@sigrun/sigrun 0.4.2 → 0.6.0

package/dist/harness/loader.js

@@ -93,6 +93,7 @@ import { satisfies, validRange } from "semver";
 import { HOST_RUNTIME_MODULES, hostModuleVersion, readPackageAssetsDir, readPackageName, readPackageVersion, resolveExtensionEntry, } from "./packages.js";
 import { RESERVED_CORE_SECTION_KEYS, RESERVED_EXTENSION_SLUGS, } from "./reserved-sections.js";
 import { slugifyName } from "./stores.js";
+import { wrapExtensionCurationTools } from "../curation/wrap.js";
 /** Every lifecycle field name, in validation order (mirrors the contract doc). */
 const LIFECYCLE_FIELDS = [
     "conversationCreated",
@@ -217,6 +218,52 @@ function validateWorkers(value) {
  * (the §8.2 grammar), and duplicate names within one extension are
  * rejected (they would collide on the `ext:<slug>:<name>` id).
  */
+/**
+ * Validate a factory result's `curationTargets` declaration (curator
+ * P7). Absent → undefined (no targets). Present but malformed →
+ * throw; the loader quarantines the extension with the thrown message
+ * (fail-loud: an extension that THINKS it declared a curation target
+ * must not silently lose it). Per target, validation order: name,
+ * duplicate qualified name (checked at collection — the slug is
+ * unknown here), tools list, guidance, undo (REQUIRED — no undo, no
+ * magic), maintain.
+ *
+ * The REGISTERED-TOOL check (a target listing a tool its extension
+ * does not register) and the cross-extension duplicate qualified id
+ * live in the load loop, where the registry and the slug are known.
+ */
+function validateCurationTargets(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw new Error("extension factory returned a curationTargets field that is not an array");
+    }
+    const targets = [];
+    for (const entry of value) {
+        const target = entry;
+        const name = target?.name;
+        if (typeof name !== "string" || name.length === 0) {
+            throw new Error("extension factory returned a curation target without a name");
+        }
+        const tools = target?.tools;
+        if (!Array.isArray(tools) ||
+            tools.some((tool) => typeof tool !== "string" || tool.length === 0)) {
+            throw new Error(`extension factory returned a curation target "${name}" whose tools is not an array of non-empty strings`);
+        }
+        if (typeof target?.guidance !== "function") {
+            throw new Error(`extension factory returned a curation target "${name}" whose guidance is not a function`);
+        }
+        if (typeof target?.undo !== "function") {
+            throw new Error(`curation target "${name}" has no undo`);
+        }
+        if (target?.maintain !== undefined &&
+            typeof target.maintain !== "function") {
+            throw new Error(`extension factory returned a curation target "${name}" whose maintain is not a function`);
+        }
+        targets.push(entry);
+    }
+    return targets;
+}
 function validateUserServices(value) {
     if (value === undefined)
         return undefined;
@@ -1204,6 +1251,10 @@ async function resolvedFromFactory(factory, hostContext) {
     }
     // `workers` is a contract key — the candidate read needs no cast.
     const workers = validateWorkers(candidate.workers);
+    // Curation targets (curator P7): validated without the slug (the
+    // qualified-id duplicate check runs in the load loop where the slug
+    // and the already-claimed ids are known).
+    const curationTargets = validateCurationTargets(candidate.curationTargets);
     return {
         ...(candidate.perUserTools === undefined
             ? {}
@@ -1244,6 +1295,7 @@ async function resolvedFromFactory(factory, hostContext) {
             ? {}
             : { ambientKinds: candidate.ambientKinds }),
         ...(workers === undefined ? {} : { workers }),
+        ...(curationTargets === undefined ? {} : { curationTargets }),
         ...(providers === undefined ? {} : { providers }),
         ...(loginProviders === undefined ? {} : { loginProviders }),
         ...(webuiBundles === undefined ? {} : { webuiBundles }),
@@ -1438,6 +1490,10 @@ export async function loadExtensions(specifiers, registry, options = {}) {
     const settingsChangedBindings = [];
     const lifecycleBindings = [];
     const workerBindings = [];
+    // Curation targets (curator P7): slug-attributed declarations, one
+    // entry per loaded extension whose result carried them — boot folds
+    // these into the ONE CurationRegistry (src/curation/targets.ts).
+    const curationBindings = [];
     const userServiceBindings = [];
     // Jobs Task 3: declared jobs, attributed to the extension slug (the
     // `ext:<slug>:<name>` id's namespace).
@@ -1475,6 +1531,11 @@ export async function loadExtensions(specifiers, registry, options = {}) {
     // Slug → declared name, for collision rejection at load (this boot's
     // loaded set only — quarantined extensions never claim a slug).
     const slugs = new Map();
+    // Qualified curation-target ids ("<slug>:<name>", curator P7): the same
+    // claimed-only-by-LOADED pattern as `slugs` — a target id names ONE
+    // target, so a duplicate quarantines the later declarer instead of
+    // shadowing (never last-wins).
+    const curationIds = new Set();
     // Channel id → slug (gateway C1): the same claimed-only-by-LOADED pattern
     // as `slugs`. Chat bindings are keyed by channel id, so a shadowing
     // adapter would inherit another adapter's chats — the collision
@@ -1695,6 +1756,32 @@ export async function loadExtensions(specifiers, registry, options = {}) {
             // install, exactly like the channel-id collision — a second engine
             // leaves no registry entry, no slug claim, and no binding. First
             // loaded wins.
+            // Curation targets (curator P7): the two slug-dependent rules
+            // check HERE — after the slug is final, BEFORE the registry
+            // install (a violation leaves no entry, no slug claim, no
+            // binding — the same point as the one-engine rule below).
+            // A target's tools list must name tools THIS extension
+            // registers (A8's wrapping rewrites registrations — an
+            // unregistered name would wrap nothing); a qualified id
+            // ("<slug>:<name>") names ONE target.
+            if (resolved.curationTargets !== undefined) {
+                const registered = new Set((extension?.tools ?? []).map((tool) => tool.name));
+                // Claim each id AS it validates: an intra-list duplicate
+                // (the same name twice in one result) hits the check on
+                // its SECOND arrival, quarantining before any install.
+                const claimed = new Set();
+                for (const target of resolved.curationTargets) {
+                    const id = `${slug}:${target.name}`;
+                    if (curationIds.has(id) || claimed.has(id)) {
+                        throw new Error(`duplicate curation target id "${id}" — a qualified id names one curation target`);
+                    }
+                    claimed.add(id);
+                    const unregistered = target.tools.find((tool) => !registered.has(tool));
+                    if (unregistered !== undefined) {
+                        throw new Error(`extension "${slug}" declares curation target "${target.name}" listing tool "${unregistered}" it does not register`);
+                    }
+                }
+            }
             if (resolved.gateway !== undefined) {
                 if (gatewayEngine !== undefined) {
                     throw new Error(`gateway engine already declared by "${gatewayEngine.extension}"`);
@@ -1702,7 +1789,23 @@ export async function loadExtensions(specifiers, registry, options = {}) {
                 gatewayEngine = { extension: slug, engine: resolved.gateway };
             }
             if (extension !== undefined) {
-                registry.install(extension);
+                // Curator A8 (P9): grow the wrap feed with this extension's
+                // just-validated target tools, then WRAP every curation-tool
+                // registration at the install — its own target tools, plus any
+                // feed name it registers (a non-core `skill_manage`). Growth
+                // lives HERE, after every quarantining check, so the feed
+                // never learns a tool whose extension failed the load. The
+                // bindings below keep pairing with the UNWRAPPED object: they
+                // carry identity, never tools, and the wrap changes only
+                // `execute`.
+                if (options.curationFeed !== undefined &&
+                    resolved.curationTargets !== undefined) {
+                    for (const target of resolved.curationTargets) {
+                        for (const tool of target.tools)
+                            options.curationFeed.add(tool);
+                    }
+                }
+                registry.install(wrapExtensionCurationTools(extension, options.curationFeed));
             }
             if (resolved.perUserTools === true)
                 perUserSlugs.push(slug);
@@ -1773,6 +1876,15 @@ export async function loadExtensions(specifiers, registry, options = {}) {
                     workers: resolved.workers,
                 });
             }
+            if (resolved.curationTargets !== undefined) {
+                curationBindings.push({
+                    extension: slug,
+                    targets: resolved.curationTargets,
+                });
+                for (const target of resolved.curationTargets) {
+                    curationIds.add(`${slug}:${target.name}`);
+                }
+            }
             if (resolved.jobs !== undefined) {
                 jobBindings.push({ extension: slug, jobs: resolved.jobs });
             }
@@ -1890,6 +2002,7 @@ export async function loadExtensions(specifiers, registry, options = {}) {
         settingsChangedBindings,
         lifecycleBindings,
         workerBindings,
+        curationBindings,
         jobBindings,
         routeBindings,
         commandBindings,

package/dist/harness/naming.js

@@ -104,6 +104,12 @@ export function createAutoNamer(deps) {
             // skip sits next to the isTaskOwned check per the plan.
             if (meta?.source === "cron")
                 return;
+            // Internal conversations (curator P5) are never named: they are
+            // invisible on every owner-keyed surface, and a name would exist
+            // only to be hidden. The bus already withholds the settle event;
+            // this is the belt-and-braces read-side gate.
+            if (meta?.internal === true)
+                return;
             // An absent doc (never written — reads serve nothing, defaults are
             // free) is an unnamed conversation with zero attempts: name it.
             if (meta?.name !== undefined || meta?.autoName !== undefined)

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

@@ -21,6 +21,7 @@ export const RESERVED_CORE_SECTION_KEYS = [
     "skills",
     "tool-guidance",
     "execution-guidance",
+    "job-state",
 ];
 /**
  * Core-owned directory names directly under a store root (multi-user M1).
@@ -31,6 +32,7 @@ export const RESERVED_CORE_SECTION_KEYS = [
  */
 export const RESERVED_EXTENSION_SLUGS = [
     "users",
+    "jobs",
     "workspace",
     "models",
     "sandbox",
@@ -38,6 +40,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,103 +316,188 @@ 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 }),
                     ...(opts.name === undefined ? {} : { name: opts.name }),
+                    ...(opts.job === undefined ? {} : { job: opts.job }),
                     ...(opts.agent === undefined ? {} : { agent: opts.agent }),
                     // The source default: the CALLING extension's slug (spec §9.5).
                     source: opts.source ?? identity.name,
                 });
             },
             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);
             },
+            async entries(id, query, limit, cursor) {
+                return (await hostBridge("conversations.entries")).conversations.entries(id, query, limit, cursor);
+            },
+            async entry(id, entryId) {
+                return (await hostBridge("conversations.entry")).conversations.entry(id, entryId);
+            },
             // 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);
+            },
+        },
+        jobs: {
+            async get(id) {
+                return (await hostBridge("jobs.get")).jobs.get(id);
             },
         },
         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);
             },
         },
