feat: end-to-end script CRUD + Rhai execution

Brings the MVP feature set online: upload a Rhai script, get an HTTP
endpoint that runs it sandboxed in-process, list/update/delete it, and
have invalid sources rejected at upload time. Verified live through
Caddy with a full lifecycle (`create → list → get → execute → update
→ delete`) plus error paths (syntax error, duplicate name, deleted).

Layout — every concern lands behind the trait seam its layer owns, so
cluster-mode in v1.3+ is a swap of two impls, not a rewrite:

  * shared::ScriptValidator — manager calls into validation without
    a hard dep on executor-core; executor-core impls the trait on
    `Engine`. Pinned in shared so neither crate has to know about
    the other.

  * executor-core::Engine — real Rhai engine: sandbox limits (max
    operations / string size / map size / call depth), disabled
    `print`, blocked `import` (DummyModuleResolver), `log::trace
    /info/warn/error` registered as a static module with shared
    log-capture buffer (no `log::debug` because `debug` is a Rhai
    reserved keyword — `log::trace` covers the same need).

      - `ctx` is pushed as a Scope constant exposing
        execution_id, script_id, script_name, request_id,
        invocation_type, request.{path,headers,body}.

      - Response convention: a Map with `statusCode` is the
        structured shape (`{statusCode, headers?, body}`); any
        other return value is a 200 with the value as the body.

      - Engine::execute is now synchronous (pure compute); the
        async wrapper + wall-clock timeout live in
        LocalExecutorClient, which spawns_blocking and applies a
        300s hard ceiling regardless of per-script config.

      - 10 unit tests cover validate, exec, structured response,
        ctx exposure, log capture, op-budget enforcement, runtime
        errors, blocked imports, JSON round-tripping.

  * manager-core::repo — full sqlx CRUD over the `scripts` table,
    with proper unique-violation handling for duplicate names.
    Embedded migrations via `sqlx::migrate!` (one initial
    `0001_init.sql` for pgcrypto + scripts + execution_logs).

  * manager-core::api — `admin_router` mounts `/scripts` and
    `/scripts/{id}`. Create + Update validate source through the
    injected `ScriptValidator` before persistence. Returns proper
    422/409/404 status codes via `ApiError::IntoResponse`.

  * orchestrator-core::api — `data_plane_router` mounts
    `/execute/{id}`: resolves the script through `ScriptResolver`,
    constructs the `ExecRequest` from headers+body, awaits
    `ExecutorClient::execute(..., timeout)`, translates the
    `ExecResponse` to an axum `Response` with header passthrough.
    Maps `ExecError` variants to 422/504/502/507.

  * picloud all-in-one — opens the pool, runs migrations, builds
    one engine, nests both routers under `/api/admin` and `/api`,
    enables structured JSON tracing and graceful shutdown on
    SIGTERM. Single `PostgresScriptRepository` Arc is shared by
    the admin router (writes) and the resolver (reads).

Other changes:
  * Workspace axum bump 0.7 → 0.8 for the `{id}` path syntax
    matching the route definitions.
  * Workspace clippy: allow `needless_pass_by_value` and
    `boxed_local` to keep API ergonomics over pedantic noise.

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

crates/manager-core/src/repo.rs

@@ -10,6 +10,9 @@ pub enum ScriptRepositoryError {
 
     #[error("not found: {0}")]
     NotFound(ScriptId),
+
+    #[error("conflict: {0}")]
+    Conflict(String),
 }
 
 /// CRUD over the `scripts` table.
@@ -17,11 +20,36 @@ pub enum ScriptRepositoryError {
 pub trait ScriptRepository: Send + Sync {
     async fn get(&self, id: ScriptId) -> Result<Option<Script>, ScriptRepositoryError>;
     async fn list(&self) -> Result<Vec<Script>, ScriptRepositoryError>;
-    async fn create(&self, script: &Script) -> Result<(), ScriptRepositoryError>;
-    async fn update(&self, script: &Script) -> Result<(), ScriptRepositoryError>;
+    async fn create(&self, input: NewScript) -> Result<Script, ScriptRepositoryError>;
+    async fn update(
+        &self,
+        id: ScriptId,
+        patch: ScriptPatch,
+    ) -> Result<Script, ScriptRepositoryError>;
     async fn delete(&self, id: ScriptId) -> Result<(), ScriptRepositoryError>;
 }
 
+/// Inbound shape for create. Defaults match the migration's CHECK
+/// constraints; the repo enforces them in the DB regardless.
+#[derive(Debug, Clone)]
+pub struct NewScript {
+    pub name: String,
+    pub description: Option<String>,
+    pub source: String,
+    pub timeout_seconds: Option<i32>,
+    pub memory_limit_mb: Option<i32>,
+}
+
+/// Inbound shape for update. `None` fields are left untouched.
+#[derive(Debug, Clone, Default)]
+pub struct ScriptPatch {
+    pub name: Option<String>,
+    pub description: Option<Option<String>>,
+    pub source: Option<String>,
+    pub timeout_seconds: Option<i32>,
+    pub memory_limit_mb: Option<i32>,
+}
+
 pub struct PostgresScriptRepository {
     pool: PgPool,
 }
@@ -31,37 +59,145 @@ impl PostgresScriptRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
+
+    #[must_use]
+    pub fn pool(&self) -> &PgPool {
+        &self.pool
+    }
 }
 
