@deftai/directive-core 0.103.0 → 0.105.0

package/dist/intake/issue-ingest.js

@@ -5,8 +5,8 @@ import { scan } from "../cache/scanner.js";
 import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { captureAndAttachLiteralAcceptance } from "../literal-acceptance/index.js";
+import { stampIntendedPlacement } from "../preflight/intended-placement.js";
 import { stampAcceptanceFromLiteralCapture } from "../product-first-done-gate/index.js";
-import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter } from "../run-summary/index.js";
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
@@ -15,6 +15,7 @@ import { slugify, TODAY } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
 import { stampDerivedClausesOnAcceptance } from "../verify-ac/clauses.js";
 import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, VBRIEF_VERSION, } from "../xbrief-migrate/constants.js";
+import { applyClauseQualityForIngest, emitAcceptanceStampFromPlan } from "./clause-derivation.js";
 import { findAcHeading, parseCheckboxItems, parseListItems, sliceAcSection, stripCodeBlocks, stripFencedCodeBlocks, } from "./markdown-scanners.js";
 import { detectRepo, extractReferencesFromVbrief, fetchOpenIssues, GITHUB_ISSUE_REF_TYPES, LIFECYCLE_FOLDERS, parseIssueNumber, } from "./reconcile-issues.js";
 /** Reference type pointing at the canonical current-shape comment permalink (#1870). */
@@ -480,11 +481,13 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
         // #3323: when no commands were stated, derive numbered clauses before product edit.
         const derived = stampDerivedClausesOnAcceptance(plan, [title, overviewSource].filter((s) => s.length > 0).join("\n\n"));
         Object.assign(plan, derived.plan);
+        applyClauseQualityForIngest(plan);
     }
     else {
         // No body: still record none_stated acceptance so absence is a decision.
         Object.assign(plan, stampAcceptanceFromLiteralCapture(plan));
     }
+    stampIntendedPlacement(plan);
     const infoRootKey = options.infoRootKey ?? LEGACY_INFO_ROOT_KEY;
     const infoVersion = options.infoVersion ?? EMITTED_VBRIEF_VERSION;
     const briefLabel = infoRootKey === MIGRATED_INFO_ROOT_KEY ? "xBRIEF" : "vBRIEF";
@@ -499,6 +502,24 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
         folder,
     ];
 }
