@deftai/directive-core 0.106.0 → 0.108.0

package/dist/design-critique/completed-arc-record.js

@@ -0,0 +1,232 @@
+/**
+ * Completed-arc record for design-critique ingest (#3806).
+ *
+ * Catalog chips are list-visible convenience, not clearance. Ingest waits on
+ * `design-critique: synthesis accepted, because ...` citing an accepted
+ * successor lean (and the verified-claims table when that comment exists).
+ *
+ * Citations are parsed once, by `scanCitations` (#3831). The accepted forms and
+ * the refused positions are published in `content/contracts/design-critique.md`
+ * `## Citation grammar`. Clearance is set membership against the latest
+ * successor lean, not position in the body, so citing the superseded lean --
+ * which `## Successor lean` requires -- cannot block.
+ */
+import { ACCEPTED_CITATION_FORMS, scanCitations, } from "./citation-grammar.js";
+import { DESIGN_CRITIQUE_CATALOG_CHIPS } from "./exclusive-chip.js";
+const SYNTHESIS_SHAPE_RE = /(?:^|\n)\s*design-critique:\s*synthesis accepted,\s*because\b/i;
+const LEAN_HEADING_RE = /(?:^|\n)\s*\*{0,2}Lean:\*{0,2}/;
+const TABLE_HEADING_RE = /(?:^|\n)\s*##\s+Verified-claims table\b/;
+/** How many ids a block detail lists before it truncates. */
+const DETAIL_ID_LIMIT = 5;
+const CATALOG = new Set(DESIGN_CRITIQUE_CATALOG_CHIPS);
+export class DesignCritiqueIngestBlockedError extends Error {
+    issueNumber;
+    reason;
+    constructor(issueNumber, reason, detail) {
+        super(`issue:ingest refused #${issueNumber}: design-critique ${reason} (${detail}) -- nothing written.`);
+        this.name = "DesignCritiqueIngestBlockedError";
+        this.issueNumber = issueNumber;
+        this.reason = reason;
+    }
+}
+export function isSynthesisAcceptedShape(body) {
+    return SYNTHESIS_SHAPE_RE.test(body);
+}
+export function isSuccessorLeanBody(body) {
+    return LEAN_HEADING_RE.test(body);
+}
+export function isVerifiedClaimsTableBody(body) {
+    return TABLE_HEADING_RE.test(body);
+}
+/**
+ * Ids cited by one comment body, in document order. Thin projection of the
+ * shared parser -- the grammar itself lives in `citation-grammar.ts`.
+ */
+export function extractCitedCommentIds(body) {
+    const ids = [];
+    const seen = new Set();
+    for (const citation of scanCitations(body).citations) {
+        if (seen.has(citation.id))
+            continue;
+        seen.add(citation.id);
+        ids.push(citation.id);
+    }
+    return ids;
+}
+export function hasDesignCritiqueCatalogChip(labels) {
+    return labels.some((name) => CATALOG.has(name));
+}
+const CRITIC_ROLE_RE = /(?:^|\n)\s*role:\s*critic\b/i;
+const MECHANISM_SHAPED_FIELD_RE = /(?:^|\n)\s*mechanism-shaped:\s*true\b/i;
+const PANEL_DEPOSIT_RE = /(?:^|\n)\s*panel-deposit\b/i;
+const PARENT_ROLE_RE = /(?:^|\n)\s*role:\s*parent\b/i;
+const SIBLINGS_FIELD_RE = /(?:^|\n)\s*siblings:\s*\d+/i;
+const INPUT_CEILING_FIELD_RE = /(?:^|\n)\s*input-ceiling:\s*\d+/i;
+export function isPanelDepositBody(body) {
+    if (PANEL_DEPOSIT_RE.test(body))
+        return true;
+    return (PARENT_ROLE_RE.test(body) && SIBLINGS_FIELD_RE.test(body) && INPUT_CEILING_FIELD_RE.test(body));
+}
+export function isInFlightCritiqueThread(comments) {
+    return comments.some((comment) => isSuccessorLeanBody(comment.body) ||
+        CRITIC_ROLE_RE.test(comment.body) ||
+        MECHANISM_SHAPED_FIELD_RE.test(comment.body) ||
+        isPanelDepositBody(comment.body));
+}
+function byId(comments) {
+    const map = new Map();
+    for (const comment of comments) {
+        map.set(comment.id, comment);
+    }
+    return map;
+}
+function latestSuccessorLean(comments) {
+    let latest;
+    for (const comment of comments) {
+        if (!isSuccessorLeanBody(comment.body))
+            continue;
+        if (latest === undefined || comment.id > latest.id)
+            latest = comment;
+    }
+    return latest;
+}
+function renderIds(ids) {
+    const shown = ids.slice(0, DETAIL_ID_LIMIT).join(", ");
+    return ids.length > DETAIL_ID_LIMIT
+        ? `${shown}, and ${ids.length - DETAIL_ID_LIMIT} more`
+        : shown;
+}
+/**
+ * Report what was scanned and what was found. A guess at the cause sends the
+ * operator back to re-post the same body and reproduce the block (#3831).
+ */
+function loneShapeDetail(scan) {
+    const parts = [
+        "synthesis-accepted sentence shape is present but cites no accepted successor lean",
+    ];
+    if (scan.idShapedRuns.length === 0) {
+        parts.push("no 8-or-more digit id appears in the body");
+    }
+    else {
+        parts.push(`${scan.idShapedRuns.length} 8-or-more digit id(s) appear in the body: ` +
+            renderIds(scan.idShapedRuns));
+    }
+    if (scan.rejected.length > 0) {
+        const classes = [...new Set(scan.rejected.map((row) => row.reason))].sort().join(", ");
+        parts.push(`${scan.rejected.length} keyword-anchored occurrence(s) refused by position (${classes})`);
+    }
+    parts.push(`accepted forms: ${ACCEPTED_CITATION_FORMS.join(" | ")}`);
+    return parts.join("; ");
+}
+function resolveCitedLean(citations, byCommentId, latestLean) {
+    if (latestLean !== undefined && citations.some((row) => row.id === latestLean.id)) {
+        return latestLean;
+    }
+    return citations
+        .map((row) => byCommentId.get(row.id))
+        .find((row) => row !== undefined && isSuccessorLeanBody(row.body));
+}
+function verdictForSynthesis(comment, comments) {
+    const scan = scanCitations(comment.body);
+    const citations = scan.citations;
+    if (citations.length === 0) {
+        return {
+            status: "blocked",
+            reason: "lone-shape",
+            detail: loneShapeDetail(scan),
+        };
+    }
+    const byCommentId = byId(comments);
+    const citedLean = resolveCitedLean(citations, byCommentId, latestSuccessorLean(comments));
+    if (citedLean === undefined) {
+        return {
+            status: "blocked",
+            reason: "cite-not-lean",
+            detail: "no cited id is a successor lean on this thread; cited: " +
+                renderIds(citations.map((row) => row.id)),
+        };
+    }
+    const citedTable = citations
+        .map((row) => byCommentId.get(row.id))
+        .find((row) => row !== undefined && isVerifiedClaimsTableBody(row.body));
+    if (citedTable === undefined) {
+        const claimed = citations.filter((row) => row.kind === "table");
+        if (claimed.length > 0) {
+            return {
+                status: "blocked",
+                reason: "missing-table-cite",
+                detail: "synthesis cites a verified-claims table id that is not a table on this thread: " +
+                    renderIds(claimed.map((row) => row.id)),
+            };
+        }
+    }
+    return {
+        status: "complete",
+        synthesisCommentId: comment.id,
+        citedLeanId: citedLean.id,
+        citedTableId: citedTable?.id ?? null,
+    };
+}
+/**
+ * Ingest clearance from thread structure. Labels and author identity are not
+ * predicates. A lone synthesis-accepted sentence shape is not the record.
+ * Clearance cites the latest successor lean; an older complete record does not
+ * clear a later recut. A panel-deposit is in-flight even before critic posts.
+ */
+export function evaluateCompletedArcRecord(input) {
+    const comments = input.comments;
+    const labels = input.labels ?? [];
+    const synthesis = comments.filter((c) => isSynthesisAcceptedShape(c.body));
+    const completeRecords = synthesis
+        .map((comment) => verdictForSynthesis(comment, comments))
+        .filter((verdict) => {
+        return verdict.status === "complete";
+    });
+    if (completeRecords.length > 0) {
+        const latestLean = latestSuccessorLean(comments);
+        const matching = latestLean === undefined
+            ? completeRecords
+            : completeRecords.filter((record) => record.citedLeanId === latestLean.id);
+        if (matching.length > 0) {
+            return matching.reduce((a, b) => (a.synthesisCommentId >= b.synthesisCommentId ? a : b));
+        }
+        const latestCompleteId = completeRecords.reduce((max, record) => Math.max(max, record.synthesisCommentId), 0);
+        const laterSynthesis = synthesis.filter((comment) => comment.id > latestCompleteId);
+        if (laterSynthesis.length > 0) {
+            const latest = laterSynthesis.reduce((a, b) => (a.id >= b.id ? a : b));
+            return verdictForSynthesis(latest, comments);
+        }
+        const citedLeanIds = completeRecords.map((record) => record.citedLeanId);
+        const latestLeanId = latestLean === undefined ? "unknown" : String(latestLean.id);
+        return {
+            status: "blocked",
+            reason: "missing-record",
+            detail: `no completed-arc record cites the latest successor lean ${latestLeanId} on this thread; ` +
+                `existing record(s) cite lean ${renderIds(citedLeanIds)}; ` +
+                `ingest waits on a record citing lean ${latestLeanId}`,
+        };
+    }
+    if (synthesis.length > 0) {
+        const latest = synthesis.reduce((a, b) => (a.id >= b.id ? a : b));
+        return verdictForSynthesis(latest, comments);
+    }
+    const inArc = hasDesignCritiqueCatalogChip(labels) || isInFlightCritiqueThread(comments);
+    if (!inArc) {
+        return { status: "not-in-arc" };
+    }
+    return {
+        status: "blocked",
+        reason: "missing-record",
+        detail: "design-critique is in flight but the completed-arc record is missing: " +
+            "`design-critique: synthesis accepted, because ...` citing the accepted successor lean; " +
+            `accepted forms: ${ACCEPTED_CITATION_FORMS.join(" | ")}`,
+    };
+}
+export function assertCompletedArcAllowsIngest(input) {
+    const verdict = evaluateCompletedArcRecord(input);
+    if (verdict.status === "blocked") {
+        throw new DesignCritiqueIngestBlockedError(input.issueNumber, verdict.reason, verdict.detail);
+    }
+    return verdict;
+}
+//# sourceMappingURL=completed-arc-record.js.map

