@deftai/directive-core 0.101.0 → 0.102.0

package/dist/session/session-start.js

@@ -7,6 +7,8 @@ import { MIGRATE_COMPLETION_NUDGE, shouldEmitMigrateNudge } from "../init-deposi
 import { hostContentSurfaceToDict, maybeFormatHostContentSurfaceLines, } from "../platform/host-content-surface.js";
 import { detectEnvironmentContext, environmentContextToDict, formatEnvironmentContext, } from "../platform/shell-context.js";
 import { ceremonyDialToDict, formatCeremonyDialStatusLine, mergeCeremonyDialDeferrals, resolveCeremonyDial, resolveSessionCeremonyDialInputs, } from "../policy/ceremony-dial.js";
+import { emitCeremonyDialEscalationEvaluation, evaluateSessionStartCeremonyDialEscalation, formatCeremonyDialPinBypassLine, isCeremonyStartTierPinned, resolveCeremonyStartTierProvenance, } from "../policy/ceremony-dial-escalation.js";
+import { maybeFormatCoverageCheckResumeDisclosure } from "../policy/coverage-debt.js";
 import { DEFT_DIRECTIVE_DISABLE_FLAG_NAME, DEFT_DIRECTIVE_DISABLE_STATUS, detectDeftDirectiveDisable, formatDeftDirectiveDisableMessage, isDeftDirectiveDisableActive, } from "../policy/deft-directive-disable.js";
 import { disclosureLine } from "../policy/disclosure.js";
 import { detectNoDeftDirective, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY, } from "../policy/no-deft-directive.js";
@@ -21,7 +23,6 @@ import { runDefaultMode } from "../triage/welcome/default-mode.js";
 import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
 import { emitSessionValueReadback } from "../value/readback.js";
 import { verifyRequiredTools } from "../verify-env/verify-tools.js";
-import { maybeFormatCoverageCheckResumeNudge } from "./coverage-check-resume-nudge.js";
 import { effortBudgetToDict, maybeFormatEffortBudgetLines, resolveProductionHostEffortDescriptor, } from "./effort-budget.js";
 import { defaultGitRunner, gitHead, gitIsAncestor, worktreePath } from "./git.js";
 import { runOrientationCompression, } from "./orientation-compression.js";
@@ -48,6 +49,18 @@ export const QUICK_STEPS = [
     "verify_tools",
 ];
 export const GATED_STEPS = ["agent_hooks", "doctor", "cache_fresh"];
+/** Standing one-liner when coverageDebt/checkResume is non-default (#3314). */
+function pushCoverageCheckResumeDisclosure(lines, projectRoot) {
+    try {
+        const line = maybeFormatCoverageCheckResumeDisclosure(projectRoot);
+        if (line !== null) {
+            lines.push(line);
+        }
+    }
+    catch {
+        // best-effort — ritual must not abort
+    }
+}
 /** Env opt-in for optional session:start network (release probe + triage cache hydrate) (#2991). */
 export const ENV_SESSION_START_NETWORK = "DEFT_SESSION_START_NETWORK";
 /** Human-readable skip notice when optional network is off the hot path (#2991). */
@@ -527,16 +540,7 @@ function runSessionRearm(projectRoot, options, instant, environment) {
     if (humanMergeLine !== null) {
         lines.push(humanMergeLine);
     }
-    // #3189: re-arm still surfaces undecided coverage/check-resume once per ritual.
-    try {
-        const coverageNudge = maybeFormatCoverageCheckResumeNudge({ projectRoot });
-        if (coverageNudge.length > 0) {
-            lines.push(coverageNudge.trimEnd());
-        }
-    }
-    catch {
-        // best-effort — re-arm must not abort
-    }
+    pushCoverageCheckResumeDisclosure(lines, projectRoot);
     const priorQuick = eligibility.state.quickSteps;
     const priorTriage = priorQuick.triage_welcome ?? ritualStep({ ok: true, ts: instant });
     // Greptile P1: legacy ritual-state without verify_tools must re-run tools —
@@ -802,6 +806,11 @@ export function runSessionStart(projectRoot, options = {}) {
         env: options.env,
     });
     const ceremonyDialSelection = options.ceremonyDial ?? resolveCeremonyDial(projectRoot, { inputs: resolvedDialInputs });
+    const startTierProvenance = resolveCeremonyStartTierProvenance({
+        selection: ceremonyDialSelection,
+        injectedSelection: options.ceremonyDial !== undefined,
+        hint: options.ceremonyDialStartTierProvenance,
+    });
     const effectiveDeferrals = mergeCeremonyDialDeferrals(deferrals, ceremonyDialSelection);
     const skipFatPath = ceremonyDialSelection.profile.skipFatPath;
     const { head: gitHeadValue, error: gitError } = gitHead(projectRoot, runGit);