+        async notify(input) {
+            return (await hostBridge("notify")).notify(identity.name, input);
+        },
         // The surfaces seam (UI-blocks U3 Task 4): `changed` awaits the
         // bridge (so a factory-body call waits, never resolves early) and
         // delegates to the server-side SurfaceService — the rev bump + the
@@ -385,7 +513,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/sections/context-files.js

@@ -45,10 +45,13 @@ async function readContextFile(input, fileName, context) {
 /**
  * The static `identity` section body: runtime facts only. No tool claims
  * (the system prompt already declares the actually-offered tools per
- * request) and no model name (it would re-emit this section on every
- * mid-conversation model swap, defeating the minimal-patch design).
+ * request), no model name (it would re-emit this section on every
+ * mid-conversation model swap, defeating the minimal-patch design), and
+ * no NAME: what the agent is called is `SOUL.md` territory, since a user
+ * may choose a different name for their own agent. Durability is runtime
+ * truth, not identity copy — it stays out of this section.
  */
-export const IDENTITY_TEXT = "You are sigrun, an AI assistant running as a persistent server built on the pi-durable harness. Conversations are durable: they survive restarts and can span channels (web UI, terminal UI, HTTP API). Multiple conversations may be active at once; each is independent.";
+export const IDENTITY_TEXT = "You are a small but extensible multi-user AI assistant built on the pi-durable harness. Conversations can span channels (web UI, terminal UI, HTTP API), and multiple independent conversations may be active at once.";
 /**
  * The persona sigrun ships when no `SOUL.md` exists. A present `SOUL.md`
  * replaces it wholesale; the default is never merged in.

package/dist/harness/sections/job-state.js

@@ -0,0 +1,24 @@
+/** The persistent state folder shared by every run of one job. */
+import { defineExtension, section } from "@earendil-works/pi-durable";
+import { jobStateDir } from "../../jobs/state-dir.js";
+import { SessionMetaDoc } from "../../server/session-meta.js";
+/** Name a new-conversation job run's persistent, per-owner state folder. */
+export function createJobStateExtension(deps) {
+    return defineExtension({
+        name: "sigrun.job-state",
+        sections: [
+            section("job-state", async (input, context) => {
+                const meta = await input.read.snapshot(SessionMetaDoc, input.conversationId, context);
+                if (meta?.jobId === undefined)
+                    return undefined;
+                const job = await deps.job(meta.jobId);
+                if (job === undefined)
+                    return undefined;
+                const root = deps.jobsRoot(meta.owner);
+                if (root === undefined)
+                    return undefined;
+                return `Job state: this conversation is a run of job "${job.name}" (${meta.jobId}). Its state folder is ${jobStateDir(root, meta.jobId)} — create it if missing. Use it to keep notes between runs (for example, when an issue was first seen). Other runs of this job use the same folder; write files atomically.`;
+            }),
+        ],
+    });
+}

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");
             }