package/dist/design-critique/exclusive-chip.d.ts

@@ -0,0 +1,33 @@
+import type { LabelClient } from "../vbrief-reconcile/types.js";
+/** Closed catalog. Last chip wins. Not an open `design-critique:*` glob. */
+export declare const DESIGN_CRITIQUE_CATALOG_CHIPS: readonly ["design-critique:mechanism-shaped", "design-critique:triage-ready"];
+export type DesignCritiqueCatalogChip = (typeof DESIGN_CRITIQUE_CATALOG_CHIPS)[number];
+export declare function isDesignCritiqueCatalogChip(name: string): name is DesignCritiqueCatalogChip;
+/**
+ * Remaining-set replace: GET current, drop the other catalog names, keep other
+ * facets, then PUT/PATCH this list. One write. No DELETE-then-POST window.
+ */
+export declare function remainingSetAfterDesignCritiqueChip(current: readonly string[], nextChip: string): string[];
+/**
+ * Fold exclusive catalog-chip replace into a LabelClient.apply add/remove
+ * mutation. Production writer: ScmLabelClient.apply.
+ */
+export declare function mergeDesignCritiqueExclusiveIntoApply(current: readonly string[], add: readonly string[], remove: readonly string[]): {
+    add: string[];
+    remove: string[];
+};
+/** Delta for LabelClient.apply (one add+remove mutation). */
+export declare function designCritiqueChipApplyDelta(current: readonly string[], nextChip: string): {
+    add: string[];
+    remove: string[];
+};
+/**
+ * Exclusive catalog-chip write via LabelClient.apply. GET current, then one
+ * apply(add, remove). Does not PUT a naive full wipe.
+ */
+export declare function applyDesignCritiqueCatalogChip(client: LabelClient, repo: string, issueNumber: number, nextChip: string): {
+    remaining: string[];
+    add: readonly string[];
+    remove: readonly string[];
+};
+//# sourceMappingURL=exclusive-chip.d.ts.map

