@deftai/directive-core 0.88.0 → 0.89.0

package/dist/triage/welcome/writers.js

@@ -1,6 +1,6 @@
-import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { assertProjectionContained } from "../../fs/projection-containment.js";
+import { containedWrite } from "../../fs/contained-write.js";
 import { hasArtifactSuffix, resolveLifecycleFolder, resolveProjectDefinitionPath, } from "../../layout/resolve.js";
 import { migrateLegacyPolicyKey, PLAN_POLICY_KEY } from "../../policy/plan-extensions.js";
 import { projectDefinitionMutationLock } from "../../vbrief-build/project-definition-io.js";
@@ -12,22 +12,51 @@ function utcIso() {
     return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 }
 export function appendAuditEntry(projectRoot, entry) {
-    const logPath = join(resolve(projectRoot), AUDIT_LOG_REL_PATH);
-    assertProjectionContained(projectRoot, logPath);
-    mkdirSync(dirname(logPath), { recursive: true });
-    const line = `${utcIso()} ${entry}\n`;
+    const root = resolve(projectRoot);
+    const logPath = join(root, AUDIT_LOG_REL_PATH);
+    // #2980 wave D: product write sink routes through containedWrite.
+    mkdirSync(root, { recursive: true });
     if (!existsSync(logPath)) {
-        writeFileSync(logPath, "# meta/policy-changes.log -- audit trail for PROJECT-DEFINITION plan.policy.* mutations (#746 / #1143)\n", "utf8");
+        containedWrite({
+            root,
+            target: AUDIT_LOG_REL_PATH,
+            data: "# meta/policy-changes.log -- audit trail for PROJECT-DEFINITION plan.policy.* mutations (#746 / #1143)\n",
+            mode: "create",
+        });
     }
-    appendFileSync(logPath, line, "utf8");
+    containedWrite({
+        root,
+        target: AUDIT_LOG_REL_PATH,
+        data: `${utcIso()} ${entry}\n`,
+        mode: "append",
+    });
     return logPath;
 }