+/** Include a refused-stamp remediation on the ingest result so it is not silent. */
+export function formatIngestCreatedMessage(folder, filename, plan, dryRun = false) {
+    const lead = dryRun
+        ? `DRY-RUN would write ${folder}/${filename}`
+        : `CREATED ${folder}/${filename}`;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return lead;
+    }
+    const acceptance = plan.acceptance;
+    if (typeof acceptance !== "object" || acceptance === null || Array.isArray(acceptance)) {
+        return lead;
+    }
+    const notice = acceptance.quality_notice;
+    if (typeof notice !== "string" || notice.trim().length === 0) {
+        return lead;
+    }
+    return `${lead}\n${notice.trim()}`;
+}
 export function targetFilename(number, title, artifactSuffix = LEGACY_ARTIFACT_SUFFIX) {
     const slug = slugify(title) || `issue-${number}`;
     return `${TODAY}-${number}-${slug}${artifactSuffix}`;
@@ -707,7 +728,7 @@ export function ingestOne(issue, options) {
     const folderPath = join(options.vbriefDir, folder);
     const target = join(folderPath, filename);
     if (options.dryRun) {
-        return ["dryrun", target, `DRY-RUN would write ${folder}/${filename}`];
+        return ["dryrun", target, formatIngestCreatedMessage(folder, filename, vbrief.plan, true)];
     }
     // Gate lifecycle folder + leaf before mkdir/write so folder/parent symlinks
     // cannot divert issue:ingest / triage:accept outside the project (#2869).
@@ -723,44 +744,8 @@ export function ingestOne(issue, options) {
     assertWriteTargetSafe(projectRoot, target);
     mkdirSync(folderPath, { recursive: true });
     writeFileSync(target, `${JSON.stringify(vbrief, null, 2)}\n`, "utf8");
-    emitIntakeAcceptanceStamp(projectRoot, vbrief.plan);
-    return ["created", target, `CREATED ${folder}/${filename}`];
-}
-function emitIntakeAcceptanceStamp(projectRoot, plan) {
-    const rec = plan !== null && typeof plan === "object" && !Array.isArray(plan)
-        ? plan
-        : null;
-    if (rec === null) {
-        return;
-    }
-    const acceptance = rec.acceptance !== null && typeof rec.acceptance === "object" && !Array.isArray(rec.acceptance)
-        ? rec.acceptance
-        : null;
-    if (acceptance === null) {
-        return;
-    }
-    const env = process.env;
-    const dest = env[ENV_RUN_SUMMARY_PATH];
-    if (dest === undefined || dest.trim().length === 0) {
-        return;
-    }
-    try {
-        const sessionId = typeof env.DEFT_SESSION_ID === "string" && env.DEFT_SESSION_ID.trim().length > 0
-            ? env.DEFT_SESSION_ID.trim()
-            : "issue-ingest";
-        const emitter = new RunSummaryEmitter({ projectRoot, sessionId, env });
-        const commands = Array.isArray(acceptance.commands) ? acceptance.commands.length : 0;
-        const clauses = Array.isArray(acceptance.clauses) ? acceptance.clauses.length : 0;
-        emitter.emitAcceptanceStamp({
-            rung: typeof acceptance.source_rung === "string" ? acceptance.source_rung : "project_floor",
-            none_stated: acceptance.none_stated === true,
-            command_count: commands,
-            clause_count: clauses,
-        });
-    }
-    catch {
-        // fail-open
-    }
+    emitAcceptanceStampFromPlan(projectRoot, vbrief.plan);
+    return ["created", target, formatIngestCreatedMessage(folder, filename, vbrief.plan)];
 }
 export function ingestBulk(issues, options) {
     let filtered = issues;
@@ -789,6 +774,7 @@ export function ingestBulk(issues, options) {
         duplicate: [],
         dryrun: [],
         failed: [],
+        notices: [],
     };
     for (const issue of filtered) {
         let ingested;
@@ -806,9 +792,12 @@ export function ingestBulk(issues, options) {
             }
             throw exc;
         }
-        const [result, path, _msg] = ingested;
+        const [result, path, msg] = ingested;
         const rel = path !== null ? path.replace(`${options.vbriefDir}/`, "").replace(/\\/g, "/") : "";
         summary[result].push(rel);
+        if (msg.includes("\n")) {
+            summary.notices.push(msg);
+        }
         if (result === "created" && path !== null) {
             const num = Number(issue.number);
             const existing = refs.get(num) ?? [];
@@ -876,6 +865,9 @@ export function issueIngestMain(args) {
         for (const entry of created) {
             process.stdout.write(`  CREATED ${entry}\n`);
         }
+        for (const notice of summary.notices ?? []) {
+            process.stdout.write(`${notice}\n`);
+        }
         for (const entry of dryrun) {
             process.stdout.write(`  DRY-RUN ${entry}\n`);
         }
@@ -926,12 +918,13 @@ export function ingestSingleForAccept(n, repo, options = {}) {
     if (issue === null) {
         throw new Error(`failed to fetch GitHub issue #${n} from ${repo} (unified cache miss + live gh api fetch failed; see stderr)`);
     }
-    const [result, path] = ingestOne(issue, {
+    // Forward ingestOne's notice-bearing third return so triage:accept can
+    // print a refused-stamp remediation instead of only the decision id (#3398).
+    return ingestOne(issue, {
         vbriefDir,
         status: options.status ?? "proposed",
         repoUrl,
         cwd: root,
     });
-    return [result, path];
 }
 //# sourceMappingURL=issue-ingest.js.map

package/dist/lifecycle/completed-tracked-on-delivery.d.ts

@@ -25,6 +25,11 @@ export interface EvaluateCompletedTrackedOptions {
     readonly repo?: string | null;
     /** Explicit delivery tip ref (e.g. origin/master). Overrides policy/git default. */
     readonly tip?: string | null;
+    /**
+     * When set, check only this issue number (#3476 drive-to DONE).
+     * Sibling unlanded closed issues do not fail the per-issue scan.
+     */
+    readonly issue?: number | null;
     readonly runGh?: RunGhFn;
     readonly skipGh?: boolean;
     readonly runGit?: GitRunner;

package/dist/lifecycle/completed-tracked-on-delivery.js

@@ -198,13 +198,16 @@ export function resolveDeliveryTip(projectRoot, tipOverride, runGit) {
             return { tip: candidate, error: null };
         }
     }
-    // Last resort: HEAD of current checkout (still a real tip for fixtures).
-    if (refExists(projectRoot, "HEAD", runGit)) {
-        return { tip: "HEAD", error: null };
-    }
+    // ⊗ HEAD fallback (#3478 review). This gate exists to prove an artifact landed
+    // on the delivery tip rather than on feature-worktree HEAD; falling back to
+    // HEAD when the delivery ref is missing (shallow clone, unfetched worktree,
+    // fetch-depth:1 checkout) checks the very branch whose land is in question and
+    // silently passes. Unresolvable delivery tip must fail closed -- pass an
+    // explicit --tip (e.g. --tip HEAD for an in-flight land PR) to opt in.
     return {
         tip: null,
-        error: `could not resolve delivery tip for branch '${branch}' (no origin/${branch}, ${branch}, or HEAD)`,
+        error: `could not resolve delivery tip for branch '${branch}' (no origin/${branch} or ${branch}); ` +
+            "fetch the delivery branch or pass an explicit --tip",
     };
 }
 function listTreePaths(projectRoot, tip, prefixes, runGit) {
@@ -270,6 +273,28 @@ function issuesFromBlobPaths(projectRoot, tip, paths, defaultRepo, runGit, origi
     }
     return hits;
 }
+/**
+ * Narrow the origin map to the requested issue.
+ *
+ * Matching is repo-scoped when the caller's repo is known (#3478 review): a
+ * corpus entry for another repository's same-numbered issue must NOT survive
+ * this filter. Letting it through leaves `originMap` non-empty, which suppresses
+ * the synthesis below and makes the gate resolve the wrong `repo#number` --
+ * a foreign open issue then green-skips an unlanded local one.
+ */
+function filterOriginsByIssue(originMap, issue, repo) {
+    const out = new Map();
+    for (const [key, entry] of originMap) {
+        if (entry.issue.number !== issue) {
+            continue;
+        }
+        if (repo !== null && entry.issue.repo !== repo) {
+            continue;
+        }
+        out.set(key, entry);
+    }
+    return out;
+}
 function mergeOrigins(hits) {
     const map = new Map();
     for (const hit of hits) {
@@ -353,7 +378,47 @@ export function evaluateCompletedTracked(projectRoot, options = {}) {
     const localHits = scanLocalOrigins(root, defaultRepo);
     const tipNonterminalPaths = listTreePaths(root, tip, nonterminalPrefixes(), runGit);
     const tipNonterminalHits = issuesFromBlobPaths(root, tip, tipNonterminalPaths, defaultRepo, runGit, `tip:${tip}`);
-    const originMap = mergeOrigins([...localHits, ...tipNonterminalHits]);
+    let originMap = mergeOrigins([...localHits, ...tipNonterminalHits]);
+    // Delivery tip only — the land invariant is post-merge tip truth (#3264 AC).
+    // Lifecycle PRs that commit completed/ on a feature branch are not expected
+    // to satisfy this gate until merge; run the verb with --tip HEAD when
+    // validating an in-flight land PR. The gate is a standalone verify verb
+    // (not wired into check:consumer) so product PRs are not deadlocked.
+    const tipTerminalPaths = listTreePaths(root, tip, terminalPrefixes(), runGit);
+    const tipTerminalHits = issuesFromBlobPaths(root, tip, tipTerminalPaths, defaultRepo, runGit, `tip:${tip}`);
+    const landedKeys = new Set(tipTerminalHits.map((h) => issueKey(h.issue)));
+    const issueFilter = options.issue ?? null;
+    if (issueFilter !== null) {
+        if (!Number.isInteger(issueFilter) || issueFilter <= 0) {
+            return {
+                code: 2,
+                message: `verify:completed-tracked: --issue must be a positive integer (got ${issueFilter})`,
+                stream: "stderr",
+                missing: [],
+                tip,
+            };
+        }
+        originMap = filterOriginsByIssue(originMap, issueFilter, defaultRepo);
+        // Drive-to DONE must not green-skip a named origin with no local brief
+        // (#3476). Synthesize the requested issue so closed+unlanded fails.
+        if (originMap.size === 0) {
+            if (defaultRepo === null) {
+                return {
+                    code: 2,
+                    message: `verify:completed-tracked: --issue ${issueFilter} requires --repo or a resolvable ` +
+                        "origin remote when no scoped xBRIEF origin is present.",
+                    stream: "stderr",
+                    missing: [],
+                    tip,
+                };
+            }
+            const synthetic = {
+                issue: { repo: defaultRepo, number: issueFilter },
+                origins: [`--issue ${issueFilter}`],
+            };
+            originMap.set(issueKey(synthetic.issue), synthetic);
+        }
+    }
     if (originMap.size === 0) {
         if (quiet) {
             return { code: 0, message: "", stream: "none", missing: [], tip };
@@ -366,14 +431,6 @@ export function evaluateCompletedTracked(projectRoot, options = {}) {
             tip,
         };
     }
-    // Delivery tip only — the land invariant is post-merge tip truth (#3264 AC).
-    // Lifecycle PRs that commit completed/ on a feature branch are not expected
-    // to satisfy this gate until merge; run the verb with --tip HEAD when
-    // validating an in-flight land PR. The gate is a standalone verify verb
-    // (not wired into check:consumer) so product PRs are not deadlocked.
-    const tipTerminalPaths = listTreePaths(root, tip, terminalPrefixes(), runGit);
-    const tipTerminalHits = issuesFromBlobPaths(root, tip, tipTerminalPaths, defaultRepo, runGit, `tip:${tip}`);
-    const landedKeys = new Set(tipTerminalHits.map((h) => issueKey(h.issue)));
     const missing = [];
     for (const [key, entry] of originMap) {
         if (landedKeys.has(key)) {
@@ -383,10 +440,20 @@ export function evaluateCompletedTracked(projectRoot, options = {}) {
         if (state === "open") {
             continue;
         }
-        // Closed: always fail. Unknown with live expected (!skipGh): also fail —
-        // cannot prove the issue is still open, so do not green-skip land debt
-        // (#3264 Greptile residual on live lookup failure).
-        if (state === "closed" || (state === null && !skipGh)) {
+        // Closed: always fail.
+        //
+        // Unknown: fail when live lookup was expected (!skipGh) -- cannot prove the
+        // issue is still open, so do not green-skip land debt (#3264 Greptile
+        // residual on live lookup failure).
+        //
+        // Unknown also fails for an explicitly named --issue even under --skip-gh
+        // (#3478 review): that is the drive-to DONE form, where the caller asserts
+        // this specific issue is done. An uncached issue must not exit 0 there --
+        // otherwise --skip-gh silently turns the DONE gate into a no-op. The
+        // unscoped corpus scan keeps the offline allowance, since a cold cache
+        // legitimately knows nothing about most scoped issues.
+        const unknownIsTerminal = !skipGh || issueFilter !== null;
+        if (state === "closed" || (state === null && unknownIsTerminal)) {
             missing.push(entry);
         }
     }

package/dist/literal-acceptance/capture.d.ts

@@ -13,6 +13,8 @@ import type { LiteralAcceptanceCommand, RejectedLiteralCommand } from "./types.j
 export interface CaptureLiteralAcceptanceResult {
     readonly commands: readonly LiteralAcceptanceCommand[];
     readonly rejected: readonly RejectedLiteralCommand[];
+    /** Prompt lines skipped inside a transcript-shaped fence (#3511). */
+    readonly transcriptPromptSkipped: number;
 }
 /**
  * Capture literal acceptance commands from free-form task statement text.
@@ -47,6 +49,14 @@ export declare function captureAndAttachLiteralAcceptance(plan: Record<string, u
     readonly commands: readonly LiteralAcceptanceCommand[];
     readonly rejected: readonly RejectedLiteralCommand[];
 };
+/** True when a rejected ledger entry was scraped from narrative prose (#3484). */
+export declare function isProseDerivedRejection(rejected: RejectedLiteralCommand): boolean;
+/**
+ * True when the author stated acceptance commands structurally — `swarm.verify_commands`
+ * or `plan.acceptance.commands` (#3484). Still used by intake/tests; demotion of
+ * prose-derived rejections no longer depends on this (#3511).
+ */
+export declare function hasStructuredAcceptanceCommands(plan: Record<string, unknown> | null | undefined): boolean;
 /** Format rejected ledger for CLI / complete-gate messages. */
 export declare function formatRejectedLedger(rejected: readonly RejectedLiteralCommand[]): string;
 //# sourceMappingURL=capture.d.ts.map