package/dist/design-critique/exclusive-chip.js

@@ -0,0 +1,68 @@
+/** Closed catalog. Last chip wins. Not an open `design-critique:*` glob. */
+export const DESIGN_CRITIQUE_CATALOG_CHIPS = [
+    "design-critique:mechanism-shaped",
+    "design-critique:triage-ready",
+];
+const CATALOG = new Set(DESIGN_CRITIQUE_CATALOG_CHIPS);
+export function isDesignCritiqueCatalogChip(name) {
+    return CATALOG.has(name);
+}
+/**
+ * Remaining-set replace: GET current, drop the other catalog names, keep other
+ * facets, then PUT/PATCH this list. One write. No DELETE-then-POST window.
+ */
+export function remainingSetAfterDesignCritiqueChip(current, nextChip) {
+    if (!isDesignCritiqueCatalogChip(nextChip)) {
+        throw new Error(`not a design-critique catalog chip: ${nextChip} (closed set: ${DESIGN_CRITIQUE_CATALOG_CHIPS.join(", ")})`);
+    }
+    const remaining = current.filter((name) => !CATALOG.has(name));
+    remaining.push(nextChip);
+    return remaining;
+}
+/**
+ * Fold exclusive catalog-chip replace into a LabelClient.apply add/remove
+ * mutation. Production writer: ScmLabelClient.apply.
+ */
+export function mergeDesignCritiqueExclusiveIntoApply(current, add, remove) {
+    const catalogAdds = add.filter(isDesignCritiqueCatalogChip);
+    if (catalogAdds.length === 0) {
+        return { add: [...add], remove: [...remove] };
+    }
+    const nextChip = catalogAdds[catalogAdds.length - 1];
+    const delta = designCritiqueChipApplyDelta(current, nextChip);
+    const addSet = new Set(add.filter((name) => !isDesignCritiqueCatalogChip(name) || name === nextChip));
+    for (const name of delta.add)
+        addSet.add(name);
+    const removeSet = new Set(remove.filter((name) => name !== nextChip));
+    for (const name of delta.remove)
+        removeSet.add(name);
+    removeSet.delete(nextChip);
+    return { add: [...addSet], remove: [...removeSet] };
+}
+/** Delta for LabelClient.apply (one add+remove mutation). */
+export function designCritiqueChipApplyDelta(current, nextChip) {
+    if (!isDesignCritiqueCatalogChip(nextChip)) {
+        throw new Error(`not a design-critique catalog chip: ${nextChip} (closed set: ${DESIGN_CRITIQUE_CATALOG_CHIPS.join(", ")})`);
+    }
+    const currentSet = new Set(current);
+    const remove = DESIGN_CRITIQUE_CATALOG_CHIPS.filter((name) => name !== nextChip && currentSet.has(name));
+    const add = currentSet.has(nextChip) ? [] : [nextChip];
+    return { add, remove };
+}
+/**
+ * Exclusive catalog-chip write via LabelClient.apply. GET current, then one
+ * apply(add, remove). Does not PUT a naive full wipe.
+ */
+export function applyDesignCritiqueCatalogChip(client, repo, issueNumber, nextChip) {
+    const current = client.fetchLabels(repo, issueNumber);
+    const { add, remove } = designCritiqueChipApplyDelta(current, nextChip);
+    if (add.length > 0 || remove.length > 0) {
+        client.apply(repo, issueNumber, add, remove);
+    }
+    return {
+        remaining: remainingSetAfterDesignCritiqueChip(current, nextChip),
+        add,
+        remove,
+    };
+}
+//# sourceMappingURL=exclusive-chip.js.map

