@deftai/directive-core 0.103.0 → 0.105.0

package/dist/swarm/launch.d.ts

@@ -37,6 +37,27 @@ export declare function enforceGates(resolved: readonly ResolvedStory[], project
     story: ResolvedStory;
     reason: string;
 } | null;
+export declare const SWARM_LAUNCH_MANIFEST_RELPATH: readonly [".deft", "swarm-launch-manifest.json"];
+export declare const SWARM_LAUNCH_OCCUPANCY_DIR: readonly [".deft", "swarm-launch-occupancy"];
+export declare function swarmLaunchManifestPath(projectRoot: string): string;
+export interface LaunchOccupancyRecord {
+    readonly allocation_plan_id: string | null;
+    readonly occupancy_session_id: string;
+    readonly story_ids: readonly string[];
+    readonly cohort_key: string;
+}
+export interface LaunchOccupancyQuery {
+    readonly allocationPlanId?: string | null;
+    readonly storyIds?: readonly string[];
+}
+export type LaunchOccupancyLookupReason = "ok" | "missing" | "wrong-cohort";
+export declare function occupancyCohortKey(allocationPlanId: string | null | undefined, storyIds?: readonly string[]): string;
+export declare function launchOccupancyRecordRelpath(cohortKey: string): string[];
+export declare function persistLaunchOccupancyRecord(projectRoot: string, record: LaunchOccupancyRecord): void;
+export declare function resolveLaunchOccupancySessionId(projectRoot: string, query?: LaunchOccupancyQuery): {
+    sessionId: string;
+    reason: LaunchOccupancyLookupReason;
+};
 export declare function buildManifest(resolved: readonly ResolvedStory[], options: {
     projectRoot: string;
     group?: string | null;
@@ -53,6 +74,7 @@ export declare function buildManifest(resolved: readonly ResolvedStory[], option
     modelSource?: string | null;
     runtimeMode?: string | null;
     githubAuthMode?: string | null;
+    occupancySessionId?: string | null;
 }): Record<string, unknown>[];
 export declare function orderCohort(resolved: readonly ResolvedStory[], _projectRoot: string): ResolvedStory[];
 export interface LaunchArgs {

package/dist/swarm/launch.js

@@ -5,6 +5,7 @@ import { inferGithubAuthMode } from "../intake/github-auth-modes.js";
 import { getPlatformCapabilities } from "../intake/platform-capabilities.js";
 import { hasArtifactSuffix, resolveLifecycleFolder, stripArtifactSuffix, } from "../layout/resolve.js";
 import { evaluate as preflightEvaluate } from "../preflight/evaluate.js";
+import { applyWorktreeOccupancy } from "../session/occupancy.js";
 import { issueNumbersFromPlan, scopeMetadataRank } from "../triage/queue/scope-walk.js";
 import { selectionOrderingKey } from "../triage/queue/selection.js";
 import { DEFAULT_BASE_BRANCH, EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK, GATE_ADVISE, GATE_ENFORCE, LEAF_CODING_WORKER_ROLE, } from "./constants.js";
@@ -334,6 +335,121 @@ function deriveBranch(group, sid) {
 function defaultWorktree(projectRoot, sid) {
     return join(projectRoot, ".deft-scratch", "worktrees", safeSegment(sid)).replace(/\\/g, "/");
 }
+export const SWARM_LAUNCH_MANIFEST_RELPATH = [".deft", "swarm-launch-manifest.json"];
+export const SWARM_LAUNCH_OCCUPANCY_DIR = [".deft", "swarm-launch-occupancy"];
+export function swarmLaunchManifestPath(projectRoot) {
+    return join(resolve(projectRoot), ...SWARM_LAUNCH_MANIFEST_RELPATH);
+}
+export function occupancyCohortKey(allocationPlanId, storyIds = []) {
+    const plan = allocationPlanId?.trim() ?? "";
+    if (plan.length > 0)
+        return `plan:${plan}`;
+    const stories = [...storyIds].map((id) => id.trim()).filter((id) => id.length > 0);
+    stories.sort();
+    return `stories:${stories.join(",")}`;
+}
+export function launchOccupancyRecordRelpath(cohortKey) {
+    return [...SWARM_LAUNCH_OCCUPANCY_DIR, `${safeSegment(cohortKey)}.json`];
+}
+function parseLaunchOccupancyRecord(payload) {
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload))
+        return null;
+    const obj = payload;
+    const sessionId = typeof obj.occupancy_session_id === "string" ? obj.occupancy_session_id.trim() : "";
+    if (sessionId.length === 0)
+        return null;
+    const cohortKey = typeof obj.cohort_key === "string" ? obj.cohort_key.trim() : "";
+    if (cohortKey.length === 0)
+        return null;
+    const planRaw = obj.allocation_plan_id;
+    const allocationPlanId = typeof planRaw === "string" && planRaw.trim().length > 0 ? planRaw.trim() : null;
+    const storyIds = Array.isArray(obj.story_ids)
+        ? obj.story_ids.filter((id) => typeof id === "string" && id.trim().length > 0)
+        : [];
+    return {
+        allocation_plan_id: allocationPlanId,
+        occupancy_session_id: sessionId,
+        story_ids: storyIds,
+        cohort_key: cohortKey,
+    };
+}
+function storySetEquals(left, right) {
+    if (left.length !== right.size)
+        return false;
+    return left.every((id) => right.has(id));
+}
+function readLaunchOccupancyFile(projectRoot, cohortKey) {
+    const path = join(resolve(projectRoot), ...launchOccupancyRecordRelpath(cohortKey));
+    try {
+        if (!existsSync(path))
+            return null;
+        return parseLaunchOccupancyRecord(JSON.parse(readFileSync(path, { encoding: "utf8" })));
+    }
+    catch {
+        return null;
+    }
+}
+function listLaunchOccupancyRecords(projectRoot) {
+    const dir = join(resolve(projectRoot), ...SWARM_LAUNCH_OCCUPANCY_DIR);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const parsed = parseLaunchOccupancyRecord(JSON.parse(readFileSync(join(dir, name), { encoding: "utf8" })));
+            if (parsed !== null)
+                out.push(parsed);
+        }
+        catch {
+            /* skip unreadable cohort slot */
+        }
+    }
+    return out;
+}
+export function persistLaunchOccupancyRecord(projectRoot, record) {
+    const relpath = launchOccupancyRecordRelpath(record.cohort_key);
+    const absDir = join(resolve(projectRoot), ...SWARM_LAUNCH_OCCUPANCY_DIR);
+    mkdirSync(absDir, { recursive: true });
+    containedWrite({
+        root: projectRoot,
+        target: join(...relpath),
+        data: `${JSON.stringify(record, null, 2)}\n`,
+        mode: "replace",
+    });
+}
+export function resolveLaunchOccupancySessionId(projectRoot, query = {}) {
+    const storyIds = (query.storyIds ?? []).map((id) => id.trim()).filter((id) => id.length > 0);
+    const requestedKey = occupancyCohortKey(query.allocationPlanId, storyIds);
+    const exact = readLaunchOccupancyFile(projectRoot, requestedKey);
+    if (exact !== null) {
+        const wantedPlan = query.allocationPlanId?.trim() ?? "";
+        if (exact.cohort_key !== requestedKey) {
+            return { sessionId: "", reason: "wrong-cohort" };
+        }
+        if (wantedPlan.length > 0 && exact.allocation_plan_id !== wantedPlan) {
+            return { sessionId: "", reason: "wrong-cohort" };
+        }
+        return { sessionId: exact.occupancy_session_id, reason: "ok" };
+    }
+    if ((query.allocationPlanId?.trim() ?? "").length > 0) {
+        return { sessionId: "", reason: "missing" };
+    }
+    if (storyIds.length === 0) {
+        return { sessionId: "", reason: "missing" };
+    }
+    const wanted = new Set(storyIds);
+    const matches = listLaunchOccupancyRecords(projectRoot).filter((rec) => storySetEquals(rec.story_ids, wanted));
+    if (matches.length === 0) {
+        return { sessionId: "", reason: "missing" };
+    }
+    const sessionIds = new Set(matches.map((rec) => rec.occupancy_session_id));
+    if (sessionIds.size !== 1) {
+        return { sessionId: "", reason: "wrong-cohort" };
+    }
+    return { sessionId: matches[0]?.occupancy_session_id ?? "", reason: "ok" };
+}
 export function buildManifest(resolved, options) {
     const cohortVbriefs = resolved.map((s) => s.relpath);
     const records = options.worktreeRecords ?? new Map();
@@ -360,6 +476,9 @@ export function buildManifest(resolved, options) {
             branch: deriveBranch(options.group ?? null, story.story_id),
             allocation_context: allocationContext,
         };
+        if (options.occupancySessionId !== undefined && options.occupancySessionId !== null) {
+            entry.occupancy_session_id = options.occupancySessionId;
+        }
         if (options.subagentBackend !== undefined && options.subagentBackend !== null) {
             entry.subagent_backend = options.subagentBackend;
         }
@@ -562,6 +681,17 @@ export function swarmLaunch(args) {
             ? dispatchProviderFor(backend.backend_id)
             : null;
     const workerRoleValue = routingFile !== null || backend !== null ? LEAF_CODING_WORKER_ROLE : null;
+    const occupancy = applyWorktreeOccupancy(projectRoot, {
+        env: args.environ ?? process.env,
+        intent: "swarm",
+    });
+    if (occupancy.code !== 0) {
+        return {
+            exitCode: EXIT_GATE_FAILED,
+            stdout: "",
+            stderr: `${occupancy.message}\n`,
+        };
+    }
     const manifest = buildManifest(ordered, {
         projectRoot,
         group: args.group ?? null,
@@ -578,8 +708,33 @@ export function swarmLaunch(args) {
         modelSource,
         runtimeMode,
         githubAuthMode,
+        occupancySessionId: occupancy.sessionId,
     });
     const rendered = `${JSON.stringify(manifest, null, 2)}\n`;
+    const storyIds = ordered.map((story) => story.story_id);
+    const cohortKey = occupancyCohortKey(allocationPlanId, storyIds);
+    try {
+        mkdirSync(dirname(swarmLaunchManifestPath(projectRoot)), { recursive: true });
+        containedWrite({
+            root: projectRoot,
+            target: join(...SWARM_LAUNCH_MANIFEST_RELPATH),
+            data: rendered,
+            mode: "replace",
+        });
+        persistLaunchOccupancyRecord(projectRoot, {
+            allocation_plan_id: allocationPlanId,
+            occupancy_session_id: occupancy.sessionId,
+            story_ids: storyIds,
+            cohort_key: cohortKey,
+        });
+    }
+    catch (exc) {
+        return {
+            exitCode: EXIT_CONFIG_ERROR,
+            stdout: "",
+            stderr: `Error: could not persist launch occupancy_session_id: ${String(exc)}\n`,
+        };
+    }
     if (args.output !== undefined && args.output !== null) {
         try {
             // #2980 wave D: product write sink routes through containedWrite.

package/dist/swarm/routing-set-cli.d.ts

@@ -1,3 +1,13 @@
 #!/usr/bin/env node
-export declare function routingSetMain(argv?: string[]): number;
+/**
+ * `routing set` CLI entry.
+ *
+ * `environ` is the same injected-environment seam `resolveDispatchProvider` and
+ * `resolveRoutingPath` already carry (default `process.env`, so production
+ * behaviour is unchanged). Tests drive this entry with a constructed
+ * environment instead of subtracting known host vars from the ambient one --
+ * a denylist that silently rots every time a new host signal is added (#3494,
+ * after #3134 / #3492).
+ */
+export declare function routingSetMain(argv?: string[], environ?: NodeJS.ProcessEnv): number;
 //# sourceMappingURL=routing-set-cli.d.ts.map

package/dist/swarm/routing-set-cli.js

@@ -4,7 +4,17 @@ import { fileURLToPath } from "node:url";
 import { PROJECTION_CONTAINMENT_REFUSED_EXIT_CODE, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { EXIT_CONFIG_ERROR, EXIT_OK } from "./constants.js";
 import { HARNESS_BOUND_PROVIDERS, ROUTING_MODE_HARNESS_DEFAULT, ROUTING_MODE_PINNED, resolveDispatchProvider, resolveRoutingPath, SWARM_WORKER_ROLES, writeModelDecision, } from "./routing.js";
-export function routingSetMain(argv = process.argv.slice(2)) {
+/**
+ * `routing set` CLI entry.
+ *
+ * `environ` is the same injected-environment seam `resolveDispatchProvider` and
+ * `resolveRoutingPath` already carry (default `process.env`, so production
+ * behaviour is unchanged). Tests drive this entry with a constructed
+ * environment instead of subtracting known host vars from the ambient one --
+ * a denylist that silently rots every time a new host signal is added (#3494,
+ * after #3134 / #3492).
+ */
+export function routingSetMain(argv = process.argv.slice(2), environ = process.env) {
     let projectRoot = ".";
     let provider = null;
     let role = null;
@@ -49,7 +59,7 @@ export function routingSetMain(argv = process.argv.slice(2)) {
         // Same key as launch + verify:routing: OPENCLAW / sessions_spawn → openclaw
         // (#2875 Greptile P1). Do not map via runtimeMode alone — OpenClaw-only envs
         // are often local-unsandboxed while still dispatching under provider openclaw.
-        resolvedProvider = resolveDispatchProvider(process.env);
+        resolvedProvider = resolveDispatchProvider(environ);
     }
     if (harnessDefault) {
         if (model !== null) {
@@ -63,7 +73,7 @@ export function routingSetMain(argv = process.argv.slice(2)) {
         return EXIT_CONFIG_ERROR;
     }
     const root = resolve(projectRoot);
-    const path = resolveRoutingPath(root);
+    const path = resolveRoutingPath(root, environ);
     try {
         writeModelDecision(root, path, resolvedProvider, role, {
             model,

package/dist/swarm/routing-verify.d.ts

@@ -1,3 +1,4 @@
+import { type RoutingFile } from "./routing.js";
 export declare const ROUTING_SET_CMD = "task swarm:routing-set -- --role <role> --model <slug>   (or --harness-default)";
 /** Roles the pre-dispatch gate checks by default: the actual model lever. */
 export declare const DEFAULT_GATED_ROLES: readonly ["leaf-implementation"];
@@ -16,5 +17,16 @@ export interface VerifyRoutingResult {
     exitCode: number;
     report: string;
 }
+/**
+ * Dedicated host-unrecognized honesty line (#3469). Disclosure, not a gate:
+ * names the empty probes, that dispatch is still allowed, and the pin or
+ * inherit that will be used. Must not be folded into "all roles decided."
+ */
+export declare function formatHostUnrecognizedHonestyLine(options: {
+    environ?: NodeJS.ProcessEnv;
+    provider: string;
+    roles: readonly string[];
+    file: RoutingFile | null;
+}): string;
 export declare function verifyRouting(options: VerifyRoutingOptions): VerifyRoutingResult;
 //# sourceMappingURL=routing-verify.d.ts.map

package/dist/swarm/routing-verify.js

@@ -5,11 +5,13 @@
  *   - enforce (pre-dispatch): a hard gate in the pre-`start_agent` /
  *     `swarm:launch` gate stack. Three-state exit:
  *       0 = every in-scope role is decided (pinned or explicit harness-default)
+ *           OR provider is unrecognized (`unknown`) -- disclosure, not a gate (#3469)
  *       1 = at least one in-scope role is undecided / not dispatchable
  *       2 = config error (unreadable / malformed route file)
+ *     Unrecognized host never exits 1/2 solely because the host was unknown.
  */
 import { EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK } from "./constants.js";
-import { dispatchProviderFromRuntime, HARNESS_BOUND_PROVIDERS, loadRoutingFile, ROUTING_MODE_HARNESS_DEFAULT, resolveDispatchProvider, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
+import { dispatchProviderFromRuntime, emptyHostDetectProbes, HARNESS_BOUND_PROVIDERS, loadRoutingFile, ROUTING_MODE_HARNESS_DEFAULT, resolveDispatchProvider, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
 export const ROUTING_SET_CMD = "task swarm:routing-set -- --role <role> --model <slug>   (or --harness-default)";
 /** Roles the pre-dispatch gate checks by default: the actual model lever. */
 export const DEFAULT_GATED_ROLES = ["leaf-implementation"];
@@ -29,6 +31,29 @@ function resolveProvider(options) {
     }
     return resolveDispatchProvider(options.environ ?? process.env);
 }
+function isUnrecognizedHost(provider) {
+    return provider === "unknown";
+}
+function formatUsedPin(file, provider, role) {
+    const resolution = resolveModelRoute(file, provider, role);
+    if (resolution.decided && resolution.source !== "invalid") {
+        const value = resolution.model ?? "harness-default";
+        return `${provider}.${role}=${value}`;
+    }
+    return `inherit (no ${provider}.${role} pin)`;
+}
+/**
+ * Dedicated host-unrecognized honesty line (#3469). Disclosure, not a gate:
+ * names the empty probes, that dispatch is still allowed, and the pin or
+ * inherit that will be used. Must not be folded into "all roles decided."
+ */
+export function formatHostUnrecognizedHonestyLine(options) {
+    const empty = emptyHostDetectProbes(options.environ ?? process.env);
+    const emptyText = empty.length > 0 ? empty.join(", ") : "(none)";
+    const used = options.roles.map((role) => formatUsedPin(options.file, options.provider, role));
+    return (`[deft routing] host unrecognized (#3469): empty probes: ${emptyText}. ` +
+        `Dispatch still allowed. Using ${used.join("; ")}.`);
+}
 export function verifyRouting(options) {
     const roles = options.roles && options.roles.length > 0 ? options.roles : DEFAULT_GATED_ROLES;
     const provider = resolveProvider(options);
@@ -64,6 +89,15 @@ export function verifyRouting(options) {
         const modelText = resolution.model ?? "<runtime default>";
         resolvedLines.push(`  ${role}: model ${modelText} (resolved-via ${resolution.source})`);
     }
+    const unrecognized = isUnrecognizedHost(provider);
+    const honesty = unrecognized
+        ? formatHostUnrecognizedHonestyLine({
+            environ: options.environ ?? process.env,
+            provider,
+            roles,
+            file: data,
+        })
+        : "";
     if (invalid.length > 0 && !options.advise) {
         return {
             exitCode: EXIT_CONFIG_ERROR,
@@ -71,25 +105,29 @@ export function verifyRouting(options) {
         };
     }
     if (options.advise) {
+        const note = "[deft routing] NOTE: plan.policy.swarmSubagentBackend enum is deprecated (#1891); use 'task swarm:routing-set' / .deft/routing.local.json instead.";
+        let body;
         if (undecided.length === 0 && invalid.length === 0) {
-            return {
-                exitCode: EXIT_OK,
-                report: `[deft routing] provider '${provider}': all ${roles.length} gated role(s) decided.\n[deft routing] NOTE: plan.policy.swarmSubagentBackend enum is deprecated (#1891); use 'task swarm:routing-set' / .deft/routing.local.json instead.`,
-            };
+            body = `[deft routing] provider '${provider}': all ${roles.length} gated role(s) decided.`;
         }
-        const parts = [];
-        if (undecided.length > 0) {
-            parts.push(`undecided role(s): ${undecided.join(", ")}`);
+        else {
+            const parts = [];
+            if (undecided.length > 0) {
+                parts.push(`undecided role(s): ${undecided.join(", ")}`);
+            }
+            if (invalid.length > 0) {
+                parts.push(`invalid: ${invalid.length}`);
+            }
+            // Unrecognized host is disclosure: do not force routing-set (#3469).
+            const decide = unrecognized
+                ? "Dispatch still allowed."
+                : `Decide before swarm dispatch: ${ROUTING_SET_CMD}`;
+            body = `[deft routing] provider '${provider}' -- ${parts.join("; ")}. ${decide}`;
         }
-        if (invalid.length > 0) {
-            parts.push(`invalid: ${invalid.length}`);
-        }
-        return {
-            exitCode: EXIT_OK,
-            report: `[deft routing] provider '${provider}' -- ${parts.join("; ")}. Decide before swarm dispatch: ${ROUTING_SET_CMD}\n[deft routing] NOTE: plan.policy.swarmSubagentBackend enum is deprecated (#1891); use 'task swarm:routing-set' / .deft/routing.local.json instead.`,
-        };
+        const report = honesty.length > 0 ? `${honesty}\n${body}\n${note}` : `${body}\n${note}`;
+        return { exitCode: EXIT_OK, report };
     }
-    if (undecided.length > 0) {
+    if (undecided.length > 0 && !unrecognized) {
         return {
             exitCode: EXIT_GATE_FAILED,
             report: `routing gate: provider '${provider}' has undecided role(s): ${undecided.join(", ")}.\n` +
@@ -97,9 +135,10 @@ export function verifyRouting(options) {
                 `Decide: ${ROUTING_SET_CMD}`,
         };
     }
-    return {
-        exitCode: EXIT_OK,
-        report: `routing gate: provider '${provider}' -- all gated role(s) decided.\n${resolvedLines.join("\n")}`,
-    };
+    const decidedBody = undecided.length > 0
+        ? `routing gate: provider '${provider}' -- dispatch allowed (host unrecognized is disclosure, not a gate).`
+        : `routing gate: provider '${provider}' -- all gated role(s) decided.\n${resolvedLines.join("\n")}`;
+    const report = honesty.length > 0 ? `${honesty}\n${decidedBody}` : decidedBody;
+    return { exitCode: EXIT_OK, report };
 }
 //# sourceMappingURL=routing-verify.js.map

package/dist/swarm/routing.d.ts

@@ -9,6 +9,19 @@ export declare const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export declare const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export declare const HARNESS_BOUND_PROVIDERS: Set<string>;
+/**
+ * Live routing key for Grok Build. A `grok-build` file key is a trap (#3469):
+ * read it as `grok` when the live provider is grok, or ignore it without
+ * blocking launch.
+ */
+export declare const GROK_ROUTING_KEY = "grok";
+export declare const GROK_BUILD_FILE_KEY = "grok-build";
+/**
+ * Env / probe names that identify Grok Build. Same set `probeMonitoringTier`
+ * already uses, plus `GROK_BUILD` / `DEFT_AGENT_RUNTIME=grok-build`.
+ * Named on the host-unrecognized honesty line when empty (#3469).
+ */
+export declare const HOST_DETECT_PROBE_NAMES: readonly ["GROK_BUILD", "DEFT_AGENT_RUNTIME", "DEFT_HAS_SPAWN_SUBAGENT", "DEFT_PROBE_GROK_BUILD", "DEFT_PROBE_SPAWN_SUBAGENT"];
 /** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877 / #2875 / #3134). */
 export declare const ROUTING_GATED_DISPATCH_PROVIDERS: Set<string>;
 export interface RouteDecision {
@@ -41,6 +54,7 @@ export declare function loadRoutingFile(path: string): {
     data: RoutingFile | null;
     error: string | null;
 };
+export declare function emptyHostDetectProbes(environ?: NodeJS.ProcessEnv): string[];
 /**
  * Resolve a (provider, role) route. Tri-state by KEY PRESENCE:
  *   - key present, model "<slug>"      -> pinned

package/dist/swarm/routing.js

@@ -33,6 +33,25 @@ export const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export const HARNESS_BOUND_PROVIDERS = new Set(["grok"]);
+/**
+ * Live routing key for Grok Build. A `grok-build` file key is a trap (#3469):
+ * read it as `grok` when the live provider is grok, or ignore it without
+ * blocking launch.
+ */
+export const GROK_ROUTING_KEY = "grok";
+export const GROK_BUILD_FILE_KEY = "grok-build";
+/**
+ * Env / probe names that identify Grok Build. Same set `probeMonitoringTier`
+ * already uses, plus `GROK_BUILD` / `DEFT_AGENT_RUNTIME=grok-build`.
+ * Named on the host-unrecognized honesty line when empty (#3469).
+ */
+export const HOST_DETECT_PROBE_NAMES = [
+    "GROK_BUILD",
+    "DEFT_AGENT_RUNTIME",
+    "DEFT_HAS_SPAWN_SUBAGENT",
+    "DEFT_PROBE_GROK_BUILD",
+    "DEFT_PROBE_SPAWN_SUBAGENT",
+];
 /** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877 / #2875 / #3134). */
 export const ROUTING_GATED_DISPATCH_PROVIDERS = new Set([
     "cursor",
@@ -100,6 +119,12 @@ function providerBlockOf(file, provider) {
     }
     return block;
 }
+export function emptyHostDetectProbes(environ = process.env) {
+    return HOST_DETECT_PROBE_NAMES.filter((name) => (environ[name] ?? "").trim().length === 0);
+}
+function decisionLooksPinned(decision) {
+    return typeof decision.model === "string" && decision.model.trim().length > 0;
+}
 /**
  * Resolve a (provider, role) route. Tri-state by KEY PRESENCE:
  *   - key present, model "<slug>"      -> pinned
@@ -107,7 +132,28 @@ function providerBlockOf(file, provider) {
  *   - key absent                       -> undecided (fail loud upstream)
  */
 export function resolveModelRoute(file, provider, role) {
-    const block = providerBlockOf(file, provider);
+    let block = providerBlockOf(file, provider);
+    if ((block === null || !(role in block)) && provider === GROK_ROUTING_KEY) {
+        const alias = providerBlockOf(file, GROK_BUILD_FILE_KEY);
+        if (alias !== null && role in alias) {
+            const aliasDecision = alias[role];
+            // Dead `grok-build` pins must not fail-close a harness-bound grok
+            // provider (#3469). Read the pin as grok harness-default.
+            if (typeof aliasDecision === "object" &&
+                aliasDecision !== null &&
+                !Array.isArray(aliasDecision) &&
+                decisionLooksPinned(aliasDecision)) {
+                return {
+                    decided: true,
+                    model: null,
+                    mode: ROUTING_MODE_HARNESS_DEFAULT,
+                    source: "harness-default explicit",
+                    error: null,
+                };
+            }
+            block = alias;
+        }
+    }
     if (block === null || !(role in block)) {
         return { decided: false, model: null, mode: null, source: "undecided", error: null };
     }
@@ -198,8 +244,12 @@ export function resolveDispatchProvider(environ = process.env) {
         runtime === "openclaw") {
         return "openclaw";
     }
-    if (envTruthy(environ, "GROK_BUILD") || runtime === "grok-build") {
-        return "grok";
+    if (envTruthy(environ, "GROK_BUILD") ||
+        envTruthy(environ, "DEFT_HAS_SPAWN_SUBAGENT") ||
+        envTruthy(environ, "DEFT_PROBE_GROK_BUILD") ||
+        envTruthy(environ, "DEFT_PROBE_SPAWN_SUBAGENT") ||
+        runtime === "grok-build") {
+        return GROK_ROUTING_KEY;
     }
     if (runtime === "cloud" || runtime === "headless") {
         return "cloud-headless";

package/dist/telemetry-coverage/evaluate.d.ts

@@ -0,0 +1,42 @@
+/**
+ * verify:telemetry-coverage — dead-surface detector (#3362).
+ *
+ * Two checks, one remediation that names the missing half:
+ *  1. Every RUN_SUMMARY_EVENT_KINDS member (and exported emitter method)
+ *     has a production caller outside the emitter module.
+ *  2. Every kind is enrolled, has a trial step, and appears in a run of
+ *     the shared fake-trial harness JSONL.
+ *
+ * Default is warn-only (exit 0). Pass --enforce to fail closed.
+ */
+import { type FakeTrialResult } from "./fake-trial.js";
+export interface TelemetryCoverageFinding {
+    readonly subject: string;
+    readonly missingCaller: boolean;
+    readonly missingFixture: boolean;
+    readonly remediation: string;
+}
+export interface TelemetryCoverageOptions {
+    readonly projectRoot: string;
+    readonly enforce?: boolean;
+    readonly scanRoots?: readonly string[];
+    readonly kinds?: readonly string[];
+    readonly enrolledKinds?: readonly string[];
+    /** Override trial-step kinds (tests). Default: DEFAULT_TRIAL_STEPS. */
+    readonly trialKinds?: readonly string[];
+    /** Skip running the fake trial (unit tests). Production default is to run it. */
+    readonly skipTrial?: boolean;
+    /** Injected trial result (tests). */
+    readonly trialResult?: Pick<FakeTrialResult, "presentKinds" | "stepOutcomes">;
+}
+export interface TelemetryCoverageResult {
+    readonly code: number;
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+    readonly findings: readonly TelemetryCoverageFinding[];
+    readonly enforce: boolean;
+    readonly failOpen: boolean;
+}
+export declare function remediationFor(subject: string, missingCaller: boolean, missingFixture: boolean): string;
+export declare function evaluateTelemetryCoverage(options: TelemetryCoverageOptions): TelemetryCoverageResult;
+//# sourceMappingURL=evaluate.d.ts.map