chore: initial scaffold — workspace, docs, blueprint

Sets up the PiCloud monorepo as a Cargo workspace organised around the
three-service architecture (manager / orchestrator / executor), each
backed by a *-core library crate so the same logic powers both the MVP
all-in-one `picloud` binary and the future split-process cluster mode.

  * crates/shared, executor-core, orchestrator-core, manager-core
    define the library surface and trait seams between the three
    services (`ExecutorClient`, `ScriptResolver`, `ScriptRepository`).
  * crates/picloud is the MVP entrypoint; serves /healthz on 8080
    (override via PICLOUD_BIND).
  * crates/picloud-{manager,orchestrator,executor} are skeleton
    binaries that keep the crate boundaries honest until cluster
    mode is built out in v1.3+.
  * docs/git-workflow.md defines the trunk-based workflow:
    short-lived branches, Conventional Commits, separate hotfix
    flow with mandatory reproduction tests.
  * CLAUDE.md captures the working rules for future Claude sessions.

Workspace passes `cargo fmt`, `cargo clippy -D warnings` (with
pedantic enabled), and `cargo test --workspace`. The all-in-one
binary responds on `/healthz` and `/`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

README.md

@@ -0,0 +1,54 @@
+# PiCloud
+
+A lightweight, self-hosted, event-driven serverless compute platform. Upload a [Rhai](https://rhai.rs/) script, get an HTTP endpoint. Designed to run on a single modest server with no idle CPU cost, and to scale out to a small cluster when you need it.
+
+> **Status:** Phase 1 — MVP scaffolding in progress.
+>
+> The authoritative design lives in [`serverless_cloud_blueprint.md`](serverless_cloud_blueprint.md).
+
+## Why
+
+Existing serverless platforms are either cloud-locked, heavyweight, or both. PiCloud aims for the opposite end of the spectrum: one binary, one database, one reverse proxy — running on hardware you already own.
+
+## Architecture (one paragraph)
+
+PiCloud splits into three logical services — **manager** (control plane: scripts, schedules, dashboard), **orchestrator** (per-node event ingress and dispatch), and **executor** (per-node Rhai sandbox) — each backed by a `*-core` Rust library. In MVP they run in a single process; in cluster mode they run as three binaries with one manager and one orchestrator + executor per node. [Caddy](https://caddyserver.com/) fronts everything; [PostgreSQL](https://www.postgresql.org/) is the single source of truth.
+
+See [`CLAUDE.md`](CLAUDE.md) for working notes and [`serverless_cloud_blueprint.md`](serverless_cloud_blueprint.md) for the full design.
+
+## Quick Start
+
+> _Coming as scaffolding lands. For now:_
+
+```sh
+# Rust toolchain (pinned via rust-toolchain.toml)
+cargo check --workspace
+
+# Run the all-in-one MVP binary (once main.rs is wired up)
+cargo run -p picloud
+```
+
+## Repository Layout
+
+```
+crates/
+  shared/                 cross-cutting types
+  executor-core/          Rhai engine + sandbox
+  orchestrator-core/      event ingress, dispatch
+  manager-core/           control plane
+  picloud/                MVP all-in-one binary
+  picloud-{manager,orchestrator,executor}/   cluster-mode binaries (skeleton)
+dashboard/                SvelteKit
+caddy/                    Caddyfile
+docker/                   Dockerfiles
+docs/
+  git-workflow.md         Trunk-based workflow
+```
+
+## Contributing
+
+See [`docs/git-workflow.md`](docs/git-workflow.md) for the branching and commit conventions. TL;DR: trunk-based, short-lived branches, Conventional Commits, no force-pushing `main`.
+
+## License
+
+TBD.