@sigrun/sigrun 0.4.2 → 0.5.0

package/dist/harness/packages.js

@@ -949,13 +949,18 @@ export async function syncGit(source, ref, gitDir, options = {}) {
     return target;
 }
 /**
- * The pi-compat `.ts` skip warning (spec §9.4): a `pi.extensions` entry
- * ending in `.ts` cannot load under plain node (the build spec removed
- * the `.ts` entry fallback) — it is skipped, keeping the package's
- * skills loadable. ONE line per skipped entry, per discovery.
+ * The `.ts` skip warning (spec §9.4): a `pi.extensions` entry ending in
+ * `.ts` cannot load under plain node (the build spec removed the `.ts`
+ * entry fallback) — it is skipped, keeping the package's skills loadable.
+ * ONE line per skipped entry, per discovery.
+ *
+ * The wording says `pi` MANIFEST rather than "pi extension" on purpose:
+ * the `pi` key is read only to LOCATE a file. Sigrun does not implement
+ * pi's extension API, so this skip is not "pi extensions don't work here";
+ * it is "this package's entry is unimportable by plain node".
  */
 function warnTsPiExtension(entry) {
-    console.warn(`pi-compat: skipping TypeScript pi extension ${entry} (not loadable under node); loading the package's skills only`);
+    console.warn(`pi manifest: skipping TypeScript entry ${entry} (not loadable under node); loading the package's skills only`);
 }
 /** Read one package root's manifest (absent/unreadable → undefined). */
 function readDiscoveryManifest(pkgRoot) {
@@ -979,9 +984,9 @@ function manifestStringArray(value) {
 }
 /**
  * A package root's manifest skill dirs (spec §9.4): `sigrun.skills`
- * (string[]) else pi-compat `pi.skills` (string[] — same SKILL.md format,
- * so no warning), each resolved against the package root, keeping only
- * EXISTING directories. No manifest, no field, or nothing existing → [].
+ * (string[]) else the `pi`-shaped `pi.skills` (string[] — same SKILL.md
+ * format, so no warning), each resolved against the package root, keeping
+ * only EXISTING directories. No manifest, no field, or nothing existing → [].
  */
 export function manifestSkills(pkgRoot) {
     const manifest = readDiscoveryManifest(pkgRoot);
@@ -1035,7 +1040,7 @@ export function manifestEntry(pkgRoot) {
             }
             return join(pkgRoot, entry);
         }
-        console.warn(`pi-compat: no loadable pi extension in ${pkgRoot} (all entries are TypeScript); loading the package's skills only`);
+        console.warn(`pi manifest: no loadable entry in ${pkgRoot} (all entries are TypeScript); loading the package's skills only`);
     }
     return undefined;
 }

package/dist/harness/reserved-sections.js

