@sigrun/sigrun 0.8.0 → 0.10.0

package/dist/server/core-views/jobs.js

@@ -30,8 +30,10 @@
  *   principal has no view at all (`access: "none"` — the surface
  *   route's 404).
  */
+import { JobDeclaredError, JobNotFoundError, } from "../../jobs/index.js";
 import { jobAccess } from "../jobs-access.js";
 import { isSuperuser } from "../auth/principal.js";
+import { createSpecOf, emptyForm, formFromJob, formValuesOf, jobFormFields, savePatchOf, } from "./jobs-form.js";
 /** The runs page size and the revisions page size (the plan refinement). */
 export const PAGE_SIZE = 25;
 /** A schedule's summary text (the JobsPanel rule, verbatim). */
@@ -45,6 +47,23 @@ function scheduleSummary(schedule) {
         return `every ${schedule.every}`;
     return `at ${schedule.at}`;
 }
+/**
+ * The provenance line for one job, derived from its id (the id prefix IS
+ * the source). Exported for the view's tests (jobs-editor Task 2).
+ */
+export function definedInOf(id, source) {
+    if (source === "file") {
+        return `settings.json (jobs → ${id.slice("file:".length)})`;
+    }
+    if (source === "extension") {
+        return `the ${extensionSlugOf(id)} extension`;
+    }
+    return "created in sigrun";
+}
+/** The declaring extension's slug (`ext:<slug>:<name>` — the middle). */
+function extensionSlugOf(id) {
+    return id.slice("ext:".length).split(":")[0];
+}
 /** One job's sidebar/header summary fields. */
 function summaryFields(row) {
     return {
@@ -83,6 +102,8 @@ function itemIdOf(payload) {
 /** Parse the instance params (loose JSON → the typed shape; bad types drop). */
 function paramsOf(params) {
     const out = {};
+    if (params.edit === true)
+        out.edit = true;
     if (typeof params.job === "string" && params.job !== "")
         out.job = params.job;
     if (Number.isInteger(params.revision) && params.revision > 0) {
@@ -132,7 +153,7 @@ function specJson(revision) {
  * otherwise `found: false` (the main empty state), exactly the list's
  * absence rule.
  */
-async function readData(jobs, principal, params) {
+async function readData(jobs, principal, params, models) {
     const rows = [];
     let selected;
     for (const wire of await jobs.list()) {
@@ -140,7 +161,12 @@ async function readData(jobs, principal, params) {
         const access = jobAccess(principal, row);
         if (access === "none")
             continue;
-        rows.push({ id: row.id, name: row.name, ...summaryFields(row) });
+        rows.push({
+            id: row.id,
+            name: row.name,
+            description: row.description ?? null,
+            ...summaryFields(row),
+        });
         if (params.job !== undefined && row.id === params.job) {
             selected = { ...row, access };
         }
@@ -152,7 +178,16 @@ async function readData(jobs, principal, params) {
         revisions: { items: [], hasMore: false, nextRevCursor: null },
     };
     if (selected === undefined)
-        return { jobs: rows, main };
+        return { jobs: rows, main, form: emptyForm(), modelOptions: models() };
+    // The Task 4 edit seed: `{job, edit}` on a WRITABLE api job seeds
+    // `/form` from the job's current spec (a declared or read job in edit
+    // mode renders the details instead — the details keep the plain
+    // empty form, which the tree never shows there).
+    const form = params.edit === true &&
+        selected.source === "api" &&
+        selected.access === "write"
+        ? formFromJob(selected)
+        : emptyForm();
     // Runs: newest first; the cursor IS a run key (opaque to clients).
     // The service's list is bounded by the retention cap, so the view
     // fetches it whole and pages in memory.
@@ -178,9 +213,30 @@ async function readData(jobs, principal, params) {
         nextRevCursor: nextRev < allRevisions.length ? nextRev : null,
     };
     main.found = true;
+    const action = selected.action;
     main.job = {
         id: selected.id,
         name: selected.name,
+        description: selected.description ?? null,
+        definedIn: definedInOf(selected.id, selected.source),
+        owner: selected.owner ?? null,
+        source: selected.source,
+        kind: action.kind,
+        prompt: action.kind === "prompt" ? action.prompt : null,
+        model: action.kind === "prompt" ? (action.model ?? null) : null,
+        thinking: action.kind === "prompt" ? (action.thinking ?? null) : null,
+        conversation: action.kind === "prompt"
+            ? action.conversation === "new"
+                ? "new"
+                : `#${action.conversation}`
+            : null,
+        deliver: action.kind === "prompt" && action.deliver !== undefined
+            ? action.deliver.join(", ")
+            : null,
+        task: action.kind === "task" ? action.task : null,
+        taskInputMarkdown: action.kind === "task" && action.input !== undefined
+            ? `\`\`\`json\n${JSON.stringify(action.input, null, 2)}\n\`\`\``
+            : null,
         ...summaryFields(selected),
         state: selected.state,
         enabled: selected.enabled,
@@ -189,7 +245,7 @@ async function readData(jobs, principal, params) {
         // the fallback only satisfies the narrowing.
         access: selected.access === "none" ? "read" : selected.access,
     };
-    return { jobs: rows, main };
+    return { jobs: rows, main, form, modelOptions: models() };
 }
 /** The one revision selected for the diff, plus its previous (baseline). */
 function selectDiff(revisions, page, version) {
@@ -207,6 +263,12 @@ function selectDiff(revisions, page, version) {
 /** The view surface (`SurfaceDef<"view">`), built over the jobs service. */
 export function createJobsView(deps) {
     const { jobs } = deps;
+    /** The model options: Default first (id "default"), then the
+     *  catalog rows (id is the full `provider/modelId`). */
+    const modelOptions = () => [
+        { id: "default", label: "Default" },
+        ...deps.models(),
+    ];
     /** The caller's directory-aware principal (undefined user = anonymous).
      *  Whole-branch review I3: the USERLESS SUPERUSER (the naive
      *  single-operator loopback principal) is admitted — the /v1/jobs
@@ -246,8 +308,9 @@ export function createJobsView(deps) {
                     onActivate: { type: "edit", name: "openJob" },
                     item: {
                         title: { $: "./name" },
-                        subtitle: { $: "./scheduleSummary" },
+                        subtitle: { $: "./description" },
                         meta: [
+                            { text: { $: "./scheduleSummary" }, icon: "clock" },
                             { text: { $: "./nextRun" }, icon: "clock" },
                             { text: { $: "./lastOutcome" }, icon: "info" },
                         ],
@@ -285,7 +348,29 @@ export function createJobsView(deps) {
         // Blocks are built as loose JSON objects (the validator owns the
         // wire shape; the service validates every tree before serving).
         const main = [];
-        if (data.main.found && data.main.job !== null) {
+        // `{edit: true}` alone is the New-job form; `{job, edit}` edits THAT
+        // job. A declared (file:/ext:) or read-access job in edit mode falls
+        // through to the DETAILS (the editor is api+write only); an unknown
+        // `job` param with edit keeps the Task 3 rule (the form wins over
+        // "Job not found") only when NO job is selected.
+        const editingJob = params.edit === true &&
+            params.job !== undefined &&
+            data.main.found &&
+            data.main.job !== null &&
+            data.main.job.source === "api" &&
+            data.main.job.access === "write";
+        if (params.edit === true && (params.job === undefined || editingJob)) {
+            main.push({
+                type: "form",
+                id: "job-form",
+                bind: "/form",
+                mode: "submit",
+                onSubmit: editingJob ? "saveJob" : "createJob",
+                submitLabel: editingJob ? "Save" : "Create",
+                children: jobFormFields(editingJob && data.main.job !== null ? data.main.job.kind : "prompt"),
+            });
+        }
+        else if (data.main.found && data.main.job !== null) {
             const job = data.main.job;
             // IMPORTANT 3 (review fix): per-run conversation buttons ride
             // the card's `actions` as per-row LITERALS. The block contract's
@@ -326,6 +411,38 @@ export function createJobsView(deps) {
                             },
                         },
                     },
+                    // Edit/Delete are api-only (declared jobs are read-only
+                    // declarations — the `job-declared` callout says where to
+                    // edit them). The confirm copy promises the run history
+                    // survives (deleteApi retires the record; history routes
+                    // answer for retired ids).
+                    ...(job.source === "api"
+                        ? [
+                            {
+                                id: "job-edit",
+                                label: "Edit",
+                                icon: "edit",
+                                action: {
+                                    type: "navigate",
+                                    params: { job: job.id, edit: true },
+                                },
+                            },
+                            {
+                                id: "job-delete",
+                                label: "Delete",
+                                icon: "delete",
+                                action: {
+                                    type: "submit",
+                                    name: "deleteJob",
+                                    confirm: {
+                                        title: "Delete this job?",
+                                        body: "Its run history is kept.",
+                                        tone: "bad",
+                                    },
+                                },
+                            },
+                        ]
+                        : []),
                 ]
                 : [];
             main.push({
@@ -336,14 +453,34 @@ export function createJobsView(deps) {
                     {
                         type: "fields",
                         rows: [
+                            { label: "Description", value: { $: "/main/job/description" } },
+                            { label: "Defined in", value: { $: "/main/job/definedIn" } },
+                            { label: "Owner", value: { $: "/main/job/owner" } },
                             { label: "Schedule", value: { $: "/main/job/scheduleSummary" } },
                             { label: "Next run", value: { $: "/main/job/nextRun" } },
                             { label: "Last outcome", value: { $: "/main/job/lastOutcome" } },
                             { label: "Last error", value: { $: "/main/job/lastError" } },
                             { label: "State", value: { $: "/main/job/state" } },
                             { label: "Version", value: { $: "/main/job/version" } },
+                            { label: "Model", value: { $: "/main/job/model" } },
+                            { label: "Thinking", value: { $: "/main/job/thinking" } },
+                            { label: "Conversation", value: { $: "/main/job/conversation" } },
+                            { label: "Deliver", value: { $: "/main/job/deliver" } },
+                            { label: "Task", value: { $: "/main/job/task" } },
                         ],
                     },
+                    // The action body blocks: BOTH are emitted UNCONDITIONALLY.
+                    // The earlier kind-conditional form rested on a false invariant —
+                    // `bumpRev` advances `rev` only (treeRev is never written), so a
+                    // REST PATCH that changes a job's action kind would leave an open
+                    // client showing the stale body block until reload (the clients
+                    // apply fresh DATA to the SAME tree). The data-bound fix is
+                    // unconditional blocks: the off-kind binding resolves null, and
+                    // both clients render a null/empty markdown text as NOTHING
+                    // visible (webui boundString → "" in a zero-height div; pi-tui
+                    // Markdown returns zero lines for empty text).
+                    { type: "markdown", text: { $: "/main/job/prompt" } },
+                    { type: "markdown", text: { $: "/main/job/taskInputMarkdown" } },
                 ],
             }, ...(writeActions.length === 0
                 ? []
@@ -355,6 +492,21 @@ export function createJobsView(deps) {
                         title: "Actions",
                         actions: writeActions,
                     },
+                ]), 
+            // Declared jobs (file:/ext:) are READ-ONLY declarations: no edit
+            // affordances here (the editor, Tasks 3-4, is api-only) — a
+            // callout points the user at the declaring source instead.
+            ...(job.source === "api"
+                ? []
+                : [
+                    {
+                        type: "callout",
+                        id: "job-declared",
+                        tone: "neutral",
+                        title: job.source === "file"
+                            ? "Defined in settings.json — edit it there"
+                            : `Declared by the ${extensionSlugOf(job.id)} extension`,
+                    },
                 ]), {
                 type: "section",
                 id: "job-runs",
@@ -479,11 +631,21 @@ export function createJobsView(deps) {
             ...tree,
             root: {
                 ...tree.root,
+                // The New job affordance renders for ANY identified caller
+                // (createJob admits via callerOf; the form itself is inert).
+                actions: [
+                    {
+                        id: "job-new",
+                        label: "New job",
+                        icon: "add",
+                        action: { type: "navigate", params: { edit: true } },
+                    },
+                ],
                 selection: {
-                    selected: params.job !== undefined,
+                    selected: params.job !== undefined || params.edit === true,
                     back: {},
                 },
-                ...(data.main.found
+                ...(data.main.found || params.edit === true
                     ? {}
                     : {
                         empty: {
@@ -528,7 +690,7 @@ export function createJobsView(deps) {
                 return { tree: noneTree(), data: {}, access: "none" };
             }
             const params = paramsOf(ctx.params);
-            const data = await readData(jobs, caller, params);
+            const data = await readData(jobs, caller, params, modelOptions);
             const revisions = params.job === undefined || !data.main.found
                 ? []
                 : await jobs.revisions(params.job);
@@ -556,7 +718,7 @@ export function createJobsView(deps) {
             if (caller === undefined)
                 return { data: {}, access: "none" };
             const params = paramsOf(ctx.params);
-            const data = await readData(jobs, caller, params);
+            const data = await readData(jobs, caller, params, modelOptions);
             return {
                 // SAFETY: same JSON-mirror cast as `render`'s (the comment there).
                 data: data,
@@ -564,16 +726,53 @@ export function createJobsView(deps) {
             };
         },
         actions: {
+            // The New job form's submit (jobs-editor Task 3): callerOf
+            // admission (anonymous non-superuser → forbidden; the userless
+            // superuser creates with an undefined owner, matching
+            // POST /v1/jobs), then the form-owned spec assembly. Field
+            // errors come back field-scoped so the channels mark the field.
+            createJob: async (ctx, payload) => {
+                const caller = callerOf(ctx);
+                if (caller === undefined) {
+                    return { ok: false, error: { message: "forbidden" } };
+                }
+                const assembled = createSpecOf(formValuesOf(payload));
+                if (!assembled.ok) {
+                    return {
+                        ok: false,
+                        error: { message: assembled.message, field: assembled.field },
+                    };
+                }
+                let created;
+                try {
+                    created = await jobs.createApi(assembled.spec, caller.user);
+                }
+                catch (error) {
+                    return {
+                        ok: false,
+                        error: {
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                    };
+                }
+                return {
+                    ok: true,
+                    toast: `Created ${assembled.spec.name}`,
+                    navigate: { type: "navigate", params: { job: created.id } },
+                };
+            },
             // The sidebar row's drill-in (review Critical 2): the `edit`
             // activation carries {itemId} = the row's id — the JOB id, the
             // collection rows' own `id` field (the channels derive item ids
             // from it, spec §5.5) — and the accepted result carries the
             // navigate back (§6.3: SurfaceActOk.navigate passes the wire
-            // unchanged). The webui applies it (useSurface routes
-            // result.navigate through onNavigate); the TUI does NOT apply
-            // result.navigate yet — a PRE-EXISTING channel gap for every
-            // ext view's action-result navigation, out of scope here
-            // (whole-branch review ledger).
+            // unchanged). Both channels apply it: the webui's useSurface
+            // routes result.navigate through onNavigate, and the TUI's
+            // SurfaceState does the same (jobs-editor Task 7) — its
+            // accepted-result branch fires onNavigate LAST, and the app's
+            // wiring reopens the view with the params. The compact page's
+            // Esc-back dispatch (tui/src/blocks/page.ts) is genuinely
+            // routed through the same seam.
             openJob: async (ctx, payload) => {
                 // Same admission as callerOf (review I3's P1 remainder):
                 // anonymous → forbidden; the userless superuser is admitted.
@@ -615,6 +814,92 @@ export function createJobsView(deps) {
                     navigate: { type: "navigate", params: { job: jobId, revision } },
                 };
             },
+            // The Edit form's submit (jobs-editor Task 4): the job rides
+            // the instance params (the surface is principal-scoped, so the
+            // params identify the selected job — the same shape runNow
+            // uses). The caller needs write access; a declared job is the
+            // 409-class refusal; the patch rules live in savePatchOf.
+            saveJob: async (ctx, payload) => {
+                const jobId = jobIdOf(payload) ?? paramsOf(ctx.params).job;
+                if (jobId === undefined) {
+                    return {
+                        ok: false,
+                        error: { message: "saveJob needs a selected job (params.job)" },
+                    };
+                }
+                const resolved = await actionAccess(ctx, jobId);
+                if ("error" in resolved)
+                    return resolved.error;
+                if (resolved.row.source !== "api") {
+                    return { ok: false, error: { message: "job_declared" } };
+                }
+                const patched = savePatchOf(formValuesOf(payload), resolved.row);
+                if (!patched.ok) {
+                    return {
+                        ok: false,
+                        error: { message: patched.message, field: patched.field },
+                    };
+                }
+                const caller = callerOf(ctx);
+                try {
+                    await jobs.updateApi(jobId, patched.patch, caller?.user ?? "api");
+                }
+                catch (error) {
+                    if (error instanceof JobDeclaredError ||
+                        error instanceof JobNotFoundError) {
+                        return { ok: false, error: { message: error.message } };
+                    }
+                    return {
+                        ok: false,
+                        error: {
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                    };
+                }
+                return {
+                    ok: true,
+                    toast: `Saved ${patched.patch.name ?? resolved.row.name}`,
+                    navigate: { type: "navigate", params: { job: jobId } },
+                };
+            },
+            // Delete: write access, api-only, then the retired job leaves
+            // the list — navigate back to the unselected view ({}).
+            deleteJob: async (ctx, payload) => {
+                const jobId = jobIdOf(payload) ?? paramsOf(ctx.params).job;
+                if (jobId === undefined) {
+                    return {
+                        ok: false,
+                        error: { message: "deleteJob needs a selected job (params.job)" },
+                    };
+                }
+                const resolved = await actionAccess(ctx, jobId);
+                if ("error" in resolved)
+                    return resolved.error;
+                if (resolved.row.source !== "api") {
+                    return { ok: false, error: { message: "job_declared" } };
+                }
+                const caller = callerOf(ctx);
+                try {
+                    await jobs.deleteApi(jobId, caller?.user ?? "api");
+                }
+                catch (error) {
+                    if (error instanceof JobDeclaredError ||
+                        error instanceof JobNotFoundError) {
+                        return { ok: false, error: { message: error.message } };
+                    }
+                    return {
+                        ok: false,
+                        error: {
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                    };
+                }
+                return {
+                    ok: true,
+                    toast: `Deleted ${resolved.row.name}`,
+                    navigate: { type: "navigate", params: {} },
+                };
+            },
             runNow: async (ctx, payload) => {
                 const jobId = jobIdOf(payload) ?? paramsOf(ctx.params).job;
                 if (jobId === undefined) {

package/dist/server/core-views/skills-tree.js

@@ -346,20 +346,11 @@ function skillActions(params, historyAvailable, deleted) {
     }
     return buttons;
 }
-/** The form fields (new skill vs edit: the name is read-only on an existing skill). */
+/** The form fields (new skill vs edit: the name is read-only on an
+ *  existing skill). A new skill always lands in the workspace: the
+ *  learned root is the curator's, so the form offers no choice. */
 function formFields(editingExisting) {
-    const whereChoice = {
-        type: "choice",
-        name: "where",
-        label: "Where",
-        required: true,
-        options: [
-            { id: "workspace", label: "Workspace" },
-            { id: "learned", label: "Learned" },
-        ],
-    };
     return [
-        ...(editingExisting ? [] : [whereChoice]),
         {
             type: "text",
             name: "name",

package/dist/server/core-views/skills.js

@@ -436,7 +436,7 @@ export function createSkillsView(deps) {
     /** The form's pre-filled values (a new skill starts empty; an edit reads the current text). */
     async function formDataOf(params, selection) {
         if (params.skill === undefined || selection === undefined) {
-            return { name: "", description: "", body: "", where: "workspace" };
+            return { name: "", description: "", body: "" };
         }
         try {
             const text = await readSkillFile(selection.skill.rootDir, selection.skill.name, "SKILL.md");
@@ -445,7 +445,6 @@ export function createSkillsView(deps) {
                 name: selection.skill.name,
                 description: parsed?.description ?? selection.skill.description,
                 body: parsed?.body ?? "",
-                where: "workspace",
             };
         }
         catch {
@@ -453,7 +452,6 @@ export function createSkillsView(deps) {
                 name: selection.skill.name,
                 description: selection.skill.description,
                 body: "",
-                where: "workspace",
             };
         }
     }
@@ -722,34 +720,24 @@ export function createSkillsView(deps) {
                 const user = userOf(ctx);
                 if (user === undefined)
                     return { ok: false, error: { message: "forbidden" } };
-                const where = fieldOf(payload, "where") ?? "workspace";
+                // New skills land in the workspace only: the learned root is
+                // the curator's (a user edits, pins or deletes learned skills,
+                // never creates one).
+                const where = fieldOf(payload, "where");
+                if (where !== undefined && where !== "workspace") {
+                    return {
+                        ok: false,
+                        error: { message: "new skills go in the workspace; learned skills come from the curator", field: "where" },
+                    };
+                }
                 const name = fieldOf(payload, "name");
                 const description = fieldOf(payload, "description");
-                const body = fieldOf(payload, "body");
                 if (name === undefined || !validSkillName(name)) {
                     return { ok: false, error: { message: "a valid skill name is required (lowercase letters, digits, dashes)", field: "name" } };
                 }
                 if (description === undefined || description.trim() === "") {
                     return { ok: false, error: { message: "a description is required", field: "description" } };
                 }
-                if (where === "learned") {
-                    const curation = deps.curationOf(user);
-                    if (curation === undefined) {
-                        return { ok: false, error: { message: "learned skills are unavailable" } };
-                    }
-                    try {
-                        await curation.store.apply(name, { kind: "create", content: skillFileText(name, description.trim(), body ?? "") }, { actor: "user" });
-                    }
-                    catch (error) {
-                        return failure(error);
-                    }
-                    deps.bump();
-                    return {
-                        ok: true,
-                        toast: `Created ${name}`,
-                        navigate: { type: "navigate", params: { skill: name, root: "learned" } },
-                    };
-                }
                 return workspaceWrite(ctx, payload, { mode: "create" });
             },
             save: async (ctx, payload) => {

package/dist/server/host-bridge.js

@@ -17,6 +17,7 @@
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { accessOf as accessOfShared } from "@sigrun/shared/access";
+import { completeOnce } from "../harness/complete.js";
 import { effectiveAdmin } from "../harness/identity/groups.js";
 import { userWire } from "./routes/users.js";
 import { accessPrincipalOf } from "./auth/access-principal.js";
@@ -24,6 +25,7 @@ import { abortOp, compactOp, configureOp, ConversationOpError, createConversatio
 import { listModels } from "./helpers.js";
 import { notifyExtension } from "./notifications.js";
 import { SessionMetaDoc } from "./session-meta.js";
+import { isJobRunConversation } from "../harness/interactive-tools.js";
 import { accountLinkWire, serializeConversationView } from "./views.js";
 /**
  * Host-side callers see effective admin derived from stored groups;
@@ -70,6 +72,9 @@ export function createHostBridge(ctx) {
                     ...(opts?.whenBusy === undefined
                         ? {}
                         : { whenBusy: opts.whenBusy }),
+                    // Ask-user Task 2: a host submit counts as a human message
+                    // (declines pending questions) only when it carries a user.
+                    declinesQuestions: opts?.user !== undefined,
                 });
             },
             async watch(id, listener) {
@@ -193,6 +198,32 @@ export function createHostBridge(ctx) {
                     state: job.state,
                 };
             },
+            async activeRun(conversationId) {
+                const jobs = await opened.jobs.list();
+                let best;
+                for (const job of jobs) {
+                    const run = job.lastRun;
+                    if (run === undefined)
+                        continue;
+                    if (run.outcome !== "running")
+                        continue;
+                    if (run.conversationId !== Number(conversationId))
+                        continue;
+                    if (best !== undefined && run.startedAt <= best.startedAt)
+                        continue;
+                    best = { jobId: job.id, owner: job.owner, startedAt: run.startedAt };
+                }
+                // startedAt is the tiebreak only — the wire shape is {jobId, owner}.
+                return best === undefined ? undefined : { jobId: best.jobId, owner: best.owner };
+            },
+            async isJobRun(conversationId) {
+                // The detection reads COMMITTED durable state (session meta,
+                // the live doc, submission records) — it never participates in
+                // the caller's transaction, so the bridge's own background
+                // context is the honest one (the HandlerContext arg is a
+                // cancellation surface only).
+                return await isJobRunConversation(opened.harness, conversationId, BACKGROUND_CONTEXT);
+            },
         },
         users: {
             // The directory in wire form (emails are admin material; the
@@ -252,11 +283,32 @@ export function createHostBridge(ctx) {
             },
         },
         // Gateway C4b: the model catalog — the SAME source function the
-        // `GET /v1/models` route serves (one construction, never two).
+        // `GET /v1/models` route serves (one construction, never two) —
+        // plus one-shot completions (warden Task 4), read-live settings
+        // per call so a `namingModel` change applies without a restart.
+        // Warden Task 6: the decision registry — the seam host's
+        // `decisions` members delegate here; `slug` is the CALLING
+        // extension's identity (read at call time), which the registry
+        // stamps as `caller` on the provider's context.
+        decisions: {
+            async evaluate(slug, request, opts = {}) {
+                return opened.decisions.evaluate(slug, request, opts);
+            },
+            async list() {
+                return opened.decisions.list();
+            },
+        },
         models: {
             async list() {
                 return listModels(opened);
             },
+            async complete(input) {
+                return completeOnce({
+                    models: opened.models,
+                    defaultModel: opened.defaultModel,
+                    readSettings: () => opened.settings.read(),
+                }, input);
+            },
         },
         commands: {
             // The merged catalog rows (`GET /v1/commands`' core + extension

package/dist/server/index.js

@@ -42,7 +42,7 @@ import { effectiveMethods } from "../config.js";
 import { registerAuthPipeline } from "./auth/pipeline.js";
 import { isLoopbackHost } from "./auth/loopback.js";
 import { SseRegistry } from "./sse-registry.js";
-import { storeAgentChange } from "./helpers.js";
+import { listModels, storeAgentChange } from "./helpers.js";
 import { registerCoreOwnershipParticipant } from "./ownership.js";
 import { createJobsView } from "./core-views/jobs.js";
 import { createSkillsView } from "./core-views/skills.js";
@@ -324,6 +324,7 @@ export async function createServer(opened, config, contributedBundles = [], opti
         createJobsView({
             jobs: opened.jobs,
             now: () => new Date(),
+            models: () => listModels(opened).map((m) => ({ id: m.id, label: m.name })),
             accessPrincipal: (principal) => accessPrincipalOf(principal, opened.identity.users),
         }),
         createSkillsView({