@sigrun/sigrun 0.6.0 → 0.7.0

package/dist/history/trailers.js

@@ -0,0 +1,145 @@
+/**
+ * Commit trailers for sigrun-owned git history (tabs+skills plan, Task 7).
+ *
+ * The feed reads action/skill from trailers, never by parsing the summary —
+ * the exact key set is the contract: Sigrun-Actor, Sigrun-Action,
+ * Sigrun-Skill, Sigrun-Review, Sigrun-Conversation, Sigrun-Reason,
+ * Sigrun-Undoes.
+ *
+ * Author identity rule (plan Global Constraints): author name = actor
+ * (`<user>` | `curator` | `agent` | `outside sigrun`), author email
+ * `<actor-slug>@sigrun.invalid` (`outside-sigrun@…`); the committer is always
+ * `sigrun <sigrun@sigrun.invalid>` (set by git.ts at commit time).
+ */
+export function actorName(actor) {
+    switch (actor.kind) {
+        case "user":
+            return actor.user;
+        case "curator":
+            return "curator";
+        case "agent":
+            return "agent";
+        case "outside":
+            return "outside sigrun";
+    }
+}
+export function actorEmail(actor) {
+    let raw;
+    if (actor.kind === "user")
+        raw = actor.user;
+    else if (actor.kind === "outside")
+        raw = "outside-sigrun";
+    else
+        raw = actor.kind;
+    // The sigrun slug rule (src/curation/names.ts): lowercase, map every
+    // run of non-slug characters (spaces included) to one dash, trim edge
+    // dashes. A name that slugs to nothing falls back to "user".
+    const slug = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return `${slug === "" ? "user" : slug}@sigrun.invalid`;
+}
+export function decodeActor(value) {
+    if (value === "curator")
+        return { kind: "curator" };
+    if (value === "agent")
+        return { kind: "agent" };
+    if (value === "outside sigrun")
+        return { kind: "outside" };
+    return { kind: "user", user: value };
+}
+const TRAILER_KEY_LINE = /^Sigrun-(Actor|Action|Skill|Review|Conversation|Reason|Undoes):/;
+/**
+ * Sanitize a string before it enters the commit message. Blank-line
+ * sequences collapse to a space: git's trailer block starts at the last
+ * blank-line-separated paragraph, so an embedded "\n\nSigrun-Actor: …"
+ * would otherwise decode as trusted metadata. Lines shaped like a trailer
+ * key are flattened into the text.
+ */
+export function sanitizeField(value) {
+    return value
+        .split("\n")
+        .map((line) => {
+        if (!TRAILER_KEY_LINE.test(line.trimStart()))
+            return line;
+        return line.replace(":", " -");
+    })
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/** Every CommitMeta string that flows into the commit message. */
+export function sanitizeMeta(meta) {
+    const clean = (value) => value === undefined ? undefined : value.replace(/[\r\n]+/g, " ").trim();
+    const summary = sanitizeField(meta.summary);
+    return {
+        actor: meta.actor,
+        summary: summary === "" ? "(no summary)" : summary,
+        action: clean(meta.action),
+        skill: clean(meta.skill),
+        reviewId: clean(meta.reviewId),
+        conversationId: meta.conversationId,
+        reason: clean(meta.reason),
+        undoes: clean(meta.undoes),
+    };
+}
+export function encodeTrailers(meta) {
+    const lines = [`Sigrun-Actor: ${actorName(meta.actor)}`];
+    if (meta.action !== undefined)
+        lines.push(`Sigrun-Action: ${meta.action}`);
+    if (meta.skill !== undefined)
+        lines.push(`Sigrun-Skill: ${meta.skill}`);
+    if (meta.reviewId !== undefined)
+        lines.push(`Sigrun-Review: ${meta.reviewId}`);
+    if (meta.conversationId !== undefined) {
+        lines.push(`Sigrun-Conversation: ${meta.conversationId}`);
+    }
+    if (meta.reason !== undefined)
+        lines.push(`Sigrun-Reason: ${meta.reason}`);
+    if (meta.undoes !== undefined)
+        lines.push(`Sigrun-Undoes: ${meta.undoes}`);
+    return lines.join("\n");
+}
+function trailer(message, key) {
+    const value = new RegExp(`^${key}:\\s*(.+)$`, "m").exec(message)?.[1]?.trim();
+    return value === undefined || value === "" ? undefined : value;
+}
+/**
+ * Decode one commit's metadata from `git show --format=fuller` output (the
+ * shape the tests produce with a plain `git show`; GitHistory.log parses its
+ * own record format instead). `paths` is always empty here — fuller output
+ * carries no diff.
+ */
+export function decodeCommit(raw) {
+    const sha = /^commit ([0-9a-f]{40})/m.exec(raw)?.[1];
+    if (sha === undefined)
+        throw new Error("decodeCommit: no commit header found");
+    const authorName = /^Author:\s+(.*?)\s+<[^>]+>/m.exec(raw)?.[1] ?? "";
+    const authorDate = /^AuthorDate:\s+(.+)$/m.exec(raw)?.[1]?.trim();
+    const messageStart = raw.indexOf("\n\n");
+    const message = messageStart === -1
+        ? ""
+        : raw
+            .slice(messageStart + 2)
+            .split("\n")
+            .map((line) => (line.startsWith("    ") ? line.slice(4) : line))
+            .join("\n")
+            .replace(/\n+$/, "");
+    const summary = message.split("\n").find((line) => line.trim() !== "") ?? "";
+    const conversationRaw = trailer(message, "Sigrun-Conversation");
+    const conversationId = conversationRaw === undefined ? undefined : Number(conversationRaw);
+    return {
+        sha,
+        at: authorDate === undefined ? "" : new Date(authorDate).toISOString(),
+        summary,
+        actor: decodeActor(trailer(message, "Sigrun-Actor") ?? authorName),
+        action: trailer(message, "Sigrun-Action"),
+        skill: trailer(message, "Sigrun-Skill"),
+        reviewId: trailer(message, "Sigrun-Review"),
+        conversationId,
+        reason: trailer(message, "Sigrun-Reason"),
+        undoes: trailer(message, "Sigrun-Undoes"),
+        paths: [],
+    };
+}

package/dist/history/workspace-history.js

@@ -0,0 +1,47 @@
+/**
+ * Workspace skills history (tabs+skills plan, Task 10): the SECOND
+ * per-user repo — `<workspace>/skills` under git, caught up on every
+ * settled run with actor `agent` and the Sigrun-Conversation trailer.
+ *
+ * The git dir lives under the user's curation history root
+ * (`<userArea>/curation/history/workspace.git`), NEVER inside the work
+ * tree — the work tree is a live user directory the agent edits, so the
+ * layout itself (not an info/exclude line) keeps the repo out of the
+ * staged content. Pathspec `["."]` with `add --all --force` stages the
+ * whole skills tree, including deletions of tracked files whose pathspec
+ * root no longer exists on disk (Task 7's shipped "exists on disk OR
+ * tracked" staging rule).
+ */
+import { join } from "node:path";
+import { historyDir } from "../curation/paths.js";
+/**
+ * The workspace skills repo layout: gitDir
+ * `<userArea>/curation/history/workspace.git`, workTree
+ * `<workspace>/skills`, pathspec `["."]`.
+ */
+export function workspaceRepoSpec(userArea, workspace) {
+    return {
+        gitDir: join(historyDir(userArea), "workspace.git"),
+        workTree: join(workspace, "skills"),
+        pathspec: ["."],
+    };
+}
+/**
+ * The user's workspace skills history, cached per (user, workspace
+ * path): a changed workspace path yields a NEW instance on the SAME
+ * gitDir, so the history follows the user across workspace moves — one
+ * log, one commit per tree. `workspace` undefined (the workspaceRoot
+ * rules' refusals) resolves to no history.
+ */
+export function workspaceHistoryFor(user, workspace, deps) {
+    if (workspace === undefined)
+        return undefined;
+    // NUL-separated: no (user, workspace) pair can collide on a boundary.
+    const key = `${user}\0${workspace}`;
+    const cached = deps.cache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const history = deps.create(workspace);
+    deps.cache.set(key, history);
+    return history;
+}

package/dist/jobs/index.js

@@ -28,7 +28,7 @@ import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { JobDoc, listRevisions, listRuns, pruneHistory, readJob, scanJobs, writeJobChange, } from "./docs.js";
 import { fireJob } from "./fire.js";
 import { reconcileJobs, } from "./reconcile.js";
-import { jobStateDir, removeJobState } from "./state-dir.js";
+import { removeJobState, warnJobStateRemoval } from "./state-dir.js";
 import { specHash } from "./spec.js";
 /** Thrown when an API write targets a `file:`/`ext:` job id (409 `job_declared`). */
 export class JobDeclaredError extends Error {
@@ -92,8 +92,7 @@ export function createJobsService(deps) {
             await removeJobState(root, id);
         }
         catch (error) {
-            const path = root === undefined ? id : jobStateDir(root, id);
-            console.warn(`jobs: could not remove job state ${path}: ${error instanceof Error ? error.message : String(error)}`);
+            warnJobStateRemoval("job state", root, id, error);
         }
     };
     // `job.changed` observation (W4 Task 4): ONE commit subscription over
@@ -240,6 +239,9 @@ export function createJobsService(deps) {
             // failure to its caller; it never rewrites or retires the job.
             await removeJobState(stateRoot(record.owner), id);
         },
+        jobStateRoot(owner) {
+            return stateRoot(owner);
+        },
         async runNow(id) {
             // ONE clock reading: the manual fire key and the run's fireAt must
             // agree — the settle path re-derives the run-record key from

package/dist/jobs/reconcile.js

@@ -38,7 +38,7 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { JobDoc, patchJob, scanJobs, writeJobChange, } from "./docs.js";
 import { nextFireAt } from "./schedule.js";
-import { jobStateDir, removeJobState } from "./state-dir.js";
+import { removeJobState, warnJobStateRemoval } from "./state-dir.js";
 import { specHash } from "./spec.js";
 import { createScheduleTask } from "./task.js";
 const SCAN_PAGE = 500;
@@ -159,8 +159,7 @@ export async function reconcileJobs(deps, ctx = BACKGROUND_CONTEXT) {
             await removeJobState(root, id);
         }
         catch (error) {
-            const path = root === undefined ? id : jobStateDir(root, id);
-            console.warn(`jobs: could not remove retired job state ${path}: ${error instanceof Error ? error.message : String(error)}`);
+            warnJobStateRemoval("retired job state", root, id, error);
         }
     }
     // ── Pass 2: records → tasks ─────────────────────────────────────

package/dist/jobs/state-dir.js

@@ -14,3 +14,12 @@ export async function removeJobState(root, jobId) {
         return;
     await rm(jobStateDir(root, jobId), { recursive: true, force: true });
 }
+/**
+ * The one best-effort removal warning (index delete, reconcile retire,
+ * transfer catch-path): the path the caller actually resolved, or the
+ * bare id when the selected owner has no jobs root.
+ */
+export function warnJobStateRemoval(what, root, jobId, error) {
+    const path = root === undefined ? jobId : jobStateDir(root, jobId);
+    console.warn(`jobs: could not remove ${what} ${path}: ${error instanceof Error ? error.message : String(error)}`);
+}

package/dist/jobs/transfer.js

@@ -17,10 +17,9 @@
  * ownerless until the source is edited — spec §8.3's posture).
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
-import { join } from "node:path";
 import { registerOwnershipParticipant } from "../server/ownership.js";
 import { scanJobs, writeJobChange } from "./docs.js";
-import { jobStateDir } from "./state-dir.js";
+import { warnJobStateRemoval } from "./state-dir.js";
 import { specHash } from "./spec.js";
 /**
  * Register the jobs transfer participant on `ctx` (createServer calls
@@ -44,11 +43,12 @@ export function registerJobsOwnershipParticipant(ctx) {
                 await jobs.resetState(id);
             }
             catch (error) {
-                // Directory-user api jobs use their managed user area. (OS-user
-                // jobs cannot enter this transfer path — user deletion refuses
+                // Name the root resetState actually resolved (the workspace
+                // service's selection), never a guessed layout. (OS-user jobs
+                // cannot enter this transfer path — user deletion refuses
                 // osUser workspaces before any participant runs.)
-                const root = join(ctx.managedPaths.userAreas(from), "jobs");
-                console.warn(`jobs: could not remove transferred job state ${jobStateDir(root, id)}: ${error instanceof Error ? error.message : String(error)}`);
+                const root = jobs.jobStateRoot(from);
+                warnJobStateRemoval("transferred job state", root, id, error);
             }
             const spec = { ...record.spec, owner: to };
             const next = {

package/dist/sandbox/grants.js

@@ -131,6 +131,17 @@ export function validateGrantPath(path, ctx) {
             (inheritedArea === undefined || !inside(candidate, inheritedArea))) {
             return { ok: false, reason: "path is inside another user's area" };
         }
+        // The curation dir is out of the agent's reach (spec §5): no
+        // workspace or grant may sit inside it, and none may CONTAIN it —
+        // a stored path equal to the bare user area would hand the agent
+        // the whole curation tree. Task 9 puts git history under
+        // curation/history.
+        for (const area of [ownArea, ...(inheritedArea === undefined ? [] : [inheritedArea])]) {
+            const curation = join(area, "curation");
+            if (inside(candidate, curation) || inside(curation, candidate)) {
+                return { ok: false, reason: "path overlaps the user's curation dir" };
+            }
+        }
     }
     return { ok: true, realpath: candidate };
 }

package/dist/sandbox/launch.js

@@ -1,4 +1,22 @@
 /** The shared helper launch shape for worker and per-user service processes. */
+/**
+ * Serialize a built policy into the `SIGRUN_SANDBOX_POLICY` env payload
+ * the sandbox helper parses (sandbox/src/policy.rs — `deny_unknown_fields`,
+ * so the field set here IS the wire contract). The single writer: every
+ * producer of a policy payload — `launchInJail`, the smoke-image jailed
+ * check — must build it here so the shapes cannot drift.
+ */
+export function serializePolicy(policy) {
+    return JSON.stringify({
+        ro: policy.ro,
+        rw: policy.rw,
+        ensureDirs: policy.ensureDirs,
+        minAbi: 6,
+        ...(policy.uid === undefined ? {} : { uid: policy.uid }),
+        ...(policy.gid === undefined ? {} : { gid: policy.gid }),
+        ...(policy.groups === undefined ? {} : { groups: policy.groups }),
+    });
+}
 /** Apply a complete policy in the helper, then exec the requested sibling process. */
 export function launchInJail(helper, policy, command, args, env) {
     return {
@@ -17,15 +35,7 @@ export function launchInJail(helper, policy, command, args, env) {
             // is not granted inside the jail, so honoring it would be the
             // same fatal startup error.
             OPENSSL_CONF: `${policy.tmp}/openssl.cnf`,
-            SIGRUN_SANDBOX_POLICY: JSON.stringify({
-                ro: policy.ro,
-                rw: policy.rw,
-                ensureDirs: policy.ensureDirs,
-                minAbi: 6,
-                ...(policy.uid === undefined ? {} : { uid: policy.uid }),
-                ...(policy.gid === undefined ? {} : { gid: policy.gid }),
-                ...(policy.groups === undefined ? {} : { groups: policy.groups }),
-            }),
+            SIGRUN_SANDBOX_POLICY: serializePolicy(policy),
         },
     };
 }

package/dist/sandbox/policy.js

@@ -98,7 +98,12 @@ export function defaultModuleTrees(coreRoot) {
 export function defaultPackageConfig(coreRoot) {
     return join(coreRoot, "package.json");
 }
-function validateUserPath(path, record, managed, inheritedFrom) {
+/**
+ * One per-user path against the grant validator (Task 10 exports it:
+ * the workspace history's `workspaceRoot` resolves the SAME precedence
+ * as `buildUserPolicy` and must refuse the same paths).
+ */
+export function validateUserPath(path, record, managed, inheritedFrom) {
     const candidate = canonical(path) ?? resolve(path);
     if (inside(candidate, "/dev/shm") || inside("/dev/shm", candidate)) {
         return { ok: false, reason: "path is or contains /dev/shm" };

package/dist/serve.js

@@ -228,6 +228,9 @@ export async function serve(env, options) {
         extensionEntries: extensionResolutions,
         env,
         listenHost: host,
+        // Polish A1 (spec §5.2): serve goes on to createServer — bridge
+        // calls in the pre-bind window keep the bounded wait.
+        expectHostBridge: true,
     });
     // The gateway handle (gateway C2) exists BEFORE the server: the meta
     // route reaches it through ServerContext, so the engine's health is

package/dist/server/auth/proxy-only.js

@@ -13,11 +13,12 @@
  * deployments keep the setup-code/invite paths (token callers exist),
  * and loopback binds keep them too (loopback is its own trust).
  */
+import { isProxyOnly } from "@sigrun/shared/auth";
 import { isLoopbackHost } from "./loopback.js";
-/** Whether the configured auth methods are exactly proxy-only. */
-export function isProxyOnly(methods) {
-    return methods.includes("proxy") && !methods.includes("token");
-}
+// Re-export: the predicate lives in @sigrun/shared (polish task 12 —
+// one definition for the server, the webui, and the CLI); this module
+// keeps the server's import path stable for its existing callers.
+export { isProxyOnly };
 /**
  * Whether this boot requires a proxy vouch for account creation:
  * proxy-only AND bound beyond loopback. The loopback test is the shared

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

@@ -0,0 +1,26 @@
+/**
+ * Core-owned views (tabs+skills Task 4): the reserved `core` slug's
+ * built-in view surfaces (the Jobs and Skills views, attached by Tasks
+ * 5 and 12 via `SurfaceService.attachCoreViews`).
+ *
+ * Core views are NOT extensions: they have no outcome row, so the
+ * health dot is unaffected, and the `/v1/extensions` + `/v1/meta`
+ * routes list them under `coreViews`, never `extensions[]`. Rendering,
+ * data, actions, and instance-key/rev machinery run through the SAME
+ * `SurfaceService` code path as extension surfaces — this module only
+ * owns the wire projection.
+ */
+/**
+ * The wire rows for a list of core-view defs: one {@link CoreViewInfo}
+ * per def, in attachment order (the channels list core views FIRST,
+ * ahead of extension views). `refreshMs` is sparse — absent when the
+ * def declares no cadence.
+ */
+export function coreViewInfos(defs) {
+    return defs.map((def) => ({
+        id: def.id,
+        title: def.title,
+        icon: def.icon,
+        ...(def.refreshMs === undefined ? {} : { refreshMs: def.refreshMs }),
+    }));
+}