@sigrun/sigrun 0.4.2 → 0.5.0

package/dist/server/conversation-ops.js

@@ -20,6 +20,7 @@ import { AgentDoc, configure } from "@earendil-works/pi-durable";
 import { accessOf, isSharing, } from "@sigrun/shared/access";
 import { extname } from "node:path";
 import { touchActivity } from "../harness/activity.js";
+import { ensureRequestId, recordAuthor, } from "../curation/attribution.js";
 import { resolveServedModelRefreshing } from "../harness/providers/refresh.js";
 import { isSuperuser } from "./auth/principal.js";
 import { isConfinedPath, parseSubmissionInput } from "./content-parts.js";
@@ -247,6 +248,9 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
     if (!parsed.ok) {
         throw new ConversationOpError({ error: "invalid_input" });
     }
+    // Every input carries a requestId (curator P1): the caller's own id, or
+    // a generated `sigrun:` UUID — the pre-admission attribution key.
+    const requestId = ensureRequestId(opts.requestId);
     // Spec §2/§3 binding contract: a conversation pinned to an unserved
     // model fails explicitly AT SUBMIT — 4xx with the available ids —
     // never a silent fallback, and never a settled no_model run surfaced
@@ -316,7 +320,11 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
     else {
         try {
             const env = await envThunk();
-            expansion = await expandInput(parsed.parts, opened.commandExpansion, env, BACKGROUND_CONTEXT);
+            // Curator A3: the learned root resolves through the conversation
+            // OWNER (SessionMetaDoc), not the submitting user — a shared-write
+            // submitter expands against the owner's learned skills.
+            const meta = await opened.harness.snapshot(SessionMetaDoc, conversation.id, BACKGROUND_CONTEXT);
+            expansion = await expandInput(parsed.parts, opened.commandExpansion, env, BACKGROUND_CONTEXT, meta?.owner);
         }
         catch (error) {
             if (error instanceof CommandUsageError) {
@@ -356,13 +364,20 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
     const draft = {
         type: "input",
         content,
-        ...(opts.requestId === undefined ? {} : { requestId: opts.requestId }),
+        requestId,
         ...(whenBusy === undefined ? {} : { whenBusy: whenBusy }),
         ...(entry === undefined ? {} : { entry }),
     };
+    // Attribution (curator P1), two writes per input: `byRequest` BEFORE the
+    // admission (the requestId exists pre-admission, so this never races; an
+    // orphan record from a failed submit is harmless) and `bySubmission`
+    // right after it returns — the key the live run's input ids resolve
+    // against. An `undefined` user records nothing (unattributed).
+    await recordAuthor(conversation, { requestId }, opts.user, BACKGROUND_CONTEXT);
     // The submit pass-through is retired (§6.7): the memory seam's
     // runSettled owns capture, so submissions admit directly.
     const submission = await conversation.submit(draft, BACKGROUND_CONTEXT);
+    await recordAuthor(conversation, { submissionId: submission.id }, opts.user, BACKGROUND_CONTEXT);
     // Admission stamps activity: the sidebar's activity sort must move the
     // moment a prompt lands — before the run settles.
     await touchActivity(opened.harness, conversation.id, opened.now, BACKGROUND_CONTEXT);
@@ -394,7 +409,10 @@ export async function listConversationsOp(ctx, caller, filters = {}) {
             // flags, and the create source (spec §9.5).
             const meta = await opened.harness.snapshot(SessionMetaDoc, record.id, BACKGROUND_CONTEXT);
             const access = accessOf(caller, meta ?? {});
-            // Hidden is absent from the list (spec §5.9).
+            // Hidden is absent from the list (spec §5.9) — and internal means
+            // hidden for EVERY caller (curator P5, accessOf rule 0): the
+            // superuser and the bridge's trusted read are covered by the same
+            // line, so no caller-specific skip can drift.
             if (access === "none")
                 continue;
             // The archived filter (absent = all).

package/dist/server/helpers.js

@@ -86,7 +86,7 @@ function autoEnableRemovals(settings, env) {
         const server = entry;
         if (server.enabled === false || server.disabled === true)
             continue;
-        // @sigrun/ext-mcp's server default is "codemode"; its pi-compat
+        // @sigrun/ext-mcp's server default is "codemode"; its deprecated
         // alias `codemode-deferred` normalizes to "codemode".
         const exposure = server.exposure === "codemode-deferred"
             ? "codemode"

package/dist/server/host-bridge.js

@@ -59,11 +59,13 @@ export function createHostBridge(ctx) {
                 const conversation = await conversationOf(id);
                 // `user` is accepted and NOT verified: extensions own their
                 // user mapping (spec §9.5) — a channel's unmapped user submits
-                // fine, and owner attribution happened at create.
+                // fine, and owner attribution happened at create. P1 records
+                // it verbatim as the input's author.
                 return await submitOp(ctx, conversation, input, {
                     ...(opts?.requestId === undefined
                         ? {}
                         : { requestId: opts.requestId }),
+                    ...(opts?.user === undefined ? {} : { user: opts.user }),
                     ...(opts?.whenBusy === undefined
                         ? {}
                         : { whenBusy: opts.whenBusy }),
@@ -284,5 +286,8 @@ export function createHostBridge(ctx) {
                 ctx.surfaces.bumpRev(slug, id, key, update);
             },
         },
+        // Curator P6 (A9): the boot-built curation host, verbatim — the
+        // ONE instance every seam host reaches through this bridge.
+        curation: ctx.opened.curationHost,
     };
 }

package/dist/server/notifications.js

@@ -132,6 +132,12 @@ export function startNotifications(ctx) {
         if (mode === "never")
             return;
         const meta = await metaOf(conversationId);
+        // Curator P5: an internal run never notifies (no "Reply ready" for
+        // curator work). The bus already withholds the host event; this is
+        // the belt-and-braces read-side gate (a hand-published or future
+        // emit path cannot leak the run).
+        if (meta?.internal === true)
+            return;
         if (mode === "cron" && meta?.source !== "cron")
             return;
         if (mode === "unwatched" &&

package/dist/server/routes/meta.js

@@ -178,8 +178,8 @@ export function registerMetaRoutes(app, ctx) {
     // templates appear the moment their files land, no reload command. The
     // core + extension halves remain boot constants; see `commands.ts` for
     // the scope rulings.
-    app.get("/v1/commands", async () => {
-        // The workspace root (the first of the three) reads through a
+    app.get("/v1/commands", async (request) => {
+        // The workspace root (the first of the four) reads through a
         // workspace env, exactly like skill discovery at generation time;
         // the catalog scan uses the root conversation's env — the static
         // workspace every conversation resolves to today.
@@ -188,7 +188,12 @@ export function registerMetaRoutes(app, ctx) {
         if (env === undefined) {
             throw new Error("envBuilder returned no ExecutionEnv");
         }
-        const skills = await listSkills(env, BACKGROUND_CONTEXT, expansion.skills);
+        // Curator A3: learned skills are the CALLER's — a user's `/skill:`
+        // menu shows their own learned skills and nobody else's (an
+        // unidentified caller sees none).
+        const skills = await listSkills(env, BACKGROUND_CONTEXT, expansion.skills, {
+            owner: request.principal.user,
+        });
         const templates = expandableTemplates(await discoverTemplates(env, BACKGROUND_CONTEXT, expansion.templates), expansion.commandNames());
         return {
             commands: [

package/dist/server/routes/submissions.js

@@ -46,6 +46,11 @@ export function registerSubmissionRoutes(app, ctx) {
                 ...(body.requestId === undefined
                     ? {}
                     : { requestId: String(body.requestId) }),
+                // Attribution (curator P1): the resolved principal's user is
+                // the input's author; an unidentified caller records nothing.
+                ...(request.principal.user === undefined
+                    ? {}
+                    : { user: request.principal.user }),
                 ...(body.whenBusy === undefined ? {} : { whenBusy: body.whenBusy }),
                 ...(request.query?.waitMs ===
                     undefined

package/dist/server/routes/surfaces.js

@@ -508,7 +508,9 @@ export function registerSurfaceRoutes(app, ctx) {
         if (chatActionStartsTurn(block.tree, body.action)) {
             const answerPayload = (body.payload ?? null);
             const wrapped = { ok: true, rev: block.state.rev };
-            await answerBlock(ctx, id, entryId, body.action, answerPayload, actionId);
+            await answerBlock(ctx, id, entryId, body.action, answerPayload, actionId, 
+            // The acting user authors the answer turn (curator P1).
+            request.principal.user);
             if (actionId !== undefined) {
                 ctx.surfaces.chatDedupRecord(actionId, address, fingerprint, wrapped);
             }

package/dist/server/routes/users.js

@@ -16,6 +16,7 @@ import { withClaimLock } from "../auth/claim-lock.js";
 import { effectiveAdmin, storedGroups } from "../../harness/identity/groups.js";
 import { transferOwnership } from "../ownership.js";
 import { validateGrantPath } from "../../sandbox/grants.js";
+import { removeUserCuration } from "../../curation/deletion.js";
 /** The wire form of one directory user. `admin` stays the STORED flag;
  * `groupAdmin` is DERIVED from stored groups and retained for one release
  * so the users UI keeps rendering. */
@@ -265,6 +266,12 @@ export function registerUserRoutes(app, ctx) {
         // §10.6 step 5: data/state stay for the recipient; core owns only
         // the departing user's credentials, settings, and every cache slug.
         await ctx.opened.extensionStores.removeUserData(user);
+        // Curator A10 (P2): the departing user's learned skills and curation
+        // state are REMOVED, never transferred — a skill distilled from
+        // their conversations can carry their paths and preferences, so it
+        // must not load for the recipient. In-flight curator runs fail
+        // closed through the stores' user-exists gate (nothing recreated).
+        await removeUserCuration(ctx.managedPaths.userAreas(user));
         return await reply.code(204).send();
     });
 }

package/dist/server/schema-fixture.js

@@ -336,6 +336,174 @@ export const VIEW_SCHEMA = {
                                                         }
                                                     }
                                                 },
+                                                {
+                                                    "kind": "object",
+                                                    "fields": {
+                                                        "name": {
+                                                            "kind": "string"
+                                                        },
+                                                        "description": {
+                                                            "kind": "string"
+                                                        },
+                                                        "parameters": {
+                                                            "kind": "object",
+                                                            "fields": {
+                                                                "type": {
+                                                                    "kind": "string"
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
+                                                                },
+                                                                "properties": {
+                                                                    "kind": "object",
+                                                                    "fields": {
+                                                                        "action": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "anyOf": {
+                                                                                    "kind": "array",
+                                                                                    "variants": [
+                                                                                        {
+                                                                                            "kind": "object",
+                                                                                            "fields": {
+                                                                                                "type": {
+                                                                                                    "kind": "string"
+                                                                                                },
+                                                                                                "const": {
+                                                                                                    "kind": "string"
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    ]
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "name": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "file_path": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "content": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "old_text": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "new_text": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "absorbed_into": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "reason": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "overlay_root": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "anyOf": {
+                                                                                    "kind": "array",
+                                                                                    "variants": [
+                                                                                        {
+                                                                                            "kind": "object",
+                                                                                            "fields": {
+                                                                                                "type": {
+                                                                                                    "kind": "string"
+                                                                                                },
+                                                                                                "const": {
+                                                                                                    "kind": "string"
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    ]
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "remove": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                },
                                                 {
                                                     "kind": "object",
                                                     "fields": {

package/dist/server/session-meta.js

@@ -29,10 +29,10 @@
  * other's fields (the mutation line serializes commits).
  *
  * Server-owned fields (`autoName`, `autoNameAttempts`,
- * `lastActivityAt`, `jobId`, `deliver`) are written by host code only
- * (activity.ts, the A2 auto-namer, fire.ts's job stamp); they are NOT
- * patch surface — the strict validator keeps rejecting them as
- * `invalid_field`.
+ * `lastActivityAt`, `jobId`, `deliver`, `internal`) are written by host
+ * code only (activity.ts, the A2 auto-namer, fire.ts's job stamp, the
+ * curator's creating commit); they are NOT patch surface — the strict
+ * validator keeps rejecting them as `invalid_field`.
  */
 import { defineDoc } from "@earendil-works/pi-durable";
 import { isSharing } from "@sigrun/shared/access";
@@ -158,12 +158,14 @@ export function validateSessionMetaPatch(body) {
             case "source":
             case "owner":
             case "jobId":
-            case "deliver": {
-                // Server-only (spec §5.9 + gateway C7): the KEY itself is the
-                // client error, whatever the value — even a `null` clear. The
-                // job stamp fields move with the fire (fire.ts's creating
-                // commit) and the delivery targets ride the job spec, never a
-                // meta patch.
+            case "deliver":
+            case "internal": {
+                // Server-only (spec §5.9 + gateway C7 + curator P5): the KEY
+                // itself is the client error, whatever the value — even a `null`
+                // clear. The job stamp fields move with the fire (fire.ts's
+                // creating commit) and the delivery targets ride the job spec,
+                // never a meta patch; the internal-run marker moves with the
+                // curator's creating commit (markInternal) alone.
                 return { error: "invalid_field", field: key };
             }
             case "sharing": {

package/dist/settings/core-sections.js

@@ -504,6 +504,15 @@ export const CORE_SETTINGS_SECTIONS = [
                                 help: "The built-in OIDC/OAuth2 login extension — applies at restart",
                                 apply: applyOf("builtinExtensions.oauth"),
                             },
+                            {
+                                type: "toggle",
+                                // Absent means ON (the built-in set defaults enabled).
+                                default: true,
+                                name: "builtinExtensions.curator",
+                                label: "Curator",
+                                help: "The built-in curator extension — applies at restart",
+                                apply: applyOf("builtinExtensions.curator"),
+                            },
                         ],
                     },
                 ],

package/dist/settings/registry.js

@@ -175,6 +175,12 @@ export const CORE_SETTING_KEYS = [
         section: "extensions",
         reason: "the built-in set resolves at boot (a disabled built-in never loads)",
     },
+    {
+        key: "builtinExtensions.curator",
+        apply: "restart",
+        section: "extensions",
+        reason: "the built-in set resolves at boot (a disabled built-in never loads)",
+    },
     {
         key: "autoEnableCodemode",
         apply: "live",