@deftai/directive-core 0.107.0 → 0.108.0

package/dist/intake/issue-ingest.js

@@ -2,6 +2,7 @@ import { lstatSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSyn
 import { basename, dirname, join, resolve } from "node:path";
 import { cacheGet } from "../cache/operations.js";
 import { scan } from "../cache/scanner.js";
+import { assertCompletedArcAllowsIngest, DesignCritiqueIngestBlockedError, } from "../design-critique/completed-arc-record.js";
 import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { captureAndAttachLiteralAcceptance } from "../literal-acceptance/index.js";
@@ -703,6 +704,41 @@ function resolveIngestProjectRoot(vbriefDir, cwd) {
     }
     return null;
 }
+function issueLabelNames(issue) {
+    const labels = issue.labels;
+    if (!Array.isArray(labels))
+        return [];
+    const names = [];
+    for (const lbl of labels) {
+        if (typeof lbl === "string") {
+            names.push(lbl);
+            continue;
+        }
+        if (lbl !== null && typeof lbl === "object" && !Array.isArray(lbl)) {
+            const name = lbl.name;
+            if (typeof name === "string")
+                names.push(name);
+        }
+    }
+    return names;
+}
+function threadCommentsFromIssue(issue) {
+    const raw = issue[ISSUE_COMMENT_THREAD_KEY];
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const rec = entry;
+        const id = Number(rec.id);
+        if (!Number.isSafeInteger(id) || id <= 0)
+            continue;
+        const body = typeof rec.body === "string" ? rec.body : "";
+        out.push({ id, body });
+    }
+    return out;
+}
 export function ingestOne(issue, options) {
     const number = Number(issue.number);
     const refs = options.existingRefs ?? scanProvenanceRefs(options.vbriefDir);
@@ -719,6 +755,11 @@ export function ingestOne(issue, options) {
         cwd: options.cwd,
         cacheRoot: options.cacheRoot,
     });
