@nurix/nustack 0.23.11 → 0.23.13

package/dist/lib/records/door.js

@@ -1,8 +1,7 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { resolveNuStackUrl } from "../nustack_client.js";
+import { assertCredentialOrigin, resolveNuStackOrigin } from "../nustack_client.js";
 import { resolveProjectId } from "../project_context.js";
+import { readProjectContract } from "../project_contract.js";
+import { originOf } from "../origin_guard.js";
 export const RECORD_KINDS = ["obligation", "gate_event", "changelog", "memory", "backlog", "proposal", "triage"];
 export const LEGACY_KIND_TRANSLATION = { "backlog.remove": "backlog", bookkeeping: "obligation" };
 export const RECORDS_BATCH_CAP = 200;
@@ -23,33 +22,41 @@ export function translatedKindOf(kind) {
     return isLegacyKind(kind) ? LEGACY_KIND_TRANSLATION[kind] : kind;
 }
 export async function readMountDoor(root) {
-    const manifest = path.join(root, ".claude", "harness.json");
-    if (!existsSync(manifest))
-        return undefined;
-    try {
-        const parsed = JSON.parse(await readFile(manifest, "utf8"));
-        if (!parsed.mount || !("door" in parsed.mount))
-            return undefined;
-        const door = parsed.mount.door;
-        return typeof door === "string" && door.trim() !== "" ? door.trim().replace(/\/+$/, "") : null;
-    }
-    catch {
-        return undefined;
-    }
+    return (await readProjectContract(root)).door;
 }
 export async function resolveDoor(root, globals, projectFlag) {
     const project = await resolveProjectId(root, projectFlag ? { project: projectFlag } : {});
     if (!project.ok)
         return { kind: "store", projectId: null, root, reason: "this folder is not bound to a Project" };
-    const door = await readMountDoor(root);
+    const contract = await readProjectContract(root);
+    const door = contract.door;
     if (door === null)
         return { kind: "store", projectId: project.projectId, root, reason: "the harness manifest configures no door" };
-    return { kind: "door", projectId: project.projectId, doorUrl: door ?? resolveNuStackUrl(globals), isPlatformDefault: door === undefined, root };
+    let origin;
+    try {
+        origin = resolveNuStackOrigin(globals, root).url;
+    }
+    catch (error) {
+        return { kind: "store", projectId: project.projectId, root, reason: error instanceof Error ? error.message : String(error) };
+    }
+    if (door !== undefined && contract.doorSource === "contract" && originOf(door) !== originOf(origin)) {
+        const reason = `the contract's door ${door} is not on the resolved origin ${origin}; records stay local`;
+        process.stderr.write(`nustack: ${reason}\n`);
+        return { kind: "store", projectId: project.projectId, root, reason };
+    }
+    return { kind: "door", projectId: project.projectId, doorUrl: door ?? origin, isPlatformDefault: door === undefined, root };
 }
 export function retryDelayMs(attempts) {
     return Math.min(RETRY_BASE_MS * 2 ** Math.max(0, attempts - 1), RETRY_CEILING_MS);
 }
 export async function postRecords(doorUrl, projectId, request, bearer) {
+    try {
+        await assertCredentialOrigin(doorUrl);
+    }
+    catch (error) {
+        const code = typeof error.code === "string" ? error.code : null;
+        return { ok: false, status: 0, code, message: error instanceof Error ? error.message : String(error) };
+    }
     let response;
     try {
         response = await fetch(`${doorUrl}/api/v2/projects/${encodeURIComponent(projectId)}/records`, {

package/dist/lib/records/drain.js

@@ -3,6 +3,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unl
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { ensureAccessToken } from "../auth_grant.js";
+import { isOriginMismatch } from "../origin_guard.js";
 import { recordsDrainLockPath } from "../local_store/paths.js";
 import { resolveNuStackUrl } from "../nustack_client.js";
 import { RECORDS_BATCH_CAP, postRecords, resolveDoor, retryDelayMs } from "./door.js";
@@ -84,14 +85,19 @@ async function drainPass(store, globals, result, shouldIgnoreBackoff) {
         if (first.row.credential === "device")
             bearer = deviceToken;
         else {
-            if (personToken === undefined)
-                personToken = (await ensureAccessToken().catch(() => null))?.accessToken ?? null;
+            if (personToken === undefined) {
+                personToken = await ensureAccessToken().then((auth) => auth?.accessToken ?? null, (error) => {
+                    if (isOriginMismatch(error))
+                        result.originRefusal = error.message;
+                    return null;
+                });
+            }
             bearer = personToken;
         }
         for (let start = 0; start < list.length; start += RECORDS_BATCH_CAP) {
             const batch = list.slice(start, start + RECORDS_BATCH_CAP);
             if (bearer === null) {
-                backoffAll(store, batch, "this device is signed out", result);
+                backoffAll(store, batch, result.originRefusal ?? "this device is signed out", result);
                 continue;
             }
             await sendBatch(store, batch, first.row.kind, bearer, result);
@@ -140,7 +146,7 @@ async function sendBatch(store, batch, kind, bearer, result) {
     }
 }
 export async function drainRecords(store, globals, options = {}) {
-    const result = { sent: 0, refused: 0, lastError: null };
+    const result = { sent: 0, refused: 0, lastError: null, originRefusal: null };
     pruneSynced(store, Date.now());
     for (let pass = 0; pass < MAX_PASSES; pass += 1) {
         options.onPass?.();

package/dist/lib/records/refusalLog.js

@@ -2,7 +2,36 @@ import { randomUUID } from "node:crypto";
 import { RECORD_SCHEMA_VERSION } from "./door.js";
 import { idempotencyKeyOf } from "./naturalKey.js";
 import { writeRecords } from "./recordsTable.js";
-export const REFUSAL_GATE_IDS = ["records-validation", "records-unknown-kind", "agent-owned-obligation", "secret-scan"];
+export const REFUSAL_GATE_IDS = [
+    "records-validation",
+    "records-unknown-kind",
+    "agent-owned-obligation",
+    "secret-scan",
+    "ownership",
+    "plan-gate",
+    "ledger",
+    "frozen-record",
+    "changelog",
+    "changelog-entry",
+    "package-table",
+    "protected-file",
+    "output-gate",
+    "branch-worktree",
+    "live-command",
+    "commit-claim",
+    "foreign-claim",
+    "open-denials",
+    "exit-stop",
+    "queue",
+    "completion-integrity",
+    "changelog-presence",
+    "commit-gate",
+    "file-gate",
+    "bash-write-screen",
+    "harness-checks",
+    "hook.rule_unavailable",
+    "hook.deadline",
+];
 const TEXT_CAP = 20_000;
 const clip = (text) => (text.length > TEXT_CAP ? `${text.slice(0, TEXT_CAP - 1)}…` : text || "-");
 export function logRefusals(store, entries, context) {

package/dist/lib/session-engine/supervisor.js

@@ -1,13 +1,11 @@
 import { execFile } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
 import { createInterface } from "node:readline";
 import { ClaudeSession } from "./claudeAdapter.js";
 import { FRAME_VERSION, parseInboundFrame, serializeFrame, } from "./frames.js";
 import { inspectSession, reclaimSession } from "./prune.js";
 import { sessionRegistryPath, readSessionRegistry, updateSessionRegistry } from "./registry.js";
 import { createSessionWorktree } from "./worktree.js";
-import { mountHarness } from "../harness/mount.js";
+import { readProjectContract } from "../project_contract.js";
 function defaultProbeClaude(env) {
     return new Promise((resolve) => {
         execFile("claude", ["--version"], { env, timeout: 5_000 }, (error, stdout) => {
@@ -41,14 +39,7 @@ export class SessionSupervisor {
         this.emit({ v: FRAME_VERSION, type: "session.error", sessionId, code, message });
     }
     async boundProjectOf(projectPath) {
-        try {
-            const parsed = JSON.parse(await readFile(path.join(projectPath, ".nustack", "workspace.json"), "utf8"));
-            const id = parsed?.workspaceId;
-            return typeof id === "string" && id.trim() ? id.trim() : null;
-        }
-        catch {
-            return null;
-        }
+        return (await readProjectContract(projectPath)).projectId;
     }
     async moveSessionRow(record, to) {
         const client = this.options.sessions;
@@ -133,17 +124,14 @@ export class SessionSupervisor {
         }
     }
     async mountInto(sessionId, root, projectId) {
-        const lookup = this.options.sessions?.harnessManifestUrl;
-        if (!lookup)
+        const mount = this.options.mountHarness;
+        if (!mount)
             return;
+        const log = this.options.log ?? ((line) => process.stderr.write(`${line}\n`));
         try {
-            const manifestUrl = await lookup.call(this.options.sessions, projectId);
-            if (!manifestUrl)
-                return;
-            await (this.options.mountHarness ?? mountHarness)(root, manifestUrl);
+            await mount(root, { projectId, writeContract: "never", runtime: "claude-code", log: () => { } });
         }
         catch (error) {
-            const log = this.options.log ?? ((line) => process.stderr.write(`${line}\n`));
             log(`nustack: harness mount skipped for session ${sessionId} - ${error instanceof Error ? error.message : String(error)}`);
         }
     }

package/dist/lib/sessions/client.js

@@ -34,18 +34,6 @@ export function makeSessionsClient(baseUrl, accessToken) {
         async setVendorSessionId(projectId, sessionId, vendorSessionId) {
             return this.transitionSession(projectId, sessionId, "running", { vendorSessionId });
         },
-        async harnessManifestUrl(projectId) {
-            const safeId = assertSafeOpaqueId("The Project id", projectId);
-            const response = await globalThis.fetch(`${baseUrl}/api/v2/projects/${encodeURIComponent(safeId)}`, {
-                headers,
-                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-            });
-            const payload = (await response.json().catch(() => null));
-            if (!response.ok)
-                throw new Error(`project summary fetch failed: HTTP ${response.status}`);
-            const url = payload?.data?.harness?.manifestUrl;
-            return typeof url === "string" && url ? url : null;
-        },
     };
 }
 export function sessionsClientFromEnv(env = process.env) {

package/dist/program.js

@@ -30,6 +30,7 @@ import { runDocsList, runDocsShow, runDocsStatus } from "./commands/docs.js";
 import { runHandoffList, runHandoffShow } from "./commands/handoff.js";
 import { runToolkitStatus, runToolkitReconcile } from "./commands/toolkit.js";
 import { runHarnessMount, runHarnessStatus } from "./commands/harness.js";
+import { runCheck } from "./commands/check.js";
 import { runSessionsList, runSessionsPrune, runSessionsRecord, runSessionsServe, } from "./commands/sessions.js";
 import { registerReviewCommands } from "./commands/review.js";
 import { registerRecordsCommands, startDrainIfDue } from "./commands/records.js";
@@ -68,7 +69,9 @@ program
     .command("init")
     .description("Onboard this folder: sign in, then bind it to a Project (the onboarding router)")
     .option("--organization <id>", "the Organization to create or select the Project in")
+    .option("--project <id>", "the Project to bind (with --yes and --organization: the unattended path)")
     .option("--yes", "pre-confirm the populated-folder onboarding guard")
+    .option("--json", "emit the versioned machine envelope (unattended path only)")
     .action(async (options) => runInit({ ...program.opts(), ...options }));
 program
     .command("add [service]")
@@ -244,7 +247,7 @@ registerProjectSyncCommands(project, () => program.opts());
 registerReviewCommands(program.command("review").description("Read and mirror NuStack Review items"), () => program.opts());
 registerRecordsCommands(program.command("records").description("Emit, send and list harness records"), () => program.opts());
 registerRecordAliases(program, () => program.opts());
-const LOCAL_ONLY_COMMANDS = ["census"];
+const LOCAL_ONLY_COMMANDS = ["census", "check"];
 const UNDRAINED_GROUPS = ["records", "gate", ...RECORD_ALIAS_GROUPS];
 program.hook("preAction", async (_program, action) => {
     if (program.opts().nonInteractive)
@@ -257,6 +260,13 @@ program.hook("preAction", async (_program, action) => {
     if (action.name() !== "telemetry" && isPartCheckStale())
         startTelemetryReconcile({ nustackUrl: program.opts().nustackUrl });
 });
+program
+    .command("check [rule]")
+    .description("Run one harness rule over this checkout; exits 0 pass, 1 block or flag, 2 when it cannot run")
+    .option("--json", "emit the versioned machine envelope")
+    .option("--hook <event>", "payload mode for the seed's thin hooks: pre-tool-use or stop (reads the hook payload on stdin)")
+    .option("--protection", "with --hook: the Protection wall's entry (block-rung Protection rows only)")
+    .action(async (rule, options) => runCheck(rule, options));
 const docs = program.command("docs").description("Work with a Project's Documents");
 docs
     .command("list")
@@ -321,12 +331,13 @@ harness
     .command("mount [path]")
     .description("Mount the resolved harness version into a checkout (default: the current repository)")
     .option("--project <id>", "the Project to act as (defaults to the bound repository)")
-    .option("--manifest <url>", "mount this manifest instead of the one the Project resolves")
+    .option("--runtime <runtime>", "the runtime whose half of the version is mounted (claude-code, codex, opencode, copilot-cli)")
+    .option("--write-contract <mode>", "whether the mount may write CLAUDE.md / AGENTS.md (never, when-unmodified)")
     .option("--json", "emit the versioned machine envelope")
     .action(async (target, options) => runHarnessMount(target, options, program.opts()));
 harness
     .command("status")
-    .description("Print the mounted harness against the cloud pin; exits 1 when they differ")
+    .description("Print the mounted harness against the expected version; exits 1 when they differ, 2 when unreachable")
     .option("--project <id>", "the Project to act as (defaults to the bound repository)")
     .option("--json", "emit the versioned machine envelope")
     .action(async (options) => runHarnessStatus(options, program.opts()));

package/dist/vendor/harness/assemble/runtimes.js

@@ -0,0 +1,32 @@
+// packages/harness/src/assemble/runtimes.ts - The four runtimes, each one's instruction file and merge targets, the
+// docs-root token and the `<runtime>/<repository path>` manifest convention. Imports nothing at runtime, so the
+// mount's vendored closure can carry it. docs/architecture/systems/harness-compiler.md speaks for it (Compile).
+export const RUNTIMES = ['claude-code', 'codex', 'opencode', 'copilot-cli'];
+export const isRuntime = (value) => RUNTIMES.includes(value);
+/** The contract path of each runtime: its instruction file, the only file a mount treats as committed policy. */
+export const INSTRUCTION_FILE_OF = {
+    'claude-code': 'CLAUDE.md',
+    codex: 'AGENTS.md',
+    opencode: 'AGENTS.md',
+    'copilot-cli': '.github/copilot-instructions.md',
+};
+/** The repository file each merge kind folds into. */
+export const MERGE_TARGET_OF = {
+    'claude-settings': '.claude/settings.local.json',
+    'codex-hooks': '.codex/hooks.json',
+    'mcp-servers': '.mcp.json',
+};
+/** A `seed` path is `@docs/<path>`, relative to the repository's docs root, which the mount resolves. */
+export const DOCS_ROOT_TOKEN = '@docs';
+export function prefixRuntime(runtime, files) {
+    return files.map((file) => ({ ...file, path: `${runtime}/${file.path}` }));
+}
+/** `<runtime>/<path>` split into its two halves; null when the first segment is not a runtime. */
+export function splitRuntimePath(path) {
+    const slash = path.indexOf('/');
+    if (slash <= 0)
+        return null;
+    const runtime = path.slice(0, slash);
+    const rest = path.slice(slash + 1);
+    return isRuntime(runtime) && rest.length > 0 ? { runtime, path: rest } : null;
+}

package/dist/vendor/harness/assemble/settingsMerge.js

@@ -0,0 +1,136 @@
+const clone = (value) => (value === undefined ? value : JSON.parse(JSON.stringify(value)));
+/** Structural equality over JSON values, key order ignored. */
+export function jsonEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a))
+        return a.length === b.length && a.every((item, index) => jsonEqual(item, b[index]));
+    const left = Object.keys(a);
+    const right = Object.keys(b);
+    return left.length === right.length && left.every((key) => jsonEqual(a[key], b[key]));
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const matcherOf = (group) => (typeof group.matcher === 'string' ? group.matcher : null);
+function removeManagedHooks(hooks, managed) {
+    for (const entry of managed) {
+        const groups = hooks[entry.event];
+        if (!Array.isArray(groups))
+            continue;
+        const group = groups.find((candidate) => matcherOf(candidate) === entry.matcher);
+        if (!group || !Array.isArray(group.hooks))
+            continue;
+        const index = group.hooks.findIndex((hook) => jsonEqual(hook, entry.hook));
+        if (index >= 0)
+            group.hooks.splice(index, 1);
+    }
+    for (const [event, groups] of Object.entries(hooks)) {
+        if (!Array.isArray(groups))
+            continue;
+        hooks[event] = groups.filter((group) => !Array.isArray(group.hooks) || group.hooks.length > 0 || Object.keys(group).some((key) => key !== 'hooks' && key !== 'matcher'));
+        if (hooks[event].length === 0)
+            delete hooks[event];
+    }
+}
+function addHooks(hooks, incoming) {
+    const added = [];
+    for (const [event, groups] of Object.entries(incoming)) {
+        const existing = (hooks[event] = Array.isArray(hooks[event]) ? hooks[event] : []);
+        for (const group of groups) {
+            const matcher = matcherOf(group);
+            let target = existing.find((candidate) => matcherOf(candidate) === matcher);
+            if (!target) {
+                target = { ...clone(group), hooks: [] };
+                existing.push(target);
+            }
+            target.hooks = Array.isArray(target.hooks) ? target.hooks : [];
+            for (const hook of group.hooks ?? []) {
+                if (target.hooks.some((held) => jsonEqual(held, hook)))
+                    continue;
+                target.hooks.push(clone(hook));
+                added.push({ event, matcher, hook: clone(hook) });
+            }
+        }
+    }
+    return added;
+}
+function mergeHookFile(existing, fragment, priorManaged) {
+    const merged = clone(existing ?? {});
+    const hooks = isObject(merged.hooks) ? merged.hooks : {};
+    removeManagedHooks(hooks, priorManaged?.hooks ?? []);
+    const added = addHooks(hooks, isObject(fragment.hooks) ? fragment.hooks : {});
+    if (Object.keys(hooks).length > 0 || isObject(merged.hooks))
+        merged.hooks = hooks;
+    return { merged, hooks: added };
+}
+/** `.claude/settings.local.json`: hooks by event and matcher, permission rules by list, any other top-level key set only when absent. */
+export function mergeClaudeSettings(existing, fragment, priorManaged) {
+    const { merged, hooks } = mergeHookFile(existing, fragment, priorManaged);
+    const permissions = [];
+    const held = isObject(merged.permissions) ? merged.permissions : null;
+    if (held) {
+        for (const { list, rule } of priorManaged?.permissions ?? []) {
+            const rules = held[list];
+            if (Array.isArray(rules))
+                held[list] = rules.filter((candidate) => candidate !== rule);
+        }
+    }
+    const incoming = isObject(fragment.permissions) ? fragment.permissions : {};
+    for (const [list, rules] of Object.entries(incoming)) {
+        if (!Array.isArray(rules))
+            continue;
+        const target = (merged.permissions = isObject(merged.permissions) ? merged.permissions : {});
+        const current = (target[list] = Array.isArray(target[list]) ? target[list] : []);
+        for (const rule of rules) {
+            if (typeof rule !== 'string' || current.includes(rule))
+                continue;
+            current.push(rule);
+            permissions.push({ list, rule });
+        }
+    }
+    if (isObject(merged.permissions)) {
+        const target = merged.permissions;
+        for (const [list, rules] of Object.entries(target))
+            if (Array.isArray(rules) && rules.length === 0 && !(existing && isObject(existing.permissions) && Array.isArray(existing.permissions[list])))
+                delete target[list];
+        if (Object.keys(target).length === 0 && !(existing && isObject(existing.permissions)))
+            delete merged.permissions;
+    }
+    const keys = [];
+    for (const { key, value } of priorManaged?.keys ?? [])
+        if (key in merged && jsonEqual(merged[key], value))
+            delete merged[key];
+    for (const [key, value] of Object.entries(fragment)) {
+        if (key === 'hooks' || key === 'permissions' || key in merged)
+            continue;
+        merged[key] = clone(value);
+        keys.push({ key, value: clone(value) });
+    }
+    return { merged, managed: { ...(hooks.length ? { hooks } : {}), ...(permissions.length ? { permissions } : {}), ...(keys.length ? { keys } : {}) } };
+}
+/** `.codex/hooks.json`: hooks by event and matcher, every other key left as the person wrote it. */
+export function mergeCodexHooks(existing, fragment, priorManaged) {
+    const { merged, hooks } = mergeHookFile(existing, fragment, priorManaged);
+    return { merged, managed: hooks.length ? { hooks } : {} };
+}
+/** `.mcp.json`: servers by name; a name the person holds is theirs, and a server the previous mount added is replaced. */
+export function mergeMcpServers(existing, fragment, priorManaged) {
+    const merged = clone(existing ?? {});
+    const servers = (isObject(merged.mcpServers) ? merged.mcpServers : {});
+    for (const { name, value } of priorManaged?.mcpServers ?? [])
+        if (name in servers && jsonEqual(servers[name], value))
+            delete servers[name];
+    const added = [];
+    for (const [name, value] of Object.entries(isObject(fragment.mcpServers) ? fragment.mcpServers : {})) {
+        if (name in servers)
+            continue;
+        servers[name] = clone(value);
+        added.push({ name, value: clone(value) });
+    }
+    if (Object.keys(servers).length > 0 || isObject(merged.mcpServers))
+        merged.mcpServers = servers;
+    return { merged, managed: added.length ? { mcpServers: added } : {} };
+}

package/dist/vendor/harness/digest/index.js

@@ -0,0 +1,38 @@
+// packages/harness/src/digest/index.ts - The one content digest a harness version is identified by, its test
+// vectors, and the version manifest. Imports only node:crypto, which the Worker's nodejs_compat flag provides.
+// docs/architecture/systems/harness-compiler.md speaks for it (Versions).
+import { createHash } from 'node:crypto';
+import { byPath } from '../lib/paths.js';
+export { FINDING_CODES } from '../lib/findings.js';
+export const sha256Hex = (content) => createHash('sha256').update(content).digest('hex');
+const shaOf = (file) => ('sha256' in file && typeof file.sha256 === 'string' ? file.sha256 : sha256Hex(file.content));
+/** sha256 hex of JSON.stringify of [{path, sha256}] sorted by path in code-unit order, each sha256 over the file's UTF-8 bytes. */
+export function contentDigest(files) {
+    const entries = files.map((file) => ({ path: file.path, sha256: shaOf(file) })).sort(byPath);
+    return sha256Hex(JSON.stringify(entries));
+}
+/** The two vectors every copy of the digest definition pins against. */
+export const CONTENT_DIGEST_VECTORS = [
+    { files: [], digest: '4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945' },
+    { files: [{ path: 'a', content: 'x' }], digest: 'd19d4b514b0cbad688ef3d00ee838c4db50655f1306c93c9ce84354b96e1a752' },
+];
+const byteLength = (content) => (typeof content === 'string' ? new TextEncoder().encode(content).byteLength : content.byteLength);
+/** The manifest of one version: prefixed entries sorted by path, totals, and the digest over its own entries. */
+export function versionManifest(files, meta) {
+    const entries = files
+        .map((file) => ({ path: file.path, sha256: sha256Hex(file.content), byteSize: byteLength(file.content), policy: file.policy, ...(file.merge ? { merge: file.merge } : {}) }))
+        .sort(byPath);
+    return {
+        schemaVersion: 1,
+        digest: contentDigest(entries),
+        semver: meta.semver,
+        projectId: meta.projectId,
+        catalogVersion: meta.catalogVersion,
+        compileMode: meta.compileMode,
+        runtimes: [...meta.runtimes],
+        unsupported: meta.unsupported,
+        fileCount: entries.length,
+        byteSize: entries.reduce((total, entry) => total + entry.byteSize, 0),
+        files: entries,
+    };
+}

package/dist/vendor/harness/lib/findings.js

@@ -0,0 +1,32 @@
+// packages/harness/src/lib/findings.ts - FINDING_CODES: every mount.*, compile.* and assemble.* finding code, in one
+// list each subpath re-exports. docs/architecture/systems/harness-compiler.md and harness-records.md speak for it.
+export const FINDING_CODES = [
+    'assemble.unknown_kind',
+    'assemble.unsafe_path',
+    'assemble.missing_primary',
+    'assemble.missing_component',
+    'assemble.duplicate_path',
+    'assemble.unparsable_json',
+    'compile.no_model',
+    'compile.model_failed',
+    'compile.anchor_missing',
+    'compile.frontmatter_changed',
+    'compile.policy_over_budget',
+    'compile.skill_catalog_over_budget',
+    'mount.schema_unknown',
+    'mount.runtime_unknown',
+    'mount.bad_sha256',
+    'mount.unsafe_path',
+    'mount.contract_outside',
+    'mount.digest_mismatch',
+    'mount.expected_digest_mismatch',
+    'mount.object_mismatch',
+    'mount.cache_corrupt',
+    'mount.fetch_failed',
+    'mount.no_route',
+    'mount.project_unknown',
+    'mount.contract_edited',
+    'mount.kept_edited',
+    'mount.merge_target_tracked',
+    'mount.merge_target_unparsable',
+];

package/dist/vendor/harness/lib/frontmatter.js

@@ -0,0 +1,79 @@
+// packages/harness/src/lib/frontmatter.ts - The leading frontmatter block and one key's value, ported from etna
+// harness/code/hooks/lib/ownership.mjs (frontmatter, unquote, cleanItem, field, asList). Pure, so the Worker runs it.
+// docs/architecture/systems/harness-records.md speaks for it.
+/** The leading `--- … ---` frontmatter block's body; "" when the text has none. */
+export function frontmatter(text) {
+    const match = /^?---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+    return match ? match[1] : '';
+}
+/** The frontmatter block with its fences and the line break after them, byte for byte; "" when there is none. */
+export function frontmatterBlock(text) {
+    const match = /^?---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/.exec(text);
+    return match ? match[0] : '';
+}
+/** The text after the frontmatter block. */
+export const bodyOf = (text) => text.slice(frontmatterBlock(text).length);
+export function unquote(value) {
+    return String(value).trim().replace(/^["']|["']$/g, '').trim();
+}
+/** One YAML list item: a quoted item ends at its closing quote; an unquoted one ends at ` #`. */
+export function cleanItem(value) {
+    const text = String(value).trim();
+    const quote = text[0];
+    if (quote === '"' || quote === "'") {
+        const end = text.indexOf(quote, 1);
+        if (end > 0)
+            return text.slice(1, end).trim();
+    }
+    const hash = text.search(/\s#/);
+    return unquote(hash >= 0 ? text.slice(0, hash) : text);
+}
+function parseInlineArray(raw) {
+    const end = raw.indexOf(']');
+    const body = (end >= 0 ? raw.slice(0, end) : raw).replace(/^\[/, '');
+    return body
+        .split(',')
+        .map((item) => cleanItem(item))
+        .filter(Boolean);
+}
+/** One frontmatter key: a scalar, an inline array, or a following `- item` block; undefined when absent. */
+export function field(block, key) {
+    const lines = block.split(/\r?\n/);
+    const head = new RegExp(`^${key}\\s*:\\s*(.*)$`);
+    for (let i = 0; i < lines.length; i++) {
+        const match = head.exec(lines[i]);
+        if (!match)
+            continue;
+        const raw = match[1].trim();
+        if (raw === '') {
+            const next = (lines[i + 1] ?? '').trim();
+            if (next.startsWith('[')) {
+                let joined = '';
+                for (let j = i + 1; j < lines.length; j++) {
+                    joined += (joined ? ' ' : '') + lines[j].trim();
+                    if (lines[j].includes(']'))
+                        break;
+                }
+                return parseInlineArray(joined);
+            }
+            const items = [];
+            for (let j = i + 1; j < lines.length; j++) {
+                const item = /^\s*-\s+(.*)$/.exec(lines[j]);
+                if (!item)
+                    break;
+                items.push(cleanItem(item[1]));
+            }
+            return items;
+        }
+        if (raw.startsWith('['))
+            return parseInlineArray(raw);
+        return unquote(raw);
+    }
+    return undefined;
+}
+/** A scalar, list or absent field as a clean string list. */
+export function asList(value) {
+    if (value == null)
+        return [];
+    return (Array.isArray(value) ? value : [value]).map((item) => String(item).trim()).filter(Boolean);
+}

package/dist/vendor/harness/lib/paths.js

@@ -0,0 +1,31 @@
+// packages/harness/src/lib/paths.ts - The one spelling of a relative path the package accepts, and the posix
+// helpers the Worker-safe modules use instead of node:path. docs/architecture/systems/harness-compiler.md speaks for it.
+/** True for a non-empty `/`-joined relative path: no leading slash, drive letter or backslash, no `.`, `..` or empty segment. */
+export function isSafeRelativePath(path) {
+    if (typeof path !== 'string' || path.length === 0 || path.length > 1024)
+        return false;
+    if (path.includes('\\') || path.includes('\0') || path.startsWith('/') || /^[A-Za-z]:/.test(path))
+        return false;
+    return path.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..');
+}
+/** Resolves `relative` against the folder `base` (both `/`-joined, repository-relative); null when it climbs out. */
+export function joinPosix(base, relative) {
+    const parts = base === '' ? [] : base.split('/');
+    for (const segment of relative.split('/')) {
+        if (segment === '' || segment === '.')
+            continue;
+        if (segment === '..') {
+            if (parts.length === 0)
+                return null;
+            parts.pop();
+        }
+        else
+            parts.push(segment);
+    }
+    return parts.join('/');
+}
+export const dirnamePosix = (path) => (path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '');
+export const basenamePosix = (path) => path.slice(path.lastIndexOf('/') + 1);
+export const depthOf = (path) => path.split('/').length;
+/** Sorts by path in code-unit order, the order the content digest is defined over. */
+export const byPath = (a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0);