-function atomicWrite(path, data) {
-    mkdirSync(dirname(path), { recursive: true });
+function atomicWrite(_projectRoot, path, data) {
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
     const payload = `${JSON.stringify(data, null, 2)}\n`;
-    const tmp = join(dirname(path), `.${Date.now()}.tmp`);
-    writeFileSync(tmp, payload, "utf8");
-    renameSync(tmp, path);
+    const tmpName = `.${Date.now()}.tmp`;
+    const tmp = join(dir, tmpName);
+    try {
+        // #2980 wave D: temp payload write uses containedWrite under the parent dir.
+        containedWrite({
+            root: resolve(dir),
+            target: tmpName,
+            data: payload,
+            mode: "create",
+        });
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
 }
 export function writeTriageScope(projectRoot, rules, options = { presetLabel: "custom" }) {
     // Serialise read-modify-write + audit append under the shared lock (#1260).
@@ -54,7 +83,7 @@ export function writeTriageScope(projectRoot, rules, options = { presetLabel: "c
         const policyRec = policy;
         const previous = policyRec.triageScope;
         policyRec.triageScope = rules;
-        atomicWrite(path, data);
+        atomicWrite(projectRoot, path, data);
         const changed = JSON.stringify(previous) !== JSON.stringify(rules);
         const actor = options.actor ?? WELCOME_AUDIT_TAG;
         const auditEntry = [
@@ -101,14 +130,14 @@ export function writeWipCap(projectRoot, wipCap, options = {}) {
         }
         if (previous !== undefined && wipCap === DEFAULT_WIP_CAP) {
             delete policyRec.wipCap;
-            atomicWrite(path, data);
+            atomicWrite(projectRoot, path, data);
             const auditEntry = `actor=${actor} field=plan.policy.wipCap action=cleared-to-default value=${wipCap} ` +
                 `previous=${JSON.stringify(previous)} changed=true`;
             appendAuditEntry(projectRoot, auditEntry);
             return [true, auditEntry];
         }
         policyRec.wipCap = wipCap;
-        atomicWrite(path, data);
+        atomicWrite(projectRoot, path, data);
         const changed = previous !== wipCap;
         const auditEntry = `actor=${actor} field=plan.policy.wipCap value=${wipCap} previous=${JSON.stringify(previous)} ` +
             `changed=${changed ? "true" : "false"}`;

package/dist/validate-content/validate-links.js

@@ -10,6 +10,11 @@ const EXCLUDE_DIRS = new Set([
     "dist",
     ".planning",
     "specs",
+    // Swarm / agent worktrees are not framework content; walking them
+    // during release Step 5 / task check is pure wall-clock waste (#2953, #1656).
+    ".deft-scratch",
+    // Legacy swarm worktree root name (pre-.deft-scratch layout).
+    "swarm-worktrees",
 ]);
 function shouldSkipPath(parts) {
     if (parts.some((p) => EXCLUDE_DIRS.has(p)))

package/dist/value/readback.js

@@ -1,8 +1,9 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { runningInsideDeftRepo } from "../doctor/paths.js";
 import { ALL_ATTRIBUTION_EVENT_NAMES } from "../events/attribution-constants.js";
-import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
+import { ContainedWriteError, containedWrite } from "../fs/contained-write.js";
+import { ProjectionContainmentError } from "../fs/projection-containment.js";
 import { DEFAULT_EVENT_LOG, readEvents } from "../lifecycle/events.js";
 import { policyColonInvocation } from "../policy/policy-invocation.js";
 import { isValueFeedbackPathAllowed, resolveValueFeedback, } from "../policy/value-feedback.js";
@@ -230,12 +231,16 @@ function appendReadbackHistory(projectRoot, eventId, line, options = {}) {
         line,
     };
     try {
-        assertWriteTargetSafe(projectRoot, path);
-        mkdirSync(join(path, ".."), { recursive: true });
-        appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
+        // #2980 wave D: product write sink routes through containedWrite.
+        containedWrite({
+            root: resolve(projectRoot),
+            target: path,
+            data: `${JSON.stringify(record)}\n`,
+            mode: "append",
+        });
     }
     catch (err) {
-        if (err instanceof ProjectionContainmentError) {
+        if (err instanceof ProjectionContainmentError || err instanceof ContainedWriteError) {
             throw err;
         }
         // observability only

package/dist/vbrief-activate/activate.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
-import { basename, dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { utcNowIso } from "../scope/vbrief-json.js";
 import { pythonJsonPretty } from "../vbrief-build/json.js";
 import { ACTIVE_FOLDER, ELIGIBLE_STATUSES_FOR_FLIP, formatEligibleStatusList, SOURCE_FOLDERS, TARGET_STATUS, } from "./constants.js";
@@ -150,15 +151,22 @@ export function activate(vbriefPath, options = {}) {
                 "collision manually before re-running `task vbrief:activate`.",
         };
     }
+    const tmpBase = `${fileName}.tmp`;
     const tmp = `${dest}.tmp`;
     try {
-        writeFileSync(tmp, pythonJsonPretty(payload), "utf8");
+        // #2980 wave D: product write sink routes through containedWrite.
+        containedWrite({
+            root: resolve(activeDir),
+            target: tmpBase,
+            data: pythonJsonPretty(payload),
+            mode: "create",
+        });
         renameSync(tmp, dest);
     }
     catch (err) {
         const e = err;
         try {
-            unlinkSync(tmp);
+            rmSync(tmp, { force: true });
         }
         catch {
             /* best-effort cleanup */

package/dist/vbrief-build/project-definition-io.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeSync, } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { pythonJsonPretty } from "./json.js";
 import { ProjectDefinitionIOError } from "./types.js";
@@ -105,12 +106,19 @@ export function loadProjectDefinitionForMutation(projectRoot) {
 }
 /** Atomically write ``data`` to ``path`` as pretty-printed JSON. */
 export function atomicWriteProjectDefinition(path, data) {
-    mkdirSync(dirname(path), { recursive: true });
+    // #2980 wave C: product write sink routes through containedWrite (temp under parent).
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
     const payload = pythonJsonPretty(data).replace(/\n$/, "");
-    const tmp = join(dirname(path), `${path.split(/[/\\]/).pop()}.${randomBytes(4).toString("hex")}.tmp`);
+    const body = payload.endsWith("\n") ? payload : `${payload}\n`;
+    const tmpName = `${basename(path)}.${randomBytes(4).toString("hex")}.tmp`;
+    const tmp = join(dir, tmpName);
     try {
-        writeFileSync(tmp, payload.endsWith("\n") ? payload : `${payload}\n`, {
-            encoding: "utf8",
+        containedWrite({
+            root: resolve(dir),
+            target: tmpName,
+            data: body,
+            mode: "create",
         });
         renameSync(tmp, path);
     }

package/dist/verify-source/contained-writes.d.ts

@@ -0,0 +1,59 @@
+/**
+ * contained-writes.ts — inventory gate for raw product write sinks (#2951).
+ *
+ * Scans TypeScript under packages/core/src (and optional roots) for raw write
+ * call patterns (`writeFileSync`, `appendFileSync`, `fs.writeFile`, etc.)
+ * outside an allowlist. Default remains **fail-open** (advisory exit 0) while
+ * mass migration continues; pass `--enforce` to fail closed (Phase 2+).
+ *
+ * Allowlist is the residual set of modules not yet migrated onto containedWrite.
+ * Phase 2 removed cache/io + lifecycle/events after sink migration.
+ *
+ * Exit codes:
+ *   0 — clean OR fail-open with findings (default)
+ *   1 — findings under `--enforce` (fail-closed)
+ *   2 — config error (project root missing)
+ *
+ * Refs #2951, #2980 (e2e/parity harness exclusions).
+ */
+/** Patterns that indicate a raw filesystem write sink in product code. */
+export declare const RAW_WRITE_PATTERNS: readonly RegExp[];
+/**
+ * Relative path prefixes (posix-style) allowed to use raw write sinks.
+ * Shrink as sinks migrate onto containedWrite (#2951 Phase 2+).
+ */
+export declare const CONTAINED_WRITES_ALLOWLIST: readonly string[];
+/**
+ * Non-product harness path markers excluded from the product inventory (#2980).
+ * Prefer exclusion over permanent CONTAINED_WRITES_ALLOWLIST entries for e2e/parity noise.
+ * Paths are matched as posix substrings after `toPosix` (always `/` separators).
+ */
+export declare const NON_PRODUCT_HARNESS_PATH_MARKERS: readonly string[];
+export interface ContainedWriteFinding {
+    readonly path: string;
+    readonly line: number;
+    readonly match: string;
+}
+export interface ContainedWritesOptions {
+    readonly projectRoot: string;
+    /** When true, exit 1 if any non-allowlisted raw write is found. Default false (fail-open). */
+    readonly enforce?: boolean;
+    /** Extra relative path prefixes to allow. */
+    readonly extraAllowlist?: readonly string[];
+    /** Roots to scan relative to projectRoot. Default packages/core/src. */
+    readonly scanRoots?: readonly string[];
+}
+export interface ContainedWritesResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+    readonly findings: readonly ContainedWriteFinding[];
+    readonly enforce: boolean;
+    readonly failOpen: boolean;
+}
+/**
+ * Inventory raw write sinks under scan roots; fail-open by default (#2951).
+ * Pass `enforce: true` / `--enforce` to fail closed on findings (Phase 2 path).
+ */
+export declare function evaluateContainedWrites(options: ContainedWritesOptions): ContainedWritesResult;
+//# sourceMappingURL=contained-writes.d.ts.map

package/dist/verify-source/contained-writes.js

@@ -0,0 +1,272 @@
+/**
+ * contained-writes.ts — inventory gate for raw product write sinks (#2951).
+ *
+ * Scans TypeScript under packages/core/src (and optional roots) for raw write
+ * call patterns (`writeFileSync`, `appendFileSync`, `fs.writeFile`, etc.)
+ * outside an allowlist. Default remains **fail-open** (advisory exit 0) while
+ * mass migration continues; pass `--enforce` to fail closed (Phase 2+).
+ *
+ * Allowlist is the residual set of modules not yet migrated onto containedWrite.
+ * Phase 2 removed cache/io + lifecycle/events after sink migration.
+ *
+ * Exit codes:
+ *   0 — clean OR fail-open with findings (default)
+ *   1 — findings under `--enforce` (fail-closed)
+ *   2 — config error (project root missing)
+ *
+ * Refs #2951, #2980 (e2e/parity harness exclusions).
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+const EXIT_OK = 0;
+const EXIT_ENFORCE_FINDINGS = 1;
+const EXIT_CONFIG = 2;
+/** Patterns that indicate a raw filesystem write sink in product code. */
+export const RAW_WRITE_PATTERNS = [
+    /\bwriteFileSync\s*\(/,
+    /\bappendFileSync\s*\(/,
+    /\bfs\.writeFile\s*\(/,
+    /\bfs\.promises\.writeFile\s*\(/,
+    /\bcreateWriteStream\s*\(/,
+    /\bwriteFile\s*\(\s*[^)]+,\s*[^)]+,\s*['"]utf8['"]/,
+    // Low-level / async forms that also bypass containedWrite (#2951 Greptile P1).
+    /\bopenSync\s*\(/,
+    /\bwriteSync\s*\(/,
+    /\bappendFile\s*\(/,
+    /\.writeFile\s*\(/,
+    /\bpromises\.writeFile\s*\(/,
+    /\bfs\.open\s*\(/,
+    /\bfs\.write\s*\(/,
+];
+/**
+ * Relative path prefixes (posix-style) allowed to use raw write sinks.
+ * Shrink as sinks migrate onto containedWrite (#2951 Phase 2+).
+ */
+export const CONTAINED_WRITES_ALLOWLIST = [
+    // Implementation modules for containment + contained write.
+    "packages/core/src/fs/contained-write.ts",
+    "packages/core/src/fs/projection-containment.ts",
+    // Deposit tree copy / contain primitives (low-level install sinks).
+    "packages/core/src/deposit/copy-tree.ts",
+    "packages/core/src/deposit/contain.ts",
+    // Lock / stream primitives (not product payload writers) — #2980 residual.
+    "packages/core/src/slice/lock.ts",
+    "packages/core/src/vbrief-build/project-definition-io.ts", // openSync mutation lock only
+    "packages/core/src/release/build-dist.ts", // createWriteStream archive packer
+    // Temporary residual product sinks (#2980 wave D). Shrink as modules migrate.
+    "packages/core/src/doctor/main.ts",
+    "packages/core/src/eval-health-relocation/evaluate.ts",
+    "packages/core/src/intake/issue-ingest.ts",
+    "packages/core/src/intake/reconcile-issues.ts",
+    "packages/core/src/issue-sync/sync-from-xbrief.ts",
+    "packages/core/src/orchestration/probe-session.ts",
+    "packages/core/src/orchestration/verify-judgment-gates.ts",
+    "packages/core/src/platform/changelog-cli.ts",
+    "packages/core/src/release/gh.ts",
+    "packages/core/src/release/pipeline-fixture.ts",
+    "packages/core/src/release/pipeline.ts",
+    "packages/core/src/render/export-spec.ts",
+    "packages/core/src/render/prd-render.ts",
+    "packages/core/src/render/roadmap-render.ts",
+    "packages/core/src/render/rule-map.ts",
+    "packages/core/src/render/spec-render.ts",
+    "packages/core/src/scm/gh-rest.ts",
+    "packages/core/src/triage/actions/candidates-log.ts",
+    "packages/core/src/triage/bootstrap/index.ts",
+    "packages/core/src/triage/reconcile/reconcile.ts",
+    "packages/core/src/triage/scope-drift/add-ignore.ts",
+    "packages/core/src/triage/scope/coverage.ts",
+    "packages/core/src/triage/scope/mutations-core.ts",
+    "packages/core/src/triage/smoketest/index.ts",
+    "packages/core/src/triage/subscribe/index.ts",
+    "packages/core/src/triage/summary/index.ts",
+    "packages/core/src/vbrief-build/speckit.ts",
+    "packages/core/src/vbrief-reconcile/reconciliation.ts",
+    "packages/core/src/vbrief-validation/safety.ts",
+    "packages/core/src/xbrief-migrate/agents-header.ts",
+    // Phase 2 removed: cache/io.ts, lifecycle/events.ts (migrated to containedWrite).
+];
+/** Path segments that mark a file as test or fixture (always allowlisted). */
+const TEST_PATH_MARKERS = [
+    ".test.ts",
+    ".test.tsx",
+    "/test-helpers.ts",
+    "/fixtures/",
+    "\\fixtures\\",
+];
+/**
+ * Non-product harness path markers excluded from the product inventory (#2980).
+ * Prefer exclusion over permanent CONTAINED_WRITES_ALLOWLIST entries for e2e/parity noise.
+ * Paths are matched as posix substrings after `toPosix` (always `/` separators).
+ */
+export const NON_PRODUCT_HARNESS_PATH_MARKERS = [
+    "/release-e2e/",
+    "/integration-e2e/",
+    "parity-scenarios.ts",
+    "parity-scenarios.tsx",
+];
+function toPosix(p) {
+    return p.split(sep).join("/");
+}
+function isTestPath(relPosix) {
+    return TEST_PATH_MARKERS.some((m) => relPosix.includes(m.replace(/\\/g, "/")));
+}
+/** E2E / parity harness under src/ — not product sinks (#2980 scanner hygiene). */
+function isNonProductHarnessPath(relPosix) {
+    return NON_PRODUCT_HARNESS_PATH_MARKERS.some((m) => relPosix.includes(m));
+}
+/** Strip trailing `/` without regex (CodeQL js/polynomial-redos safe). */
+function stripTrailingSlashes(path) {
+    let end = path.length;
+    while (end > 0 && path.charCodeAt(end - 1) === 47 /* / */) {
+        end -= 1;
+    }
+    return end === path.length ? path : path.slice(0, end);
+}
+function isAllowlisted(relPosix, allow) {
+    if (isTestPath(relPosix) || isNonProductHarnessPath(relPosix)) {
+        return true;
+    }
+    return allow.some((entry) => {
+        // Avoid regex on path input (CodeQL js/polynomial-redos on /\/+$/).
+        const e = stripTrailingSlashes(entry.split("\\").join("/"));
+        // Exact file match, or directory-prefix only (never bare endsWith — that
+        // lets `evil/.../packages/core/src/fs/contained-write.ts` slip through).
+        return relPosix === e || relPosix.startsWith(`${e}/`);
+    });
+}
+function walkTsFiles(dir, out) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (name === "node_modules" || name === "dist" || name === ".git") {
+            continue;
+        }
+        const full = join(dir, name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            walkTsFiles(full, out);
+        }
+        else if (st.isFile() && (name.endsWith(".ts") || name.endsWith(".tsx"))) {
+            out.push(full);
+        }
+    }
+}
+function scanFile(absPath, relPosix) {
+    let text;
+    try {
+        text = readFileSync(absPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const findings = [];
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        // Skip import lines and comments-only lines for noise reduction.
+        const trimmed = line.trim();
+        if (trimmed.startsWith("import ") ||
+            trimmed.startsWith("//") ||
+            trimmed.startsWith("*") ||
+            trimmed.startsWith("/*")) {
+            continue;
+        }
+        for (const re of RAW_WRITE_PATTERNS) {
+            if (re.test(line)) {
+                findings.push({
+                    path: relPosix,
+                    line: i + 1,
+                    match: trimmed.length > 100 ? `${trimmed.slice(0, 97)}...` : trimmed,
+                });
+                break;
+            }
+        }
+    }
+    return findings;
+}
+/**
+ * Inventory raw write sinks under scan roots; fail-open by default (#2951).
+ * Pass `enforce: true` / `--enforce` to fail closed on findings (Phase 2 path).
+ */
+export function evaluateContainedWrites(options) {
+    const root = resolve(options.projectRoot);
+    if (!existsSync(root)) {
+        return {
+            code: EXIT_CONFIG,
+            message: `verify:contained-writes: project root not found: ${root}`,
+            stream: "stderr",
+            findings: [],
+            enforce: Boolean(options.enforce),
+            failOpen: !options.enforce,
+        };
+    }
+    const enforce = options.enforce === true;
+    const allow = [...CONTAINED_WRITES_ALLOWLIST, ...(options.extraAllowlist ?? [])];
+    const scanRoots = options.scanRoots ?? ["packages/core/src"];
+    const findings = [];
+    for (const scanRel of scanRoots) {
+        const scanAbs = resolve(root, scanRel);
+        if (!existsSync(scanAbs)) {
+            continue;
+        }
+        const files = [];
+        walkTsFiles(scanAbs, files);
+        for (const abs of files) {
+            const relPosix = toPosix(relative(root, abs));
+            if (isAllowlisted(relPosix, allow)) {
+                continue;
+            }
+            findings.push(...scanFile(abs, relPosix));
+        }
+    }
+    if (findings.length === 0) {
+        return {
+            code: EXIT_OK,
+            message: `OK: verify:contained-writes — no non-allowlisted raw write sinks under ${scanRoots.join(", ")} (enforce=${enforce}).`,
+            stream: "stdout",
+            findings: [],
+            enforce,
+            failOpen: !enforce,
+        };
+    }
+    const lines = [
+        `verify:contained-writes: found ${findings.length} raw write sink(s) outside allowlist:`,
+        ...findings.slice(0, 50).map((f) => `  ${f.path}:${f.line}: ${f.match}`),
+    ];
+    if (findings.length > 50) {
+        lines.push(`  ... and ${findings.length - 50} more`);
+    }
+    if (enforce) {
+        lines.push("FAIL: --enforce is set; migrate sinks to packages/core/src/fs/contained-write.ts or add a justified allowlist entry (#2951).");
+        return {
+            code: EXIT_ENFORCE_FINDINGS,
+            message: lines.join("\n"),
+            stream: "stderr",
+            findings,
+            enforce: true,
+            failOpen: false,
+        };
+    }
+    lines.push("ADVISORY (fail-open): exit 0. Prefer containedWrite() for new sinks; pass --enforce to fail closed. See docs/reference/contained-write.md (#2951 Phase 2).");
+    return {
+        code: EXIT_OK,
+        message: lines.join("\n"),
+        stream: "stdout",
+        findings,
+        enforce: false,
+        failOpen: true,
+    };
+}
+//# sourceMappingURL=contained-writes.js.map

package/dist/verify-source/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./biome-config.js";
 export * from "./code-structure-validate.js";
+export * from "./contained-writes.js";
 export * from "./content-manifest.js";
 export { CANONICAL_SCHEMA_REL, type ContractDriftOptions, type ContractDriftResult, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";

package/dist/verify-source/index.js

@@ -1,5 +1,6 @@
 export * from "./biome-config.js";
 export * from "./code-structure-validate.js";
+export * from "./contained-writes.js";
 export * from "./content-manifest.js";
 export { CANONICAL_SCHEMA_REL, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";

package/dist/verify-source/openclaw-tier1.js

@@ -14,7 +14,20 @@ export const OPENCLAW_TIER1_TARGETS = [
     {
         path: "content/skills/deft-directive-swarm/references/host-openclaw.md",
         label: "swarm OpenClaw host adapter",
-        markers: ["Step 2f: OpenClaw Launch", "sessions_spawn", "openclaw"],
+        // Cold-start (#2968 A7): project root + Skills Index before freestyle; keep Tier-1 launch markers.
+        markers: [
+            "Step 2f: OpenClaw Launch",
+            "sessions_spawn",
+            "openclaw",
+            "Cold-start",
+            "Skills Index",
+            "project root",
+        ],
+    },
+    {
+        path: "content/contracts/host-lifecycle-duties.md",
+        label: "host lifecycle duty list contract (#2968 A3)",
+        markers: ["Session start", "Deft-shaped user intent", "Skills Index", "project root"],
     },
     {
         path: "packages/core/src/swarm/routing.ts",

package/dist/verify-source/verify-stubs.js

@@ -11,6 +11,9 @@ export const EXCLUDE_DIRS = new Set([
     "__pycache__",
     "dist",
     "scripts",
+    // Swarm / agent worktrees are not product source (#2953, #1656).
+    ".deft-scratch",
+    "swarm-worktrees",
 ]);
 export const EXTENSIONS = new Set([".py", ".go", ".sh"]);
 function isWordChar(ch) {