package/dist/design-critique/parent-audit.d.ts

@@ -0,0 +1,59 @@
+/** Parent-side substantiation deposit + fail-closed evaluator (#3651 / ADR-006). */
+export type AuditReading = "measured" | "asserted";
+export type AuditRole = "parent" | "critic" | "triage";
+export type AuditPremise = {
+    markerId: string;
+    sha?: string;
+    pointer?: string;
+    reading?: AuditReading;
+    introducedByRole: AuditRole;
+    /** Changes classification, residual, or next-build contract. */
+    loadBearing: boolean;
+};
+export type AuditClearance = {
+    markerId: string;
+    clearedByRole: AuditRole;
+    /** Critic artifact names this marker as its audit target. */
+    targetsMarker: boolean;
+};
+export type AuditEnvelope = {
+    /** Marker ids listed on `audit-targets:`. Empty means the field was omitted. */
+    auditTargets: string[];
+    /** Envelope explicitly set `audit-targets: none`. */
+    declaredNone: boolean;
+};
+export type AuditBindAttempt = {
+    allAcceptMap: boolean;
+    /** Marker ids the bind record still lists as unresolved. */
+    unresolvedMarkerIds: string[];
+};
+export type ParentAuditDeposit = {
+    premises: readonly AuditPremise[];
+    clearances: readonly AuditClearance[];
+    envelopes: readonly AuditEnvelope[];
+    /** Ids the next critic envelope must name. */
+    namedAuditTargets?: readonly string[];
+    bindAttempt?: AuditBindAttempt;
+};
+export type AuditFailureCode = "missing-token" | "parent-self-clear" | "silent-clear" | "bind-unresolved" | "envelope-omits-target" | "marker-collision";
+export type AuditFailure = {
+    code: AuditFailureCode;
+    detail: string;
+};
+export declare function parseAuditToken(token: string): {
+    markerId: string;
+    sha: string;
+    pointer: string;
+    reading: AuditReading;
+} | null;
+export declare function formatAuditToken(parts: {
+    markerId: string;
+    sha: string;
+    pointer: string;
+    reading: AuditReading;
+}): string;
+export declare function evaluateParentAudit(deposit: ParentAuditDeposit): {
+    ok: boolean;
+    failures: AuditFailure[];
+};
+//# sourceMappingURL=parent-audit.d.ts.map

