feat: persist execution logs + dashboard detail view + integration tests

Three threads landing together because they share a public surface
(the new execution_log shape) and verifying any one in isolation
would mean re-doing the work later.

== (A) execution log persistence ==

  * shared::ExecutionLog + ExecutionStatus carry the audit-trail
    shape that flows from the orchestrator through the sink and
    back out via the manager's logs endpoint.

  * shared::ExecutionLogSink trait — abstraction the orchestrator
    writes through. In single-process MVP mode the manager's
    Postgres-backed impl is plugged in directly; in cluster mode
    (v1.3+) the orchestrator's impl will post over HTTP to the
    manager. Trait lives in `shared` so neither *-core crate has
    to know about the other.

  * manager-core::PostgresExecutionLogSink writes to the
    execution_logs table (already in the initial migration);
    PostgresExecutionLogRepository reads them back, paginated.
    AdminState now carries both a script repo and a log repo, so
    `admin_router` exposes `GET /scripts/{id}/logs?limit=&offset=`
    capped at 200 rows per page to keep the dashboard responsive.

  * orchestrator-core::DataPlaneState gains `log_sink`. The
    execute handler builds an ExecutionLog on every outcome —
    success, error, timeout, budget-exceeded — and awaits the
    sink. Sink failures are logged at warn and DO NOT mask the
    user-facing result, since "we couldn't write the audit row"
    is a separate concern from "the script ran".

  * picloud binary refactored into a lib (`build_app(pool)` is
    the seam) + thin bin shell. Same Postgres pool backs the
    script repo, the log repo, and the sink — no double pool.

== (B) dashboard ==

  * Typed API client extended with `scripts.logs(id, opts)`,
    `scripts.update/remove`, and `execute(id, body, headers)`.
    Plain `fetch` wrapper now surfaces server-side error
    messages via a typed ApiError so the UI can render them.

  * `/` — create-script form now actually creates; on success
    the list reloads. List entries link to detail.

  * `/scripts/[id]` — new detail route: source editor with save
    (calls update, version bumps); Test invoke panel that sends
    arbitrary JSON body + headers to /api/execute and shows the
    response; Recent executions panel reading from /logs with
    expandable per-row request/response/script-log views.
    Delete button with confirm. SPA-routed; Caddy serves
    `build/` with the same index.html fallback.

== (C) integration tests ==

  * crates/picloud/tests/api.rs — 14 sqlx::test cases driving
    `build_app` through an axum_test::TestServer against a fresh
    Postgres DB per test. Covers: health, full script CRUD,
    duplicate-name conflict, invalid-source rejection on both
    create and update, execute echoing the body, status+header
    passthrough, 404 on missing scripts, error-path executions
    landing in the audit log with the right status.

  * Tests are `#[ignore]` by default so plain `cargo test
    --workspace` stays green without infrastructure. Opt-in via:
    `docker compose up -d postgres && \
       DATABASE_URL=postgres://picloud:picloud@127.0.0.1:15432/picloud \
       cargo test -p picloud --test api -- --include-ignored`

Verified live through Caddy on :8000: three logged invocations
land in the logs endpoint with the right structured `data` on
each `log::info`/`log::warn`, error-path executions are still
captured with status=error, dashboard list + SPA detail route
both reachable.

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

crates/manager-core/src/api.rs

@@ -11,23 +11,27 @@ use axum::{
     routing::get,
     Json, Router,
 };
-use picloud_shared::{Script, ScriptId, ScriptValidator, ValidationError};
+use picloud_shared::{ExecutionLog, Script, ScriptId, ScriptValidator, ValidationError};
 use serde::Deserialize;
 
-use crate::repo::{NewScript, ScriptPatch, ScriptRepository, ScriptRepositoryError};
+use crate::repo::{
+    ExecutionLogRepository, NewScript, ScriptPatch, ScriptRepository, ScriptRepositoryError,
+};
 
 /// State shared by control-plane handlers. Separates concerns so the
 /// manager can validate at upload time without depending on the
 /// concrete executor-core types.