-// Real query bodies land alongside the first migration. Stubbing the trait
-// impl so the workspace compiles and the seam is visible.
 #[async_trait]
 impl ScriptRepository for PostgresScriptRepository {
-    async fn get(&self, _id: ScriptId) -> Result<Option<Script>, ScriptRepositoryError> {
-        let _ = &self.pool;
-        Ok(None)
+    async fn get(&self, id: ScriptId) -> Result<Option<Script>, ScriptRepositoryError> {
+        let row = sqlx::query_as::<_, ScriptRow>(
+            "SELECT id, name, description, version, source, \
+                    timeout_seconds, memory_limit_mb, created_at, updated_at \
+             FROM scripts WHERE id = $1",
+        )
+        .bind(id.into_inner())
+        .fetch_optional(&self.pool)
+        .await?;
+        Ok(row.map(Into::into))
     }
 
     async fn list(&self) -> Result<Vec<Script>, ScriptRepositoryError> {
-        Ok(Vec::new())
+        let rows = sqlx::query_as::<_, ScriptRow>(
+            "SELECT id, name, description, version, source, \
+                    timeout_seconds, memory_limit_mb, created_at, updated_at \
+             FROM scripts ORDER BY name",
+        )
+        .fetch_all(&self.pool)
+        .await?;
+        Ok(rows.into_iter().map(Into::into).collect())
     }
 
-    async fn create(&self, _script: &Script) -> Result<(), ScriptRepositoryError> {
-        Ok(())
+    async fn create(&self, input: NewScript) -> Result<Script, ScriptRepositoryError> {
+        let res = sqlx::query_as::<_, ScriptRow>(
+            "INSERT INTO scripts (name, description, source, timeout_seconds, memory_limit_mb) \
+             VALUES ($1, $2, $3, COALESCE($4, 30), COALESCE($5, 256)) \
+             RETURNING id, name, description, version, source, \
+                       timeout_seconds, memory_limit_mb, created_at, updated_at",
+        )
+        .bind(&input.name)
+        .bind(input.description.as_deref())
+        .bind(&input.source)
+        .bind(input.timeout_seconds)
+        .bind(input.memory_limit_mb)
+        .fetch_one(&self.pool)
+        .await;
+
+        match res {
+            Ok(row) => Ok(row.into()),
+            Err(sqlx::Error::Database(e)) if e.is_unique_violation() => {
+                Err(ScriptRepositoryError::Conflict(format!(
+                    "a script named {:?} already exists",
+                    input.name
+                )))
+            }
+            Err(e) => Err(e.into()),
+        }
     }
 
-    async fn update(&self, _script: &Script) -> Result<(), ScriptRepositoryError> {
-        Ok(())
+    async fn update(
+        &self,
+        id: ScriptId,
+        patch: ScriptPatch,
+    ) -> Result<Script, ScriptRepositoryError> {
+        // COALESCE-based partial update: `NULL` parameters leave columns
+        // untouched. Description is double-Optioned so callers can
+        // explicitly set it to NULL (Some(None)) vs leave it alone (None).
+        let row = sqlx::query_as::<_, ScriptRow>(
+            "UPDATE scripts SET \
+                name = COALESCE($2, name), \
+                description = CASE WHEN $3::bool THEN $4 ELSE description END, \
+                source = COALESCE($5, source), \
+                timeout_seconds = COALESCE($6, timeout_seconds), \
+                memory_limit_mb = COALESCE($7, memory_limit_mb), \
+                version = version + 1, \
+                updated_at = NOW() \
+             WHERE id = $1 \
+             RETURNING id, name, description, version, source, \
+                       timeout_seconds, memory_limit_mb, created_at, updated_at",
+        )
+        .bind(id.into_inner())
+        .bind(patch.name.as_deref())
+        .bind(patch.description.is_some())
+        .bind(patch.description.as_ref().and_then(|d| d.as_deref()))
+        .bind(patch.source.as_deref())
+        .bind(patch.timeout_seconds)
+        .bind(patch.memory_limit_mb)
+        .fetch_optional(&self.pool)
+        .await?;
+
+        row.map(Into::into)
+            .ok_or(ScriptRepositoryError::NotFound(id))
     }
 
-    async fn delete(&self, _id: ScriptId) -> Result<(), ScriptRepositoryError> {
+    async fn delete(&self, id: ScriptId) -> Result<(), ScriptRepositoryError> {
+        let res = sqlx::query("DELETE FROM scripts WHERE id = $1")
+            .bind(id.into_inner())
+            .execute(&self.pool)
+            .await?;
+        if res.rows_affected() == 0 {
+            return Err(ScriptRepositoryError::NotFound(id));
+        }
         Ok(())
     }
 }
 
+/// Row shape mirroring the `scripts` table for sqlx FromRow.
+#[derive(sqlx::FromRow)]
+struct ScriptRow {
+    id: uuid::Uuid,
+    name: String,
+    description: Option<String>,
+    version: i32,
+    source: String,
+    timeout_seconds: i32,
+    memory_limit_mb: i32,
+    created_at: chrono::DateTime<chrono::Utc>,
+    updated_at: chrono::DateTime<chrono::Utc>,
+}
+
+impl From<ScriptRow> for Script {
+    fn from(r: ScriptRow) -> Self {
+        Self {
+            id: r.id.into(),
+            name: r.name,
+            description: r.description,
+            version: r.version,
+            source: r.source,
+            timeout_seconds: u32::try_from(r.timeout_seconds).unwrap_or(30),
+            memory_limit_mb: u32::try_from(r.memory_limit_mb).unwrap_or(256),
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+        }
+    }
+}
+
 /// Adapts a `ScriptRepository` into the `ScriptResolver` trait the
-/// orchestrator depends on, so we don't pull the manager into the
-/// orchestrator's dependency graph.
+/// orchestrator depends on. Keeps orchestrator-core unaware of how
+/// scripts are stored.
 pub struct RepoResolver<R: ScriptRepository> {
     repo: R,
 }