package/dist/design-critique/parent-audit.js

@@ -0,0 +1,121 @@
+/** Parent-side substantiation deposit + fail-closed evaluator (#3651 / ADR-006). */
+const TOKEN_RE = /^audit:([A-Za-z0-9._-]+) sha=([0-9a-fA-F]{7,40}) pointer=(\S+) reading=(measured|asserted)$/;
+export function parseAuditToken(token) {
+    const match = TOKEN_RE.exec(token.trim());
+    if (!match)
+        return null;
+    return {
+        markerId: match[1] ?? "",
+        sha: match[2] ?? "",
+        pointer: match[3] ?? "",
+        reading: (match[4] ?? "asserted"),
+    };
+}
+export function formatAuditToken(parts) {
+    return `audit:${parts.markerId} sha=${parts.sha} pointer=${parts.pointer} reading=${parts.reading}`;
+}
+function independentlyCleared(markerId, clearances, colliding) {
+    if (colliding.has(markerId))
+        return false;
+    return clearances.some((c) => c.markerId === markerId && c.clearedByRole === "critic" && c.targetsMarker);
+}
+function collidingMarkerIds(premises) {
+    const counts = new Map();
+    for (const premise of premises) {
+        if (!premise.loadBearing)
+            continue;
+        counts.set(premise.markerId, (counts.get(premise.markerId) ?? 0) + 1);
+    }
+    return new Set([...counts.entries()].filter(([, n]) => n > 1).map(([id]) => id));
+}
+export function evaluateParentAudit(deposit) {
+    const failures = [];
+    const colliding = collidingMarkerIds(deposit.premises);
+    for (const id of colliding) {
+        failures.push({
+            code: "marker-collision",
+            detail: `load-bearing premises share marker ${id}`,
+        });
+    }
+    for (const premise of deposit.premises) {
+        if (!premise.loadBearing)
+            continue;
+        if (!premise.sha || !premise.pointer || !premise.reading) {
+            failures.push({
+                code: "missing-token",
+                detail: `premise ${premise.markerId} is missing sha, pointer, or reading`,
+            });
+            continue;
+        }
+        const token = formatAuditToken({
+            markerId: premise.markerId,
+            sha: premise.sha,
+            pointer: premise.pointer,
+            reading: premise.reading,
+        });
+        if (!parseAuditToken(token)) {
+            failures.push({
+                code: "missing-token",
+                detail: `premise ${premise.markerId} token failed grammar`,
+            });
+        }
+    }
+    for (const clearance of deposit.clearances) {
+        if (clearance.clearedByRole === "parent") {
+            failures.push({
+                code: "parent-self-clear",
+                detail: `parent cleared marker ${clearance.markerId}`,
+            });
+        }
+    }
+    const computedUnresolved = deposit.premises
+        .filter((p) => p.loadBearing && !independentlyCleared(p.markerId, deposit.clearances, colliding))
+        .map((p) => p.markerId);
+    const named = deposit.namedAuditTargets ?? [];
+    if (named.length > 0) {
+        if (deposit.envelopes.length === 0) {
+            failures.push({
+                code: "envelope-omits-target",
+                detail: `no envelope named audit targets ${named.join(",")}`,
+            });
+        }
+        for (const envelope of deposit.envelopes) {
+            if (envelope.declaredNone) {
+                failures.push({
+                    code: "envelope-omits-target",
+                    detail: "envelope declared none while named audit targets exist",
+                });
+                continue;
+            }
+            for (const id of named) {
+                if (!envelope.auditTargets.includes(id)) {
+                    failures.push({
+                        code: "envelope-omits-target",
+                        detail: `envelope omitted audit target ${id}`,
+                    });
+                }
+            }
+        }
+    }
+    const bind = deposit.bindAttempt;
+    if (bind) {
+        const declared = new Set(bind.unresolvedMarkerIds);
+        for (const id of computedUnresolved) {
+            if (!declared.has(id)) {
+                failures.push({
+                    code: "silent-clear",
+                    detail: `marker ${id} dropped from unresolved without critic clearance`,
+                });
+            }
+        }
+        const unresolvedForBind = [...new Set([...computedUnresolved, ...bind.unresolvedMarkerIds])];
+        if (bind.allAcceptMap && unresolvedForBind.length > 0) {
+            failures.push({
+                code: "bind-unresolved",
+                detail: `all-accept bind with unresolved markers ${unresolvedForBind.join(",")}`,
+            });
+        }
+    }
+    return { ok: failures.length === 0, failures };
+}
+//# sourceMappingURL=parent-audit.js.map