@@ -831,7 +840,13 @@ export function runSessionStart(projectRoot, options = {}) {
     const quickSteps = recordDeferredSteps(QUICK_STEPS, effectiveDeferrals, instant);
     const gatedSteps = recordDeferredSteps(GATED_STEPS, effectiveDeferrals, instant);
     const lines = [];
-    lines.push(formatCeremonyDialStatusLine(ceremonyDialSelection));
+    lines.push(formatCeremonyDialStatusLine(ceremonyDialSelection, {
+        startTierProvenance,
+    }));
+    const pinBypassLine = formatCeremonyDialPinBypassLine(startTierProvenance);
+    if (pinBypassLine !== null) {
+        lines.push(pinBypassLine);
+    }
     if (provisionalDial.reasons.length > 0 && options.ceremonyDial === undefined) {
         lines.push(`[deft ceremony-dial] provisional: ${provisionalDial.reasons.join("; ")}`);
     }
@@ -919,6 +934,8 @@ export function runSessionStart(projectRoot, options = {}) {
     else {
         stepTimings.push({ name: "branch_policy", duration_ms: 0, skipped: true });
     }
+    // Standing disclosure is independent of branch_policy deferral (#3314 / Greptile).
+    pushCoverageCheckResumeDisclosure(lines, projectRoot);
     // #3214 / #3156: verify_tools is mutation readiness — always run, even under
     // rapid/minimal. Dial skipFatPath only lightens *ceremony* (triage welcome,
     // optional network, staleness tickler), never readiness gates.
@@ -1182,20 +1199,12 @@ export function runSessionStart(projectRoot, options = {}) {
     if (consentPrompt.length > 0) {
         lines.push(consentPrompt.trimEnd());
     }
-    // #3189: skippable coverageDebt/checkResume project-decision nudge (fail-open; never blocks).
-    try {
-        const coverageNudge = maybeFormatCoverageCheckResumeNudge({ projectRoot });
-        if (coverageNudge.length > 0) {
-            lines.push(coverageNudge.trimEnd());
-        }
-    }
-    catch {
-        // best-effort operator advisory — session start must not abort
-    }
     const writeStarted = performance.now();
     const coldSessionId = (options.newSessionId ?? randomUUID)();
     const dialDict = {
         ...ceremonyDialToDict(ceremonyDialSelection),
+        start_tier: ceremonyDialSelection.depth,
+        start_tier_provenance: startTierProvenance,
         provisional: {
             taskSize: provisionalDial.taskSize,
             modelTier: provisionalDial.modelTier,
@@ -1274,6 +1283,19 @@ export function runSessionStart(projectRoot, options = {}) {
                     }
                     : {}),
             });
+            emitter.emitKnownToolTurnDenominator();
+            // #3319: evaluate escalate-on-evidence only when #3274 is live. A pin
+            // emits nothing so never-evaluated stays distinguishable from declined.
+            if (!isCeremonyStartTierPinned(startTierProvenance)) {
+                emitCeremonyDialEscalationEvaluation({
+                    projectRoot,
+                    sessionId: coldSessionId,
+                    env: options.env,
+                    evaluation: evaluateSessionStartCeremonyDialEscalation({
+                        selection: ceremonyDialSelection,
+                    }),
+                });
+            }
         }
         catch {
             // fail-open

package/dist/session/toolchain-preflight.d.ts

@@ -8,9 +8,12 @@
  * Never bootstraps tooling the PRODUCT does not need. Failures name cause and
  * remedy without embedding env values.
  */
+import { type CheckGateSpec } from "../check/gate-lists.js";
 export declare const TOOLCHAIN_PREFLIGHT_TOOLS: readonly ["task", "pnpm", "node", "git"];
 export type ToolchainPreflightTool = (typeof TOOLCHAIN_PREFLIGHT_TOOLS)[number];
 export type ToolchainPreflightStatus = "ok" | "missing" | "degraded";
+/** How a missing tool affects check dispatch (#3335). */
+export type ToolchainPreflightImpact = "none" | "degraded";
 export interface ToolchainPreflightFinding {
     readonly tool: ToolchainPreflightTool | "cli_dist";
     readonly present: boolean;
@@ -18,6 +21,11 @@ export interface ToolchainPreflightFinding {
     readonly cause: string | null;
     /** Operator/agent remedy command or instruction. */
     readonly remedy: string | null;
+    /**
+     * Missing-tool impact. `none` = present false but no install remedy and
+     * check does not skip CLI-native gates (#3335).
+     */
+    readonly impact?: ToolchainPreflightImpact | null;
 }
 export interface ToolchainPreflightResult {
     readonly status: ToolchainPreflightStatus;
@@ -46,6 +54,13 @@ export interface ToolchainPreflightOptions {
      * a global `deft`/`directive` is on PATH.
      */
     readonly probeCliDist?: boolean;
+    /** Active check composition. Defaults from consumer vs framework context. */
+    readonly composedGates?: readonly CheckGateSpec[];
+    /**
+     * Consumer deposit (not framework source). When omitted, inferred from
+     * frameworkRoot vs projectRoot (#3335 / #3324).
+     */
+    readonly consumerDeposit?: boolean;
 }
 /**
  * Gates that specifically need a package manager / built dist.

package/dist/session/toolchain-preflight.js

@@ -10,6 +10,9 @@
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { allGatesCliDispatchable, GLOBAL_CLI_REMEDY, isCliNativeGate, } from "../check/cli-native-gates.js";
+import { isFrameworkRepoRoot, isFrameworkSourceContext } from "../check/context.js";
+import { CONSUMER_CHECK_GATES, checkGateId, FRAMEWORK_CHECK_GATES, } from "../check/gate-lists.js";
 import { defaultWhich } from "../doctor/which.js";
 export const TOOLCHAIN_PREFLIGHT_TOOLS = ["task", "pnpm", "node", "git"];
 const REMEDY = {
@@ -73,16 +76,35 @@ function formatFindingLine(finding) {
     if (finding.present) {
         return `[deft preflight] ${finding.tool}: ok`;
     }
+    if (finding.impact === "none") {
+        const cause = finding.cause ?? "absent";
+        return `[deft preflight] ${finding.tool}: absent (impact: none) — ${cause}`;
+    }
     const cause = finding.cause ?? "missing";
     const remedy = finding.remedy ?? "install the tool";
     return `[deft preflight] ${finding.tool}: MISSING — cause: ${cause}; remedy: ${remedy}`;
 }
+function inferConsumerDeposit(options) {
+    if (options.consumerDeposit !== undefined)
+        return options.consumerDeposit;
+    const project = options.projectRoot;
+    if (project === undefined)
+        return false;
+    // Same-path roots are framework-source only when the tree is the source repo.
+    if (isFrameworkRepoRoot(project))
+        return false;
+    const framework = options.frameworkRoot ?? project;
+    return !isFrameworkSourceContext(framework, project);
+}
 /**
  * Run done-gate toolchain preflight. Pure probe — never installs or builds.
  */
 export function runToolchainPreflight(options = {}) {
     const which = options.which ?? defaultWhich;
     const exists = options.exists ?? existsSync;
+    const consumerDeposit = inferConsumerDeposit(options);
+    const composed = options.composedGates ?? (consumerDeposit ? CONSUMER_CHECK_GATES : FRAMEWORK_CHECK_GATES);
+    const allCli = allGatesCliDispatchable(composed);
     const findings = [];
     for (const tool of TOOLCHAIN_PREFLIGHT_TOOLS) {
         findings.push(probeTool(tool, which));
@@ -90,13 +112,48 @@ export function runToolchainPreflight(options = {}) {
     if (options.probeCliDist !== false) {
         findings.push(probeCliDist(options.frameworkRoot ?? options.projectRoot, which, exists));
     }
-    const missingCritical = findings.filter((f) => !f.present && (f.tool === "task" || f.tool === "pnpm" || f.tool === "node"));
+    const cliPresent = findings.some((f) => f.tool === "cli_dist" && f.present);
     const taskMissing = findings.some((f) => f.tool === "task" && !f.present);
     const pnpmMissing = findings.some((f) => f.tool === "pnpm" && !f.present);
     const nodeMissing = findings.some((f) => f.tool === "node" && !f.present);
+    // #3335: in a deposit whose composed gates are all CLI-dispatchable, a
+    // missing task binary is impact none — no install-go-task remedy.
+    if (taskMissing && allCli) {
+        const idx = findings.findIndex((f) => f.tool === "task");
+        const prior = findings[idx];
+        if (idx >= 0 && prior !== undefined) {
+            findings[idx] = {
+                ...prior,
+                impact: "none",
+                remedy: cliPresent || nodeMissing ? null : GLOBAL_CLI_REMEDY,
+                cause: cliPresent
+                    ? "go-task absent; CLI-native gates dispatch via global deft/directive (#3335)"
+                    : "go-task absent and no global deft/directive CLI",
+            };
+        }
+    }
+    const missingCritical = findings.filter((f) => {
+        if (f.present || f.impact === "none")
+            return false;
+        return f.tool === "task" || f.tool === "pnpm" || f.tool === "node";
+    });
     const skip = new Set();
-    if (taskMissing || nodeMissing) {
-        // Dynamic: orchestrator expands SKIP_ALL_GATES to the live gate list.
+    if (nodeMissing) {
+        skip.add(SKIP_ALL_GATES);
+    }
+    else if (taskMissing && !allCli) {
+        if (!cliPresent) {
+            skip.add(SKIP_ALL_GATES);
+        }
+        else {
+            for (const spec of composed) {
+                const id = checkGateId(spec);
+                if (!isCliNativeGate(id))
+                    skip.add(id);
+            }
+        }
+    }
+    else if (taskMissing && allCli && !cliPresent) {
         skip.add(SKIP_ALL_GATES);
     }
     else if (pnpmMissing) {
@@ -104,7 +161,7 @@ export function runToolchainPreflight(options = {}) {
             skip.add(id);
         }
     }
-    const degraded = missingCritical.length > 0;
+    const degraded = missingCritical.length > 0 || (taskMissing && allCli && !cliPresent);
     const ok = !degraded;
     const status = ok ? "ok" : "degraded";
     const lines = [];
@@ -115,7 +172,9 @@ export function runToolchainPreflight(options = {}) {
         }
     }
     if (ok) {
-        lines.push("[deft preflight] done-gate toolchain ready (task, pnpm, node)");
+        lines.push(taskMissing && allCli
+            ? "[deft preflight] done-gate toolchain ready (CLI dispatch; go-task not required) (#3335)"
+            : "[deft preflight] done-gate toolchain ready (task, pnpm, node)");
     }
     else {
         lines.push("[deft preflight] degraded mode: directive check will skip toolchain-dependent gates " +
@@ -144,6 +203,7 @@ export function toolchainPreflightToDict(result) {
             present: f.present,
             cause: f.cause,
             remedy: f.remedy,
+            ...(f.impact !== undefined ? { impact: f.impact } : {}),
         })),
         skip_gate_ids: [...result.skipGateIds],
     };

package/dist/verify-ac/clauses.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Rung-2 derived AC: decompose the task statement into testable clauses
+ * at intake; walk every clause against the shipped artifact at done (#3323).
+ */
+export type ClauseOutcome = "verified" | "unverifiable" | "failed";
+export interface AcceptanceClauseReading {
+    readonly text: string;
+    readonly artifact_path: string | null;
+}
+export interface AcceptanceClause {
+    readonly id: number;
+    readonly text: string;
+    readonly artifact_path: string | null;
+    readonly ambiguous: boolean;
+    readonly readings?: readonly AcceptanceClauseReading[];
+    readonly chosen_reading?: number;
+}
+export interface ClauseWalkResult {
+    readonly id: number;
+    readonly text: string;
+    readonly artifact_path: string | null;
+    readonly outcome: ClauseOutcome;
+    readonly detail: string;
+}
+export interface ClauseWalkReport {
+    readonly clauses: readonly ClauseWalkResult[];
+    readonly failed: readonly ClauseWalkResult[];
+    readonly unverifiable: readonly ClauseWalkResult[];
+    readonly verified: readonly ClauseWalkResult[];
+    readonly ok: boolean;
+    readonly message: string;
+}
+/** Numbered independently testable clauses from the task statement (#3323). */
+export declare function deriveAcceptanceClauses(taskStatement: string): AcceptanceClause[];
+export declare function readAcceptanceClauses(acceptance: unknown): AcceptanceClause[];
+export declare function serializeAcceptanceClauses(clauses: readonly AcceptanceClause[]): Record<string, unknown>[];
+/**
+ * When no commands are stated, stamp derived clauses onto plan.acceptance
+ * and promote source_rung to derived. Leaves stated-command acceptance alone.
+ */
+export declare function stampDerivedClausesOnAcceptance(plan: Record<string, unknown>, taskStatement: string): {
+    readonly plan: Record<string, unknown>;
+    readonly clauses: readonly AcceptanceClause[];
+};
+export declare function isScratchArtifactPath(artifactPath: string): boolean;
+export declare function walkAcceptanceClauses(clauses: readonly AcceptanceClause[], projectRoot: string): ClauseWalkReport;
+/** Done reports lead with failed/unverifiable; unverifiable is never dropped. */
+export declare function formatClauseWalkMessage(report: Omit<ClauseWalkReport, "message"> & {
+    readonly message?: string;
+}, prior?: string): string;
+//# sourceMappingURL=clauses.d.ts.map