+    assertCompletedArcAllowsIngest({
+        issueNumber: number,
+        labels: issueLabelNames(enriched),
+        comments: threadCommentsFromIssue(enriched),
+    });
     const emissionLayout = resolveIngestEmissionLayout(options.vbriefDir);
     const [vbrief, folder] = buildIssueVbrief(enriched, options.status, options.repoUrl, {
         infoRootKey: emissionLayout.infoRootKey,
@@ -774,6 +815,7 @@ export function ingestBulk(issues, options) {
         duplicate: [],
         dryrun: [],
         failed: [],
+        blocked: [],
         notices: [],
     };
     for (const issue of filtered) {
@@ -790,6 +832,11 @@ export function ingestBulk(issues, options) {
                 process.stderr.write(`${exc.message}\n`);
                 continue;
             }
+            if (exc instanceof DesignCritiqueIngestBlockedError) {
+                summary.blocked.push(`#${exc.issueNumber}`);
+                process.stderr.write(`${exc.message}\n`);
+                continue;
+            }
             throw exc;
         }
         const [result, path, msg] = ingested;
@@ -861,7 +908,8 @@ export function issueIngestMain(args) {
         const duplicate = summary.duplicate;
         const dryrun = summary.dryrun;
         const failed = summary.failed ?? [];
-        process.stdout.write(`issue:ingest bulk summary: ${created.length} created, ${duplicate.length} duplicate, ${dryrun.length} dry-run, ${failed.length} refused (total considered: ${summary.total})\n`);
+        const blocked = summary.blocked ?? [];
+        process.stdout.write(`issue:ingest bulk summary: ${created.length} created, ${duplicate.length} duplicate, ${dryrun.length} dry-run, ${failed.length} refused, ${blocked.length} blocked (total considered: ${summary.total})\n`);
         for (const entry of created) {
             process.stdout.write(`  CREATED ${entry}\n`);
         }
@@ -877,8 +925,16 @@ export function issueIngestMain(args) {
         for (const entry of failed) {
             process.stdout.write(`  REFUSED ${entry} (quarantine scanner hard-fail; nothing written)\n`);
         }
+        for (const entry of blocked) {
+            process.stdout.write(`  BLOCKED ${entry} (design-critique completed-arc record; nothing written)\n`);
+        }
         // #2306: fail closed on any quarantine hard-fail in the batch.
-        return failed.length > 0 ? 2 : 0;
+        // Design-critique protocol holds are exit 1, not the scanner fatal path.
+        if (failed.length > 0)
+            return 2;
+        if (blocked.length > 0)
+            return 1;
+        return 0;
     }
     const issue = fetchIssue(repo, args.number, { cwd: projectRoot });
     if (issue === null) {
@@ -901,6 +957,10 @@ export function issueIngestMain(args) {
             process.stderr.write(`${exc.message}\n`);
             return 2;
         }
+        if (exc instanceof DesignCritiqueIngestBlockedError) {
+            process.stderr.write(`${exc.message}\n`);
+            return 1;
+        }
         throw exc;
     }
     process.stdout.write(`${msg}\n`);

package/dist/intake/platform-capabilities.d.ts

@@ -1,11 +1,18 @@
 /** Minimal runtime capability probe for github_auth_modes (#1557a / #1784). */
+import { type ManagedRuntimeProbe } from "../platform/cursor-managed-runtime.js";
 export declare const RUNTIME_MODE_LOCAL_UNSANDBOXED = "local-unsandboxed";
 export declare const RUNTIME_MODE_CURSOR_NATIVE_SANDBOX = "cursor-native-sandbox";
 export declare const RUNTIME_MODE_CLOUD_HEADLESS = "cloud-headless";
 export declare const KNOWN_RUNTIME_MODES: Set<string>;
 export interface RuntimeCapabilityReport {
     readonly runtimeMode: string;
+    /** Stable id naming why `runtimeMode` was chosen; surfaced by scm:status (#3859). */
+    readonly runtimeModeReason?: string;
 }
-export declare function probeRuntimeCapabilities(environ?: NodeJS.ProcessEnv): RuntimeCapabilityReport;
-export declare function getPlatformCapabilities(): RuntimeCapabilityReport;
+export interface ProbeRuntimeCapabilityOptions {
+    /** Injectable managed-runtime probe (#3859). Defaults to the metadata read. */
+    readonly managedRuntimeProbe?: ManagedRuntimeProbe;
+}
+export declare function probeRuntimeCapabilities(environ?: NodeJS.ProcessEnv, options?: ProbeRuntimeCapabilityOptions): RuntimeCapabilityReport;
+export declare function getPlatformCapabilities(options?: ProbeRuntimeCapabilityOptions): RuntimeCapabilityReport;
 //# sourceMappingURL=platform-capabilities.d.ts.map

package/dist/intake/platform-capabilities.js

@@ -1,4 +1,5 @@
 /** Minimal runtime capability probe for github_auth_modes (#1557a / #1784). */
+import { hasExplicitHostGhSelection, probeManagedRuntime, RUNTIME_REASON_CI_MARKER, RUNTIME_REASON_CURSOR_MARKER_AMBIGUOUS, RUNTIME_REASON_CURSOR_SANDBOX_MARKER, RUNTIME_REASON_EXPLICIT_HOST_GH, RUNTIME_REASON_MANAGED_RUNTIME_PROBE, RUNTIME_REASON_NO_RUNTIME_MARKER, } from "../platform/cursor-managed-runtime.js";
 export const RUNTIME_MODE_LOCAL_UNSANDBOXED = "local-unsandboxed";
 export const RUNTIME_MODE_CURSOR_NATIVE_SANDBOX = "cursor-native-sandbox";
 export const RUNTIME_MODE_CLOUD_HEADLESS = "cloud-headless";
@@ -11,24 +12,52 @@ const TRUTHY = new Set(["1", "true", "yes", "on"]);
 function isTruthy(value) {
     return value !== undefined && TRUTHY.has(value.trim().toLowerCase());
 }
-function classifyRuntimeMode(environ = process.env) {
+/**
+ * Classify the execution runtime.
+ *
+ * Ordering is load-bearing (#3859):
+ *   1. CI markers, so a CI runner is never reclassified by a Cursor signal.
+ *   2. A positive Cursor managed-runtime read, above every other Cursor signal.
+ *   3. Cursor native sandbox.
+ *   4. A Cursor marker with no managed read leaves the runtime AMBIGUOUS. Only
+ *      an explicit operator/dispatcher selection resolves it to local; absent
+ *      that, the verdict is unchanged from before #3859.
+ */
+function classifyRuntimeMode(environ = process.env, options = {}) {
     for (const key of ["GROK_BUILD", "GITHUB_ACTIONS", "CI", "BUILDKITE", "DEFT_AGENT_RUNTIME"]) {
         if (isTruthy(environ[key])) {
-            return RUNTIME_MODE_CLOUD_HEADLESS;
+            return { mode: RUNTIME_MODE_CLOUD_HEADLESS, reason: RUNTIME_REASON_CI_MARKER };
         }
     }
+    const managedProbe = options.managedRuntimeProbe ?? probeManagedRuntime;
+    if (managedProbe(environ).verdict === "managed") {
+        return {
+            mode: RUNTIME_MODE_CLOUD_HEADLESS,
+            reason: RUNTIME_REASON_MANAGED_RUNTIME_PROBE,
+        };
+    }
     if (isTruthy(environ.CURSOR_SANDBOX) || isTruthy(environ.CURSOR_SANDBOX_LANDLOCK_STATUS)) {
-        return RUNTIME_MODE_CURSOR_NATIVE_SANDBOX;
+        return {
+            mode: RUNTIME_MODE_CURSOR_NATIVE_SANDBOX,
+            reason: RUNTIME_REASON_CURSOR_SANDBOX_MARKER,
+        };
     }
     if (isTruthy(environ.CURSOR_AGENT) || isTruthy(environ.CURSOR_COMPOSER)) {
-        return RUNTIME_MODE_CLOUD_HEADLESS;
+        if (hasExplicitHostGhSelection(environ)) {
+            return { mode: RUNTIME_MODE_LOCAL_UNSANDBOXED, reason: RUNTIME_REASON_EXPLICIT_HOST_GH };
+        }
+        return {
+            mode: RUNTIME_MODE_CLOUD_HEADLESS,
+            reason: RUNTIME_REASON_CURSOR_MARKER_AMBIGUOUS,
+        };
     }
-    return RUNTIME_MODE_LOCAL_UNSANDBOXED;
+    return { mode: RUNTIME_MODE_LOCAL_UNSANDBOXED, reason: RUNTIME_REASON_NO_RUNTIME_MARKER };
 }
-export function probeRuntimeCapabilities(environ = process.env) {
-    return { runtimeMode: classifyRuntimeMode(environ) };
+export function probeRuntimeCapabilities(environ = process.env, options = {}) {
+    const { mode, reason } = classifyRuntimeMode(environ, options);
+    return { runtimeMode: mode, runtimeModeReason: reason };
 }
-export function getPlatformCapabilities() {
-    return probeRuntimeCapabilities();
+export function getPlatformCapabilities(options = {}) {
+    return probeRuntimeCapabilities(process.env, options);
 }
 //# sourceMappingURL=platform-capabilities.js.map

package/dist/orphan-active/evaluate.d.ts

@@ -6,11 +6,28 @@ export interface OrphanActiveBrief {
     readonly reason: string;
     readonly kind: OrphanKind;
 }
+/**
+ * How the run's issue-state verdicts were reached (#3767). A pass with
+ * `unverified > 0` is not evidence that the tree is clean.
+ */
+export interface OrphanActiveBasis {
+    readonly inventory: number;
+    readonly live: number;
+    readonly cache: number;
+    readonly unverified: number;
+    /** Oldest cache entry that produced a verdict, in ms. */
+    readonly maxCacheAgeMs: number | null;
+    /** True when reads resolved through `ghx`, a cached GET proxy. */
+    readonly proxied: boolean;
+    readonly elapsedMs: number;
+    readonly budgetMs: number;
+}
 export interface EvaluateResult {
     readonly code: 0 | 1 | 2;
     readonly message: string;
     readonly stream: OutputStream;
     readonly orphans: readonly OrphanActiveBrief[];
+    readonly basis: OrphanActiveBasis;
 }
 export interface EvaluateOptions {
     readonly quiet?: boolean;
@@ -19,6 +36,8 @@ export interface EvaluateOptions {
     readonly skipGh?: boolean;
     /** When set, scan only active/running briefs that reference this issue (#3429). */
     readonly issue?: number | null;
+    /** Monotonic clock seam so basis ages and budget checks are testable. */
+    readonly nowMs?: () => number;
 }
 /**
  * Pure evaluator for orphaned active/running xBRIEF detection (#2321 / #3429).
@@ -26,6 +45,12 @@ export interface EvaluateOptions {
  * issues and/or a merged PR — the stop-at:pr-open orphan signature.
  * Pass `issue` to scan one origin after merge. Confirmed shipped prints
  * scope:complete; unresolved lookup still exits 1 with a retry remediation.
+ *
+ * Issue state resolves by query shape (#3767): scoped `--issue N` takes an
+ * authoritative read and stays fail-closed on unknown; the unscoped sweep uses
+ * one complete, fail-closed open-issue inventory and stays fail-open on
+ * unknown so offline work is not network-authorized. A cache hit is honoured
+ * only inside `ISSUE_CACHE_MAX_AGE_MS`, and every verdict reports its basis.
  */
 export declare function evaluate(projectRoot: string, options?: EvaluateOptions): EvaluateResult;
 //# sourceMappingURL=evaluate.d.ts.map