package/dist/doctor/checks.d.ts

@@ -106,6 +106,12 @@ export declare function checkCompletedLifecycleConsistency(projectRoot: string):
  * historical pre-#2862 corpora do not red-light doctor; scope:complete fails closed.
  */
 export declare function checkCompletedOpenItems(projectRoot: string): CheckResult;
+/**
+ * Surface completed/ artifacts that never passed runTransition (#3679).
+ * Exit-exempt so historical corpora do not red-light doctor; the change-set
+ * verify (`verify:completed-write-guard`) fails closed on new adds.
+ */
+export declare function checkCompletedUnguardedWrite(projectRoot: string): CheckResult;
 /**
  * Surface invalid coverageDebt + checkResume typed blocks (#3314).
  * Absent / default / valid typed values pass. Invalid blocks skip (advisory,

package/dist/doctor/checks.js

@@ -6,6 +6,7 @@ import { detectDualLayout, detectLegacyLayout, dualLayoutSignpostLine, legacyLay
 import { detectCanonicalVendoredManifest, isNpmManaged, NPM_MANAGED_SENTINEL_KEY, NPM_MANAGED_SENTINEL_VALUE, } from "../init-deposit/migrate.js";
 import { resolveLifecycleRoot } from "../layout/resolve.js";
 import { scanCompletedLifecycleConsistency } from "../lifecycle/completed-consistency.js";
+import { scanCompletedWriteCorpus } from "../lifecycle/completed-write-guard.js";
 import { resolveCheckResume } from "../policy/check-resume.js";
 import { resolveCoverageDebt } from "../policy/coverage-debt.js";
 import { classifyXbriefSchemaDistance } from "../staleness-tickler/probe-xbrief.js";
@@ -34,6 +35,7 @@ export const DOCTOR_ADVISORY_FAIL_CHECKS = new Set([
     "stale-xbrief-schema-deposit",
     "typescript-7-side-by-side",
     "completed-open-items",
+    "completed-unguarded-write",
     "coverage-check-resume-policy",
 ]);
 /** True when a check fail must stay a warning (not lastErrorCount / exit 1). */
@@ -1167,6 +1169,37 @@ export function checkCompletedOpenItems(projectRoot) {
         },
     };
 }