@@ -38,6 +38,8 @@ export const RESERVED_EXTENSION_SLUGS = [
     "user-settings",
     "user-secrets",
     "skills",
+    "versions",
+    "archive",
     "prompts",
     "packages",
     "git",

package/dist/harness/seam-host.js

@@ -37,6 +37,28 @@ export class SeamError extends Error {
  * boot-built store trio (one per boot, from the resolved roots); the
  * host scopes it to its identity's slug — `rekey` re-scopes in place.
  */
+/**
+ * The pre-bind forwarder for the curation surface's SYNC store members
+ * (`skills(user)`, `overlays(user)`): returns the store handle at once;
+ * every method call awaits the bridge first (the shared pending promise
+ * carries the bind deadline). Method names are read off the resolved
+ * store at call time, so the forwarder stays shape-stable.
+ */
+function syncStoreForwarder(pending, member, user) {
+    return new Proxy({}, {
+        get(_t, method) {
+            return async (...args) => {
+                const resolvedHost = (await pending);
+                const store = resolvedHost[member](user);
+                const fn = store[method];
+                if (typeof fn !== "function") {
+                    throw new Error(`curation: store ${member}(${user}) method ${String(method)} is not callable`);
+                }
+                return fn.apply(store, [...args]);
+            };
+        },
+    });
+}
 export function createSeamHost(identity, kinds, bind, sharedStores, perUserTools, services) {
     const interactionKinds = new Set(kinds.interaction ?? []);
     const ambientKinds = new Set(kinds.ambient ?? []);
@@ -79,10 +101,31 @@ export function createSeamHost(identity, kinds, bind, sharedStores, perUserTools
     const bridgePromise = new Promise((resolve) => {
         bridgeReleased = resolve;
     });
-    const hostBridge = async () => {
+    // The pre-bind bound: a bridge call that waits PAST this long fails
+    // loud instead of hanging forever (the jobs-task fake-clock hang's
+    // lesson). Production never sees it — `createServer` binds the bridge
+    // at boot, long inside the bound — but a serverless embed that never
+    // builds a server would otherwise await an eternally pending promise.
+    const bridgeDeadlineMs = 60_000;
+    const hostBridge = async (member) => {
         await bind.harness();
-        return bridgePromise;
+        return await Promise.race([
+            bridgePromise,
+            new Promise((_, reject) => {
+                const timer = setTimeout(() => {
+                    reject(new Error(`seam host: ${member} — the bridge never bound after ${bridgeDeadlineMs}ms; is createServer running? (caller: ${identity.name})`));
+                }, bridgeDeadlineMs);
+                // The rejection timer never keeps the process alive.
+                if (typeof timer === "object" && "unref" in timer)
+                    timer.unref();
+            }),
+        ]);
     };
+    // The curation surface's settled bridge host (curator P6/A9): memoized
+    // HERE — in the host closure — so every `host.curation` getter call (a
+    // FRESH proxy per read) shares one settled reference. See the getter's
+    // own comment for the sync-member discipline this serves.
+    let curationHost;
     return {
         get stores() {
             return { ...stores, user: userStores };
@@ -273,7 +316,7 @@ export function createSeamHost(identity, kinds, bind, sharedStores, perUserTools
         // re-keyed current slug, read at call time).
         conversations: {
             async create(opts = {}) {
-                const bridge = await hostBridge();
+                const bridge = await hostBridge("conversations.create");
                 return bridge.conversations.create({
                     ...(opts.owner === undefined ? {} : { owner: opts.owner }),
                     ...(opts.sharing === undefined ? {} : { sharing: opts.sharing }),
@@ -284,90 +327,160 @@ export function createSeamHost(identity, kinds, bind, sharedStores, perUserTools
                 });
             },
             async submit(id, input, opts) {
-                const bridge = await hostBridge();
+                const bridge = await hostBridge("conversations.submit");
                 return bridge.conversations.submit(id, input, opts);
             },
             async watch(id, listener) {
-                const bridge = await hostBridge();
+                const bridge = await hostBridge("conversations.watch");
                 return bridge.conversations.watch(id, listener);
             },
             async list(opts) {
-                const bridge = await hostBridge();
+                const bridge = await hostBridge("conversations.list");
                 return bridge.conversations.list(opts);
             },
             async meta(id) {
-                const bridge = await hostBridge();
+                const bridge = await hostBridge("conversations.meta");
                 return bridge.conversations.meta(id);
             },
             // The C4a ops: straight delegation (the bridge resolves the id and
             // runs the op its HTTP twin runs).
             async abort(id) {
-                return (await hostBridge()).conversations.abort(id);
+                return (await hostBridge("conversations.abort")).conversations.abort(id);
             },
             async configure(id, opts) {
-                return (await hostBridge()).conversations.configure(id, opts);
+                return (await hostBridge("conversations.configure")).conversations.configure(id, opts);
             },
             async compact(id) {
-                return (await hostBridge()).conversations.compact(id);
+                return (await hostBridge("conversations.compact")).conversations.compact(id);
             },
             async fork(id, opts) {
-                return (await hostBridge()).conversations.fork(id, opts);
+                return (await hostBridge("conversations.fork")).conversations.fork(id, opts);
             },
             async patchMeta(id, patch) {
-                return (await hostBridge()).conversations.patchMeta(id, patch);
+                return (await hostBridge("conversations.patchMeta")).conversations.patchMeta(id, patch);
             },
             // The C4b ops: same straight delegation.
             async upload(id, file) {
-                return (await hostBridge()).conversations.upload(id, file);
+                return (await hostBridge("conversations.upload")).conversations.upload(id, file);
             },
             async readFile(id, path) {
-                return (await hostBridge()).conversations.readFile(id, path);
+                return (await hostBridge("conversations.readFile")).conversations.readFile(id, path);
             },
         },
         users: {
             async list() {
-                return (await hostBridge()).users.list();
+                return (await hostBridge("users.list")).users.list();
             },
             async get(user) {
-                return (await hostBridge()).users.get(user);
+                return (await hostBridge("users.get")).users.get(user);
             },
         },
         accounts: {
             async lookup(provider, subject) {
-                return (await hostBridge()).accounts.lookup(provider, subject);
+                return (await hostBridge("accounts.lookup")).accounts.lookup(provider, subject);
             },
             async link(provider, subject, user, via) {
-                return (await hostBridge()).accounts.link(provider, subject, user, via);
+                return (await hostBridge("accounts.link")).accounts.link(provider, subject, user, via);
             },
             async unlink(provider, subject) {
-                return (await hostBridge()).accounts.unlink(provider, subject);
+                return (await hostBridge("accounts.unlink")).accounts.unlink(provider, subject);
             },
             async listForUser(user) {
-                return (await hostBridge()).accounts.listForUser(user);
+                return (await hostBridge("accounts.listForUser")).accounts.listForUser(user);
             },
         },
         access: {
             async accessOf(principal, resource) {
-                return (await hostBridge()).access.accessOf(principal, resource);
+                return (await hostBridge("access.accessOf")).access.accessOf(principal, resource);
             },
         },
         identity: {
             async actingUser(conversationId) {
-                return (await hostBridge()).identity.actingUser(conversationId);
+                return (await hostBridge("identity.actingUser")).identity.actingUser(conversationId);
             },
         },
+        // Curator P6 (A9): the boot-built curation host through the bridge —
+        // the lazy member discipline (a factory-body call waits for the
+        // bridge; a post-bind call resolves at once). Every member of the
+        // curation surface is a function, so a Proxy that forwards each
+        // property read (and call) to the RESOLVED bridge host implements
+        // the whole surface with the same wait semantics as the async
+        // delegations above. Members that return SYNCHRONOUS store objects
+        // (`skills(user)`, `overlays(user)` — store handles whose own methods
+        // are async) must come back UNAWAITED: an `async` wrapper would
+        // return a Promise of the store, and the caller's sync `.list()` —
+        // the shape the view and the targets use — would read undefined
+        // (D1's e2e found the view rendering 500 on exactly this). The
+        // settled host is memoized in the HOST closure (not the getter —
+        // every `host.curation` read returns a FRESH proxy, and a per-proxy
+        // memo would reset on each read, putting the async forwarder back
+        // in front of sync members on the second read).
+        get curation() {
+            if (curationHost !== undefined)
+                return curationHost;
+            const pending = hostBridge("curation").then((bridge) => {
+                curationHost = bridge.curation;
+                return bridge.curation;
+            });
+            // SAFETY: the Proxy target satisfies the structural member shapes
+            // because every forwarded call is an `apply` trap on the real host's
+            // own member; the cast only bridges the contract's named members.
+            return new Proxy({}, {
+                get(_target, property) {
+                    // The settled-bridge fast path: the member itself, bound — a
+                    // synchronous member (`skills`) returns its store synchronously,
+                    // an async one keeps returning its promise. The property read is
+                    // STILL a function either way (the surface has no data members),
+                    // so callers observe the contract shape unchanged.
+                    if (curationHost !== undefined) {
+                        const member = curationHost[property];
+                        if (typeof member !== "function") {
+                            throw new Error(`curation: member ${String(property)} is not callable`);
+                        }
+                        return member.bind(curationHost);
+                    }
+                    // The pre-bind window: every member becomes a forwarder that
+                    // waits for the bridge (the factory-body discipline). The
+                    // surface's SYNC store members — `skills(user)` and
+                    // `overlays(user)` return store handles whose own methods are
+                    // async (the shape the view and the steps call: `.list()` with
+                    // no await on the store itself) — must come back as a STORE,
+                    // not a promise of one (the eval's idle pass hit exactly this:
+                    // the archive step read `.list` off a promise). A lazy store
+                    // whose methods each await the bridge preserves the
+                    // sync-return contract while keeping the wait: the caller
+                    // gets the store immediately and its first method call
+                    // resolves once the bridge lands (or rejects at the bind
+                    // deadline through the shared pending promise).
+                    if (property === "skills" || property === "overlays") {
+                        return (user) => syncStoreForwarder(pending, property, user);
+                    }
+                    return async (...args) => {
+                        const resolvedHost = await pending;
+                        // SAFETY: the property is one of the contract's own function
+                        // members (the surface has no data members); the bound call is
+                        // the real host's, typed at the call site.
+                        const member = resolvedHost[property];
+                        if (typeof member !== "function") {
+                            throw new Error(`curation: member ${String(property)} is not callable`);
+                        }
+                        return member.apply(resolvedHost, [...args]);
+                    };
+                },
+            });
+        },
         // Gateway C4b: straight delegation (the bridge owns both bodies).
         models: {
             async list() {
-                return (await hostBridge()).models.list();
+                return (await hostBridge("models.list")).models.list();
             },
         },
         commands: {
             async list() {
-                return (await hostBridge()).commands.list();
+                return (await hostBridge("commands.list")).commands.list();
             },
             async run(conversationId, name, args, opts) {
-                return (await hostBridge()).commands.run(conversationId, name, args, opts);
+                return (await hostBridge("commands.run")).commands.run(conversationId, name, args, opts);
             },
         },
         // The surfaces seam (UI-blocks U3 Task 4): `changed` awaits the
@@ -385,7 +498,7 @@ export function createSeamHost(identity, kinds, bind, sharedStores, perUserTools
                     // production (nothing sets it).
                     globalThis.__sigrunSurfaceChanged?.(host.name);
                 };
-                void hostBridge()
+                void hostBridge("surfaces.changed")
                     .then((bridge) => {
                     ran();
                     bridge.surfaces.changed(identity.name, id, key, update);

package/dist/harness/settings.js

@@ -368,8 +368,8 @@ function validate(value) {
         if (builtins === undefined) {
             throw new SettingsValidationError("builtinExtensions", "must be an object");
         }
-        checkKeys("builtinExtensions.", builtins, ["codemode", "mcp", "toolSearch", "gateway", "oauth"]);
-        for (const key of ["codemode", "mcp", "toolSearch", "gateway", "oauth"]) {
+        checkKeys("builtinExtensions.", builtins, ["codemode", "mcp", "toolSearch", "gateway", "oauth", "curator"]);
+        for (const key of ["codemode", "mcp", "toolSearch", "gateway", "oauth", "curator"]) {
             if (builtins[key] !== undefined && typeof builtins[key] !== "boolean") {
                 throw new SettingsValidationError(`builtinExtensions.${key}`, "must be a boolean");
             }

package/dist/harness/tools.js

@@ -29,6 +29,7 @@
 import { Type } from "@earendil-works/pi-ai";
 import { createBashTool, createEditTool, createReadTool, createWriteTool, } from "@earendil-works/pi-durable/tools";
 import { defineExtension, defineTool } from "@earendil-works/pi-durable";
+import { SessionMetaDoc } from "../server/session-meta.js";
 // ---------------------------------------------------------------------------
 // Coding tools (read/write/edit/bash)
 // ---------------------------------------------------------------------------
@@ -77,11 +78,80 @@ export const imageReadTool = defineTool({
         return { output: [image] };
     },
 });
+/**
+ * Wrap the read tool with learned-root usage counting. The wrapper
+ * resolves the conversation owner through the api's document reader
+ * (the SessionMeta doc — the A3 pattern), and the read's absolute path
+ * against the owner's learned root; a path inside it (a SKILL.md or a
+ * support file) bumps `read` for the owning skill. The wrapped result
+ * passes through unchanged.
+ */
+export function countReadUsage(seam, base = imageReadTool) {
+    return {
+        ...base,
+        execute: async (args, api, context) => {
+            const result = await base.execute(args, api, context);
+            void countLearnedRead(seam, args.path, api, context);
+            return result;
+        },
+    };
+}
+/** Bump `read` for a learned-root path, when it lands inside one. */
+async function countLearnedRead(seam, path, api, context) {
+    try {
+        const meta = await api.snapshot(SessionMetaDoc, api.conversationId, context);
+        const owner = meta?.owner;
+        const counters = seam.countersOf(owner);
+        const root = seam.learnedRootOf(owner);
+        if (counters === undefined || root === undefined || api.env === undefined)
+            return;
+        const resolved = await api.env.absolutePath(path, context);
+        if (!resolved.ok)
+            return;
+        const skill = learnedSkillOf(resolved.value, root);
+        if (skill !== undefined) {
+            counters.bump(skill, "read");
+            void counters.flush();
+        }
+    }
+    catch {
+        // Counting is advisory: no read ever fails because usage telemetry
+        // could not resolve the owner or the path.
+    }
+}
+/** The `skills/<name>/…` segment of a path inside a learned root; `undefined` outside. */
+function learnedSkillOf(absolute, root) {
+    if (absolute === root || !absolute.startsWith(`${root}/`))
+        return undefined;
+    const rest = absolute.slice(root.length + 1).split("/");
+    const name = rest[0];
+    if (name === undefined || name === "")
+        return undefined;
+    return name;
+}
 /** `read`, `write`, `edit`, `bash` — core-installed for every conversation. */
 export const codingToolsExtension = defineExtension({
     name: "sigrun.coding-tools",
     tools: [imageReadTool, createWriteTool(), createEditTool(), createBashTool()],
 });
+/**
+ * The coding tools with learned-root usage counting (curator A6, P4):
+ * with a {@link ReadUsageSeam} the `read` tool is wrapped so reads
+ * inside the conversation owner's learned root bump the owner's
+ * counters. Without one, the plain surface — the boot default until
+ * the curation wiring hands both seam halves.
+ */
+export function createCodingToolsExtension(options) {
+    return defineExtension({
+        name: "sigrun.coding-tools",
+        tools: [
+            options === undefined ? imageReadTool : countReadUsage(options),
+            createWriteTool(),
+            createEditTool(),
+            createBashTool(),
+        ],
+    });
+}
 // ---------------------------------------------------------------------------
 // Search tools (find/grep/ls) — pure TS over ExecutionEnv
 // ---------------------------------------------------------------------------

package/dist/jobs/fire.js

@@ -39,6 +39,7 @@ import { parseModelSpec } from "../config.js";
 import { expandInput } from "../commands/expand.js";
 import { SessionMetaDoc } from "../server/session-meta.js";
 import { noteThen } from "../server/turns/submit-turn.js";
+import { recordAuthor } from "../curation/attribution.js";
 import { JobRunDoc, patchJob, readJob } from "./docs.js";
 /**
  * Fire one job under `fireKey`. `fireAt` is the epoch ms the key pins
@@ -122,7 +123,9 @@ async function jobPromptText(deps, conversationId, prompt, context) {
     if (conversation === undefined)
         return prompt;
     const env = await conversationEnv(deps, conversation);
-    const expansion = await expandInput([{ type: "text", text: prompt }], deps.commandExpansion, env, context);
+    // Curator A3: the learned root is the conversation owner's.
+    const meta = await deps.harness.snapshot(SessionMetaDoc, conversationId, context);
+    const expansion = await expandInput([{ type: "text", text: prompt }], deps.commandExpansion, env, context, meta?.owner);
     const part = expansion.parts[0];
     return part !== undefined && part.type === "text" ? part.text : prompt;
 }
@@ -175,11 +178,21 @@ async function firePrompt(deps, id, record, fireKey, baseRun, prior, context) {
             }, context);
         }
         const prompt = await jobPromptText(deps, conversationId, action.prompt, context);
-        await noteThen(deps.harness, conversation, () => conversation.submit({
-            type: "input",
-            content: [{ type: "text", text: prompt }],
-            requestId: `job:${fireKey}`,
-        }, context), context);
+        await noteThen(deps.harness, conversation, 
+        // Attribution (curator P1): the job's input is authored by the
+        // job's owner — `byRequest` before the admission, `bySubmission`
+        // after, exactly like submitOp (an ownerless job records nothing).
+        async () => {
+            const requestId = `job:${fireKey}`;
+            await recordAuthor(conversation, { requestId }, record.owner, context);
+            const submission = await conversation.submit({
+                type: "input",
+                content: [{ type: "text", text: prompt }],
+                requestId,
+            }, context);
+            await recordAuthor(conversation, { submissionId: submission.id }, record.owner, context);
+            return submission;
+        }, context);
         return { outcome: "running", conversationId };
     }
     // conversation: "new" — the run record + conversation in ONE commit.
@@ -237,11 +250,20 @@ async function firePrompt(deps, id, record, fireKey, baseRun, prior, context) {
         return { outcome: "blocked" };
     }
     const prompt = await jobPromptText(deps, conversationId, action.prompt, context);
-    await noteThen(deps.harness, conversation, () => conversation.submit({
-        type: "input",
-        content: [{ type: "text", text: prompt }],
-        requestId: `job:${fireKey}`,
-    }, context), context);
+    await noteThen(deps.harness, conversation, 
+    // Attribution (curator P1), the twin of the fixed-conversation site
+    // above: the job's owner authors the job's input.
+    async () => {
+        const requestId = `job:${fireKey}`;
+        await recordAuthor(conversation, { requestId }, record.owner, context);
+        const submission = await conversation.submit({
+            type: "input",
+            content: [{ type: "text", text: prompt }],
+            requestId,
+        }, context);
+        await recordAuthor(conversation, { submissionId: submission.id }, record.owner, context);
+        return submission;
+    }, context);
     return { outcome: "running", conversationId };
 }
 /** `<job name> · <YYYY-MM-DD HH:mm in the job's timezone>` (the plan's name). */

package/dist/jobs/skills-refs.js

@@ -0,0 +1,40 @@
+/**
+ * The core-side job skill-reference reader (curator P6, A9): the skill
+ * names a user's job PROMPTS reference — `/skill:name` tokens in every
+ * prompt action's text, from job records the durable scan sees (api,
+ * file, and extension sources alike), ENABLED AND PAUSED alike.
+ *
+ * The curator's diet step (Part B) needs this as the "job depends on
+ * this skill" signal: archiving a skill a paused job still references
+ * would break the job the moment it is re-enabled, so paused jobs count
+ * exactly as much as live ones.
+ *
+ * Pure read: one storage scan over the `sigrun.job` family (the same
+ * `scanJobs` primitive the jobs service's own reads use), filtered by
+ * owner, then a text scan for `/skill:name` tokens. No mutation, no
+ * task enumeration.
+ */
+import { scanJobs } from "./docs.js";
+/** The `/skill:name` token grammar (the expansion path's own prefix). */
+const SKILL_TOKEN = /(?:^|\s)\/skill:([A-Za-z0-9][A-Za-z0-9._-]*)/g;
+/**
+ * Every skill name the user's job prompts reference (`/skill:name`
+ * tokens), paused jobs included. A user with no jobs (or an unknown
+ * user) reads an empty set — the scan is the truth, never a directory
+ * check.
+ */
+export async function jobSkillRefs(storage, user, ctx) {
+    const jobs = await scanJobs(storage, ctx);
+    const refs = new Set();
+    for (const { record } of jobs) {
+        if (record.owner !== user)
+            continue;
+        const action = record.spec.action;
+        if (action.kind !== "prompt")
+            continue;
+        for (const match of action.prompt.matchAll(SKILL_TOKEN)) {
+            refs.add(match[1]);
+        }
+    }
+    return refs;
+}

package/dist/sandbox/policy.js

@@ -3,6 +3,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { agentEnv } from "../harness/agent-env.js";
+import { learnedSkillsDir } from "../curation/paths.js";
 import { revalidate, validateGrantPath } from "./grants.js";
 function canonical(path) {
     try {
@@ -179,6 +180,16 @@ export function buildUserPolicy(record, ctx) {
             continue;
         mkdirSync(path, { recursive: true, mode: 0o700 });
     }
+    // Curator A3: the owner's learned skills root exists and is granted
+    // read-only below. Created here (the designed empty case is an absent
+    // dir), validated like every other per-user path before entering
+    // policy — never another user's root.
+    const learned = learnedSkillsDir(userArea);
+    mkdirSync(learned, { recursive: true, mode: 0o700 });
+    const learnedValidation = validateUserPath(learned, record, ctx.managed);
+    if (!learnedValidation.ok) {
+        return invalidReason(learned, learnedValidation.reason);
+    }
     const workspaceValidation = validateUserPath(requestedWorkspace, record, ctx.managed);
     if (!workspaceValidation.ok) {
         return invalidReason(requestedWorkspace, workspaceValidation.reason);
@@ -243,6 +254,9 @@ export function buildUserPolicy(record, ctx) {
         ...moduleTrees.paths,
         defaultPackageConfig(ctx.managed.coreRoot),
         ...grants.flatMap((grant) => (grant.access === "ro" ? [grant.path] : [])),
+        // Curator A3: read access to the owner's own learned skills (support
+        // files are read with ordinary file tools); writes go through P3.
+        learnedValidation.realpath,
     ]);
     const env = agentEnv();
     delete env.SSH_AUTH_SOCK;

package/dist/server/blocks/answers.js

@@ -13,7 +13,9 @@
  * The surface's unnoted change records fold into `content` first and
  * `notedThrough` advances BEFORE the §8.3 note step runs — so the turn
  * sends no separate note for this surface, while changes on OTHER
- * surfaces still note. `requestId` makes a double click one turn.
+ * surfaces still note. `requestId` makes a double click one turn. The
+ * acting `user` rides through to `submitOp` as the answer's author
+ * (curator P1).
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { toText } from "@sigrun/shared/blocks";
@@ -30,14 +32,15 @@ import { BlocksStateDoc } from "../../harness/blocks/state.js";
  * `skipNoteFor` (this surface notes no further this turn) and the
  * answer entry. The route owns access gating and actionId dedup; this
  * caller runs only for a located, write-accessible block whose handler
- * starts a turn.
+ * starts a turn. `user` is the acting user (curator P1): recorded as the
+ * answer input's author, `undefined` for an unidentified caller.
  *
  * The fold and the `notedThrough` advance run in ONE commit BEFORE the
  * note step (§8.4: "The surface's unnoted change records are folded into
  * `content` first, and `notedThrough` advances, before the §8.3 note
  * step runs"), so the answer turn never double-reports its surface.
  */
-export async function answerBlock(ctx, conversationId, entryId, action, payload, actionId) {
+export async function answerBlock(ctx, conversationId, entryId, action, payload, actionId, user) {
     const { opened } = ctx;
     const block = await readChatBlock(opened.harness, conversationId, entryId);
     if (block === undefined) {
@@ -80,6 +83,9 @@ export async function answerBlock(ctx, conversationId, entryId, action, payload,
     }, BACKGROUND_CONTEXT);
     await submitOp(ctx, conversation, folded.content, {
         ...(actionId === undefined ? {} : { requestId: `blocks:${actionId}` }),
+        // Attribution (curator P1): the answering user authors the answer's
+        // input turn.
+        ...(user === undefined ? {} : { user }),
         skipNoteFor: entryId,
         entry: {
             kind: BlocksAnswerEntry.kind,