-pub struct AdminState<R> {
+pub struct AdminState<R, L> {
     pub repo: Arc<R>,
+    pub logs: Arc<L>,
     pub validator: Arc<dyn ScriptValidator>,
 }
 
-impl<R> Clone for AdminState<R> {
+impl<R, L> Clone for AdminState<R, L> {
     fn clone(&self) -> Self {
         Self {
             repo: self.repo.clone(),
+            logs: self.logs.clone(),
             validator: self.validator.clone(),
         }
     }
@@ -35,15 +39,23 @@ impl<R> Clone for AdminState<R> {
 
 /// Build the admin router. The caller (binary) chooses where to mount
 /// it (typically `Router::new().nest("/api/admin", admin_router(state))`).
-pub fn admin_router<R: ScriptRepository + 'static>(state: AdminState<R>) -> Router {
+pub fn admin_router<R, L>(state: AdminState<R, L>) -> Router
+where
+    R: ScriptRepository + 'static,
+    L: ExecutionLogRepository + 'static,
+{
     Router::new()
-        .route("/scripts", get(list_scripts::<R>).post(create_script::<R>))
+        .route(
+            "/scripts",
+            get(list_scripts::<R, L>).post(create_script::<R, L>),
+        )
         .route(
             "/scripts/{id}",
-            get(get_script::<R>)
-                .put(update_script::<R>)
-                .delete(delete_script::<R>),
+            get(get_script::<R, L>)
+                .put(update_script::<R, L>)
+                .delete(delete_script::<R, L>),
         )
+        .route("/scripts/{id}/logs", get(list_logs::<R, L>))
         .with_state(state)
 }
 
@@ -85,14 +97,14 @@ where
 // Handlers
 // ----------------------------------------------------------------------------
 
-async fn list_scripts<R: ScriptRepository>(
-    State(state): State<AdminState<R>>,
+async fn list_scripts<R: ScriptRepository, L: ExecutionLogRepository>(
+    State(state): State<AdminState<R, L>>,
 ) -> Result<Json<Vec<Script>>, ApiError> {
     Ok(Json(state.repo.list().await?))
 }
 
-async fn get_script<R: ScriptRepository>(
-    State(state): State<AdminState<R>>,
+async fn get_script<R: ScriptRepository, L: ExecutionLogRepository>(
+    State(state): State<AdminState<R, L>>,
     Path(id): Path<ScriptId>,
 ) -> Result<Json<Script>, ApiError> {
     state
@@ -103,8 +115,8 @@ async fn get_script<R: ScriptRepository>(
         .ok_or(ApiError::NotFound(id))
 }
 
-async fn create_script<R: ScriptRepository>(
-    State(state): State<AdminState<R>>,
+async fn create_script<R: ScriptRepository, L: ExecutionLogRepository>(
+    State(state): State<AdminState<R, L>>,
     Json(input): Json<CreateScriptRequest>,
 ) -> Result<(StatusCode, Json<Script>), ApiError> {
     state.validator.validate(&input.source)?;
@@ -121,8 +133,8 @@ async fn create_script<R: ScriptRepository>(
     Ok((StatusCode::CREATED, Json(created)))
 }
 
-async fn update_script<R: ScriptRepository>(
-    State(state): State<AdminState<R>>,
+async fn update_script<R: ScriptRepository, L: ExecutionLogRepository>(
+    State(state): State<AdminState<R, L>>,
     Path(id): Path<ScriptId>,
     Json(input): Json<UpdateScriptRequest>,
 ) -> Result<Json<Script>, ApiError> {
@@ -145,14 +157,39 @@ async fn update_script<R: ScriptRepository>(
     Ok(Json(updated))
 }
 
-async fn delete_script<R: ScriptRepository>(
-    State(state): State<AdminState<R>>,
+async fn delete_script<R: ScriptRepository, L: ExecutionLogRepository>(
+    State(state): State<AdminState<R, L>>,
     Path(id): Path<ScriptId>,
 ) -> Result<StatusCode, ApiError> {
     state.repo.delete(id).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
+#[derive(Debug, Deserialize)]
+pub struct LogsQuery {
+    #[serde(default = "default_limit")]
+    pub limit: i64,
+    #[serde(default)]
+    pub offset: i64,
+}
+
+const fn default_limit() -> i64 {
+    50
+}
+
+async fn list_logs<R: ScriptRepository, L: ExecutionLogRepository>(
+    State(state): State<AdminState<R, L>>,
+    Path(id): Path<ScriptId>,
+    axum::extract::Query(q): axum::extract::Query<LogsQuery>,
+) -> Result<Json<Vec<ExecutionLog>>, ApiError> {
+    // Cap to keep the dashboard responsive; the data plane writes are
+    // unbounded over time so a paged read is the only sane default.
+    let limit = q.limit.clamp(1, 200);
+    let offset = q.offset.max(0);
+    let logs = state.logs.list_for_script(id, limit, offset).await?;
+    Ok(Json(logs))
+}
+
 // ----------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------