+/**
+ * Surface completed/ artifacts that never passed runTransition (#3679).
+ * Exit-exempt so historical corpora do not red-light doctor; the change-set
+ * verify (`verify:completed-write-guard`) fails closed on new adds.
+ */
+export function checkCompletedUnguardedWrite(projectRoot) {
+    const checkName = "completed-unguarded-write";
+    const result = scanCompletedWriteCorpus(projectRoot);
+    if (result.findings.length === 0) {
+        return {
+            name: checkName,
+            status: "pass",
+            detail: "Completed write-guard OK (#3679): no completed/ artifacts lack a runTransition write",
+            data: { finding_count: 0, scanned: result.scanned },
+        };
+    }
+    const message = `Completed unguarded writes (#3679, advisory). ` +
+        `${result.findings.length} artifact(s) under completed/ have no runTransition write:\n` +
+        result.findings.map((f) => `  - ${f.detail}`).join("\n") +
+        `\nNew adds fail closed via verify:completed-write-guard; historical corpus is advisory.`;
+    return {
+        name: checkName,
+        status: "fail",
+        detail: message,
+        data: {
+            finding_count: result.findings.length,
+            advisory: true,
+            findings: result.findings.map((f) => ({ rel_path: f.relPath, detail: f.detail })),
+        },
+    };
+}
 /**
  * Surface invalid coverageDebt + checkResume typed blocks (#3314).
  * Absent / default / valid typed values pass. Invalid blocks skip (advisory,
@@ -1248,6 +1281,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
         checks.push(checkCoverageCheckResumePolicy(projectRoot));
         checks.push(checkCompletedLifecycleConsistency(projectRoot));
         checks.push(checkCompletedOpenItems(projectRoot));
+        checks.push(checkCompletedUnguardedWrite(projectRoot));
         return {
             projectRoot,
             installRoot: null,
@@ -1270,6 +1304,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
     checks.push(checkCoverageCheckResumePolicy(projectRoot));
     checks.push(checkCompletedLifecycleConsistency(projectRoot));
     checks.push(checkCompletedOpenItems(projectRoot));
+    checks.push(checkCompletedUnguardedWrite(projectRoot));
     return {
         projectRoot,
         installRoot,

package/dist/freshness/bind.d.ts

@@ -3,7 +3,7 @@
  *
  * Host-agnostic storage:
  * - Default (no sessionId): `.deft/session-bind.json` — single-operator convenience.
- * - With sessionId: `.deft/session-binds/<safeId>.json` — isolated multi-session binds.
+ * - With sessionId: `.deft/session-binds/<sha256-slice>.json` — isolated multi-session binds.
  *
  * Multi-agent hosts MUST pass a stable host session identity when binding and
  * reporting so one session cannot certify another as current.
@@ -16,10 +16,39 @@ export declare const SESSION_BINDS_DIR_REL: string;
 export declare function sessionBindPath(projectRoot: string, sessionId?: string | null): string;
 /**
  * Stable filesystem-safe file name for a host session id.
- * Keeps a short prefix for debug, hashes the rest to avoid path injection.
- * Character filter is O(n) (no regex) — CodeQL poly-redos on uncontrolled ids.
+ *
+ * Hash only (#3768): a 24-hex SHA-256 slice of the id. Hex cannot carry a path
+ * separator, so path injection is structurally impossible, and the name stays
+ * derivable from the id — lookup is one computed path, never a directory scan.
+ *
+ * Records written before #3768 also carried the first 32 characters of the id
+ * (`legacySessionFileName`). Dropping that prefix is hygiene, not a security
+ * fix: the same id is already published in `.deft/occupancy.json`,
+ * `.deft/ritual-state.json` and the bind record body (#3611 / #3754).
+ *
+ * Coupling warning: if `.deft/` JSON bodies are ever tightened (say to `0600`)
+ * while names still carry the prefix, the prefix becomes independently
+ * load-bearing — directory read permission alone would recover an id that the
+ * file mode was meant to protect. Anyone tightening those modes must keep bind
+ * names prefix-free.
  */
 export declare function safeSessionFileName(sessionId: string): string;
+/**
+ * Pre-#3768 record name: sanitized 32-character id prefix plus the same hash.
+ *
+ * Existing records are **tolerated, not migrated**. `readBoundGeneration` falls
+ * back to this name when the hash-only record is absent, so freshness pins
+ * written before the rename are not orphaned; writes always use the hash-only
+ * name, so the next bind supersedes the legacy record. Both names derive from
+ * the id, so the fallback stays O(1) and adds no directory scan.
+ *
+ * Character filter is O(n) (no regex) — CodeQL poly-redos on uncontrolled ids.
+ */
+export declare function legacySessionFileName(sessionId: string): string;
+/**
+ * Derived path of a pre-#3768 record. Read fallback only — never a write target.
+ */
+export declare function legacySessionBindPath(projectRoot: string, sessionId: string): string;
 export interface BindSessionOptions {
     readonly sessionId?: string | null;
     readonly nowIso?: string;