@zq-silk/yui 0.14.0 → 0.14.2

package/dist/observability/faultClassification.js

@@ -1,16 +1,13 @@
-import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
 export const FAULT_CLASSES = [
-    "provider-transient",
-    "policy-denied",
     "session-dead",
     "delivery-uncertain",
-    "storage-backend-lock",
+    "result-missing",
+    "runtime-failure",
+    "workspace-state",
     "review-infra",
-    "review-semantic-negative",
     "integration-environment",
     "integration-candidate-failure",
     "stale-base-target-cas",
-    "archive-resource-leak",
     "other"
 ];
 export const NO_FAULT = Object.freeze({
@@ -18,87 +15,76 @@ export const NO_FAULT = Object.freeze({
     basis: "none",
     evidence: ""
 });
-const PROVIDER_TRANSIENT_PATTERN = /\b5\d{2}\b|gateway time|connection lost|server error|overloaded|rate.?limit|ECONNRESET|socket hang up|API Error|nonstream call error|mid-response/iu;
-const POLICY_DENIED_PATTERN = /policy|permission denied|forbidden|not authorized|\b403\b/iu;
-const SESSION_DEAD_PATTERN = /tmux session exited|session cannot be replaced|could not start|pane[^\n]*(dead|exited)|session[^\n]*(dead|exited|broken)|native session|launch reservation/iu;
-const STORAGE_LOCK_PATTERN = /storage lock|database is locked|SQLITE_BUSY|lock timeout|COMMAND_TIMED_OUT|storage conflict|timed out waiting/iu;
-const DELIVERY_UNCERTAIN_PATTERN = /delivery[^\n]*(uncertain|unknown)|uncertain[^\n]*delivery|push[^\n]*uncertain/iu;
-const STALE_BASE_PATTERN = /stale (role|agent|base|target|state)|expected head|base[^\n]*(changed|moved)|conflict|CAS/iu;
 const INTEGRATION_ENVIRONMENT_PATTERN = /tsc: not found|command not found|ENOENT|runner disappeared|runner vanished|dirty target|wrong argument|not a git repository|npm error|node: not found/iu;
 function excerpt(text, max = 160) {
     const normalized = text.replace(/\s+/g, " ").trim();
     return normalized.length <= max ? normalized : `${normalized.slice(0, max)}…`;
 }
-/**
- * Classify a failed Turn. A structured hint (from a future capability
- * provider) always wins; otherwise the summary is matched as historical
- * import text. Non-failed Turns return {@link NO_FAULT}.
- */
-export function classifyTurnFailure(run, structured) {
+/** Classify a failed Turn without inspecting Agent-authored output. */
+export function classifyTurnFailure(run) {
     if (run.status !== "failed")
         return NO_FAULT;
-    if (structured !== undefined) {
+    const failureReason = run.result?.failureReason;
+    if (failureReason === "cancelled")
+        return NO_FAULT;
+    if (failureReason === "delivery-unknown") {
         return {
-            faultClass: structured.faultClass,
-            basis: "structured",
-            evidence: structured.evidence
+            faultClass: "delivery-uncertain",
+            basis: "core-fact",
+            evidence: failureReason
         };
     }
-    const summary = run.result?.output ?? "";
-    if (summary.length === 0) {
-        return { faultClass: "other", basis: "text-historical", evidence: "" };
-    }
-    const text = excerpt(summary);
-    if (POLICY_DENIED_PATTERN.test(summary)) {
-        return { faultClass: "policy-denied", basis: "text-historical", evidence: text };
-    }
-    if (PROVIDER_TRANSIENT_PATTERN.test(summary)) {
-        return { faultClass: "provider-transient", basis: "text-historical", evidence: text };
-    }
-    if (STORAGE_LOCK_PATTERN.test(summary)) {
-        return { faultClass: "storage-backend-lock", basis: "text-historical", evidence: text };
-    }
-    if (DELIVERY_UNCERTAIN_PATTERN.test(summary)) {
-        return { faultClass: "delivery-uncertain", basis: "text-historical", evidence: text };
+    if (failureReason === "startup-failed") {
+        return {
+            faultClass: "session-dead",
+            basis: "core-fact",
+            evidence: failureReason
+        };
     }
-    if (STALE_BASE_PATTERN.test(summary)) {
-        return { faultClass: "stale-base-target-cas", basis: "text-historical", evidence: text };
+    if (failureReason === "missing-result") {
+        return {
+            faultClass: "result-missing",
+            basis: "core-fact",
+            evidence: failureReason
+        };
     }
-    if (SESSION_DEAD_PATTERN.test(summary)) {
-        return { faultClass: "session-dead", basis: "text-historical", evidence: text };
+    if (failureReason === "runtime-failed") {
+        return {
+            faultClass: "runtime-failure",
+            basis: "core-fact",
+            evidence: failureReason
+        };
     }
-    return { faultClass: "other", basis: "text-historical", evidence: text };
-}
-/**
- * Review execution failure (the Round itself failed to execute/deliver) is
- * `review-infra`; a completed Round with failed checks is a semantic negative.
- */
-export function classifyReviewRound(round, evidence) {
-    const outcome = classifyReviewRoundOutcome(round, evidence);
-    if (outcome?.kind === "non-semantic") {
+    if (failureReason === "workspace-unavailable"
+        || failureReason === "workspace-dirty"
+        || failureReason === "workspace-branch-mismatch") {
         return {
-            faultClass: "review-infra",
-            basis: "structured",
-            evidence: outcome.reason
+            faultClass: "workspace-state",
+            basis: "core-fact",
+            evidence: failureReason
         };
     }
-    if (outcome?.kind === "semantic" && (round.checks ?? []).some((c) => c.outcome === "failed")) {
-        const failed = (round.checks ?? [])
-            .filter((c) => c.outcome === "failed")
-            .map((c) => c.name)
-            .join(",");
+    return {
+        faultClass: "other",
+        basis: "core-fact",
+        evidence: failureReason ?? "failed without Core failure reason"
+    };
+}
+/** ReviewRound failure is an execution fault; completed prose is not classified. */
+export function classifyReviewRound(round) {
+    if (round.status === "failed") {
         return {
-            faultClass: "review-semantic-negative",
-            basis: "structured",
-            evidence: `failed checks: ${failed}`
+            faultClass: "review-infra",
+            basis: "core-fact",
+            evidence: round.failure?.message ?? "Review execution failed without Core failure detail."
         };
     }
     return NO_FAULT;
 }
 /**
  * Integration failure classes: environment/toolchain failure, stale base/CAS
- * conflict, or candidate failure. Conflict reports are structured; check
- * details are matched as historical text.
+ * conflict, or candidate failure. Conflict/check records are Core-owned, but
+ * environment attribution still uses a regex over their diagnostic text.
  */
 export function classifyIntegrationAttempt(attempt) {
     if (attempt.status !== "failed")
@@ -106,7 +92,7 @@ export function classifyIntegrationAttempt(attempt) {
     if (attempt.conflict !== undefined) {
         return {
             faultClass: "stale-base-target-cas",
-            basis: "structured",
+            basis: "core-fact",
             evidence: excerpt(attempt.conflict.summary)
         };
     }
@@ -116,20 +102,20 @@ export function classifyIntegrationAttempt(attempt) {
     if (INTEGRATION_ENVIRONMENT_PATTERN.test(checkText)) {
         return {
             faultClass: "integration-environment",
-            basis: "text-historical",
+            basis: "core-diagnostic",
             evidence: excerpt(checkText)
         };
     }
     if ((attempt.checks ?? []).some((c) => c.outcome === "failed")) {
         return {
             faultClass: "integration-candidate-failure",
-            basis: "structured",
+            basis: "core-fact",
             evidence: excerpt(checkText)
         };
     }
     return {
         faultClass: "other",
-        basis: "structured",
+        basis: "core-fact",
         evidence: "failed without checks or conflict"
     };
 }
@@ -138,8 +124,10 @@ export function emptyFaultClassCounts() {
 }
 export function countFaultClasses(classifications) {
     const counts = new Map(FAULT_CLASSES.map((name) => [name, 0]));
-    for (const { faultClass } of classifications) {
-        counts.set(faultClass, (counts.get(faultClass) ?? 0) + 1);
+    for (const classification of classifications) {
+        if (classification.basis === "none")
+            continue;
+        counts.set(classification.faultClass, (counts.get(classification.faultClass) ?? 0) + 1);
     }
     return Object.freeze(Object.fromEntries(counts));
 }

package/dist/observability/orchestrationMetrics.js

@@ -1,19 +1,10 @@
 import { isDeepStrictEqual } from "node:util";
-import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
+import { isCompletedReviewExecutionFromTurns } from "../review/reviewAcceptance.js";
 import { projectFirstProgressAdvisory } from "../runtime/firstProgressAdvisory.js";
 /** One Task's orchestration cost and advisory projection, with no writes. */
 export function projectTaskOrchestration(facts) {
-    const evidence = {
-        listTurns: () => facts.turns,
-        listReviewFindings: () => facts.reviewFindings,
-        listEvents: () => facts.events
-    };
     const fullRounds = facts.reviewRounds.filter((round) => round.deltaRecheck === undefined);
     const deltaRounds = facts.reviewRounds.filter((round) => round.deltaRecheck !== undefined);
-    const classifications = new Map(facts.reviewRounds.map((round) => [round.id, classifyReviewRoundOutcome(round, evidence)]));
-    const semanticRounds = facts.reviewRounds.filter((round) => (classifications.get(round.id)?.kind === "semantic"));
-    const p1P2Findings = facts.reviewFindings.filter((finding) => ((finding.severity === "p1" || finding.severity === "p2")
-        && semanticRounds.some((round) => round.id === finding.firstReviewRoundId))).length;
     const candidateTimes = [
         ...facts.changeSets.map(({ createdAt }) => createdAt),
         ...facts.workItems.flatMap((item) => item.candidates
@@ -43,7 +34,7 @@ export function projectTaskOrchestration(facts) {
         reviewRounds: facts.reviewRounds,
         integrations: facts.integrations
     });
-    const advisories = projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgress.attentionRecommended);
+    const advisories = projectAdvisories(facts, fullRounds, repeatedIdentities, firstProgress.attentionRecommended);
     const publicationAt = facts.task.completedAt === undefined
         ? undefined
         : facts.publications
@@ -66,12 +57,7 @@ export function projectTaskOrchestration(facts) {
         reviews: {
             full: fullRounds.length,
             delta: deltaRounds.length,
-            nonSemantic: [...classifications.values()].filter((value) => value?.kind === "non-semantic").length,
-            ambiguous: [...classifications.values()].filter((value) => value?.kind === "ambiguous").length,
-            p1P2Findings,
-            p1P2FindingsPerSemanticReview: semanticRounds.length === 0
-                ? 0
-                : p1P2Findings / semanticRounds.length
+            failed: facts.reviewRounds.filter(({ status }) => status === "failed").length
         },
         integrations: {
             attempts: facts.integrations.length,
@@ -87,7 +73,7 @@ export function projectTaskOrchestration(facts) {
         advisories
     });
 }
-function projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgressAttention) {
+function projectAdvisories(facts, fullRounds, repeatedIdentities, firstProgressAttention) {
     const result = [];
     if (facts.task.type === "bugfix" && facts.workItems.length > 0) {
         result.push({
@@ -96,26 +82,6 @@ function projectAdvisories(facts, classifications, fullRounds, repeatedIdentitie
             refs: facts.workItems.map(({ id }) => `work-item:${id}`)
         });
     }
-    const repairItems = facts.workItems.filter((item) => (item.acceptance.some((line) => line.startsWith("review-finding:"))));
-    const byRound = new Map();
-    for (const item of repairItems) {
-        const roundIds = new Set(item.acceptance.flatMap((line) => {
-            const findingId = line.startsWith("review-finding:") ? line.slice("review-finding:".length) : "";
-            const finding = facts.reviewFindings.find(({ id }) => id === findingId);
-            return finding === undefined ? [] : [finding.firstReviewRoundId];
-        }));
-        for (const roundId of roundIds)
-            byRound.set(roundId, [...(byRound.get(roundId) ?? []), item]);
-    }
-    for (const [roundId, items] of byRound) {
-        if (items.length < 2 || hasRepairFanoutDecision(facts.decisions, roundId, items))
-            continue;
-        result.push({
-            code: "review-repair-fanout",
-            reason: `Findings from Review ${roundId} were split across ${items.length} WorkItems without a durable Decision explaining independent ownership.`,
-            refs: [`review-round:${roundId}`, ...items.map(({ id }) => `work-item:${id}`)]
-        });
-    }
     if (repeatedIdentities > 0) {
         result.push({
             code: "repeated-integration-check",
@@ -125,19 +91,17 @@ function projectAdvisories(facts, classifications, fullRounds, repeatedIdentitie
                 .map(({ id }) => `durable-job:${id}`)
         });
     }
-    const semanticFull = fullRounds.filter((round) => classifications.get(round.id)?.kind === "semantic")
+    const completedFull = fullRounds.filter((round) => (isCompletedReviewExecutionFromTurns(round, facts.turns)))
         .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-    const recent = semanticFull.slice(-3);
-    const recentIds = new Set(recent.map(({ id }) => id));
-    const newFinding = facts.reviewFindings.some(({ firstReviewRoundId }) => recentIds.has(firstReviewRoundId));
+    const recent = completedFull.slice(-3);
     const sameCandidate = recent.length === 3
         && recent.every((round) => isDeepStrictEqual(round.taskCandidate, recent[0].taskCandidate));
     const sameReviewer = recent.length === 3
         && recent.every((round) => round.reviewerRoleName === recent[0].reviewerRoleName);
-    if (sameCandidate && sameReviewer && !newFinding) {
+    if (sameCandidate && sameReviewer) {
         result.push({
             code: "repeated-full-review",
-            reason: `The same Reviewer completed three full semantic Reviews of the same frozen candidate without a new finding; this is a cost advisory, not a Review limit.`,
+            reason: `The same Reviewer completed three full Reviews of the same frozen candidate; Core does not inspect their result text, so this is only a cost advisory.`,
             refs: recent.map(({ id }) => `review-round:${id}`)
         });
     }
@@ -150,12 +114,6 @@ function projectAdvisories(facts, classifications, fullRounds, repeatedIdentitie
     }
     return result;
 }
-function hasRepairFanoutDecision(decisions, roundId, items) {
-    return decisions.some((decision) => {
-        const text = `${decision.title}\n${decision.rationale}`;
-        return text.includes(roundId) && items.every(({ id }) => text.includes(id));
-    });
-}
 function terminalWorkspaceCount(facts) {
     return facts.managedWorkspaces.filter(({ owner }) => {
         if (owner.type === "task")

package/dist/profile/agentProfile.js

@@ -8,7 +8,7 @@ export const BUILTIN_PROFILE_IDS = Object.freeze([
 export function createAgentProfile(input, now) {
     const timestamp = now.toISOString();
     return validateAgentProfile({
-        schemaVersion: 2,
+        schemaVersion: 3,
         id: requireIdentity(input.id, "Agent Profile id"),
         revision: 1,
         ...normalizeInput(input),
@@ -24,15 +24,15 @@ export function updateAgentProfile(profile, patch, now) {
         revision: profile.revision + 1,
         updatedAt: now.toISOString()
     };
-    for (const key of ["description", "instructions", "skills", "model", "effort"]) {
+    for (const key of ["description", "instructions", "skills"]) {
         if (candidate[key] === undefined)
             delete candidate[key];
     }
     return validateAgentProfile(candidate);
 }
 export function validateAgentProfile(profile) {
-    if (profile.schemaVersion !== 2) {
-        throw new Error("AgentProfile must use schemaVersion 2.");
+    if (profile.schemaVersion !== 3) {
+        throw new Error("AgentProfile must use schemaVersion 3.");
     }
     requireIdentity(profile.id, "Agent Profile id");
     requirePositiveInteger(profile.revision, "Agent Profile revision");
@@ -43,10 +43,7 @@ export function validateAgentProfile(profile) {
         optionalText(profile.instructions, "Profile instructions");
     if (profile.skills !== undefined)
         normalizedUniqueText(profile.skills, "Profile skill");
-    if (profile.model !== undefined)
-        optionalText(profile.model, "Profile model");
-    if (profile.effort !== undefined)
-        optionalText(profile.effort, "Profile effort");
+    validateAgentProfileRuntime(profile.runtime);
     requireTimestamp(profile.createdAt, "Agent Profile createdAt");
     requireTimestamp(profile.updatedAt, "Agent Profile updatedAt");
     if (Date.parse(profile.updatedAt) < Date.parse(profile.createdAt)) {
@@ -59,24 +56,28 @@ export function builtinAgentProfileInputs() {
         {
             id: "worker",
             description: "Implement and validate one bounded delegated WorkItem.",
-            defaultAccess: "write"
+            defaultAccess: "write",
+            runtime: { source: "global-worker" }
         },
         {
             id: "explorer",
             description: "Inspect sources and return evidence without modifying them.",
             instructions: "Do not modify files or external state.",
-            defaultAccess: "read"
+            defaultAccess: "read",
+            runtime: { source: "global-worker" }
         },
         {
             id: "implementer",
             description: "Implement and validate one bounded result.",
-            defaultAccess: "write"
+            defaultAccess: "write",
+            runtime: { source: "global-worker" }
         },
         {
             id: "reviewer",
             description: "Review one candidate against the user's core outcome, supported behavior, and direct evidence.",
             instructions: "Start from user intent and acceptance criteria. Inspect the complete relevant change and report only reachable, material, actionable problems with direct evidence. Separate defects from verification gaps, and prefer the smallest sufficient correction. Follow the bound Project's Policy and Knowledge for build, test, migration, release, and review expectations; do not import rules from another Project or Task. For normal software delivery, review the frozen Task result as one final ReviewRound rather than inventing a per-WorkItem protocol unless the Project Policy explicitly requires one. A Task-final Round has no synthetic WorkItem anchor, and the Reviewer Session and physical workspace continue across changed-head Rounds without reusing an earlier verdict. The current Turn's frozen candidate remains the only scope even if Task main advances. For Delta Recheck, return equivalent-and-accepted, finding, or requires-full-review with explicit reasoning; never create the next Round. Do not turn speculative or extreme edge cases into new state, retries, fallbacks, or protocol. In the Review workspace you may edit source or tests, run local checks, and optionally commit diagnostic evidence. Never push, integrate, mutate Task state, touch another workspace or stable checkout, or write the real Yui control-plane home. End the Provider turn with complete findings, checks actually run, uncertainty, and bounded next actions; Yui preserves the full free-form report automatically. Expose evidence and options to the Leader, who decides.",
-            defaultAccess: "write"
+            defaultAccess: "write",
+            runtime: { source: "global-worker" }
         }
     ];
 }
@@ -92,8 +93,7 @@ function normalizeInput(input) {
         ...(input.skills === undefined
             ? {}
             : { skills: normalizedUniqueText(input.skills, "Profile skill") }),
-        ...(input.model === undefined ? {} : { model: optionalText(input.model, "Profile model") }),
-        ...(input.effort === undefined ? {} : { effort: optionalText(input.effort, "Profile effort") })
+        runtime: normalizeRuntime(input.runtime ?? { source: "global-worker" })
     };
 }
 function normalizePatch(patch) {
@@ -101,7 +101,7 @@ function normalizePatch(patch) {
     if (Object.hasOwn(patch, "defaultAccess")) {
         result.defaultAccess = validatedAccess(patch.defaultAccess);
     }
-    for (const key of ["description", "instructions", "model", "effort"]) {
+    for (const key of ["description", "instructions"]) {
         if (!Object.hasOwn(patch, key))
             continue;
         result[key] = patch[key] === undefined
@@ -113,8 +113,53 @@ function normalizePatch(patch) {
             ? undefined
             : normalizedUniqueText(patch.skills, "Profile skill");
     }
+    if (Object.hasOwn(patch, "runtime")) {
+        if (patch.runtime === undefined) {
+            throw new Error("Agent Profile runtime is required.");
+        }
+        result.runtime = normalizeRuntime(patch.runtime);
+    }
     return result;
 }
+function normalizeRuntime(runtime) {
+    validateAgentProfileRuntime(runtime);
+    return runtime.source === "global-worker"
+        ? { source: "global-worker" }
+        : {
+            source: "explicit",
+            agentId: requireIdentity(runtime.agentId, "Profile Agent id"),
+            ...(runtime.model === undefined
+                ? {}
+                : { model: optionalText(runtime.model, "Profile model") }),
+            ...(runtime.effort === undefined
+                ? {}
+                : { effort: optionalText(runtime.effort, "Profile effort") })
+        };
+}
+function validateAgentProfileRuntime(runtime) {
+    if (runtime === null || typeof runtime !== "object" || Array.isArray(runtime)) {
+        throw new Error("Agent Profile runtime is invalid.");
+    }
+    const source = runtime.source;
+    if (source === "global-worker") {
+        if (Object.keys(runtime).some((key) => key !== "source")) {
+            throw new Error("Worker-inherited Agent Profile runtime cannot persist Agent settings.");
+        }
+        return;
+    }
+    if (source !== "explicit") {
+        throw new Error(`Agent Profile runtime source is invalid: ${String(source)}.`);
+    }
+    if (Object.keys(runtime).some((key) => (key !== "source" && key !== "agentId" && key !== "model" && key !== "effort"))) {
+        throw new Error("Explicit Agent Profile runtime contains unsupported fields.");
+    }
+    const explicit = runtime;
+    requireIdentity(explicit.agentId, "Profile Agent id");
+    if (explicit.model !== undefined)
+        optionalText(explicit.model, "Profile model");
+    if (explicit.effort !== undefined)
+        optionalText(explicit.effort, "Profile effort");
+}
 function validatedAccess(value) {
     if (value === undefined)
         throw new Error("Agent Profile default access is required.");

package/dist/profile/agentProfileRuntime.js

@@ -0,0 +1,100 @@
+import { createRoleAgentBinding } from "../role/role.js";
+/** The single read model for persisted Profile intent and current runtime. */
+export function resolveAgentProfileView(profile, store) {
+    return {
+        profile,
+        runtime: resolveAgentProfileRuntime(profile, store)
+    };
+}
+/**
+ * Resolve one Profile into a complete Role binding. Inherited Profiles copy
+ * the current Global Worker active binding verbatim. An explicit Profile with
+ * a matching Worker binding preserves that complete binding, whether active or
+ * dormant, and overlays its own model/effort; another Agent starts from its
+ * provider defaults.
+ */
+export function resolveAgentProfileRuntime(profile, store) {
+    if (profile.runtime.source === "global-worker") {
+        const worker = store.getGlobalRole("worker");
+        if (worker === null) {
+            return {
+                status: "unavailable",
+                source: "global-worker",
+                reason: "Global Role worker is not configured."
+            };
+        }
+        const binding = worker.agentBindings[worker.activeAgentId];
+        if (binding === undefined) {
+            return {
+                status: "unavailable",
+                source: "global-worker",
+                workerRevision: worker.launchRevision,
+                reason: `Global Role worker active Agent is not bound: ${worker.activeAgentId}.`
+            };
+        }
+        const agent = store.getConfiguredAgent(binding.agentId);
+        if (agent === null) {
+            return {
+                status: "unavailable",
+                source: "global-worker",
+                workerRevision: worker.launchRevision,
+                reason: `Global Role worker Agent is not configured: ${binding.agentId}.`
+            };
+        }
+        if (agent.adapterId !== binding.adapterId) {
+            return {
+                status: "unavailable",
+                source: "global-worker",
+                workerRevision: worker.launchRevision,
+                reason: `Global Role worker Agent adapter does not match its binding: ${binding.agentId}.`
+            };
+        }
+        return {
+            status: "resolved",
+            source: "global-worker",
+            workerRevision: worker.launchRevision,
+            binding: createRoleAgentBinding(agent, binding.config)
+        };
+    }
+    const agent = store.getConfiguredAgent(profile.runtime.agentId);
+    if (agent === null) {
+        return {
+            status: "unavailable",
+            source: "explicit",
+            reason: `Configured Agent not found: ${profile.runtime.agentId}.`
+        };
+    }
+    const worker = store.getGlobalRole("worker");
+    const workerBinding = worker?.agentBindings[agent.id];
+    if (workerBinding !== undefined && workerBinding.adapterId !== agent.adapterId) {
+        return {
+            status: "unavailable",
+            source: "explicit",
+            reason: `Global Role worker Agent adapter does not match its binding: ${agent.id}.`
+        };
+    }
+    const base = workerBinding === undefined
+        ? createRoleAgentBinding(agent)
+        : createRoleAgentBinding(agent, workerBinding.config);
+    const config = structuredClone(base.config);
+    if (profile.runtime.model === undefined)
+        delete config.model;
+    else
+        config.model = profile.runtime.model;
+    if (profile.runtime.effort === undefined)
+        delete config.effort;
+    else
+        config.effort = profile.runtime.effort;
+    return {
+        status: "resolved",
+        source: "explicit",
+        binding: createRoleAgentBinding(agent, config)
+    };
+}
+export function requireResolvedAgentProfileRuntime(profile, store) {
+    const runtime = resolveAgentProfileRuntime(profile, store);
+    if (runtime.status === "unavailable") {
+        throw new Error(`Agent Profile ${profile.id} runtime is unavailable: ${runtime.reason}`);
+    }
+    return runtime;
+}

package/dist/release/releaseWorkflowPorts.js

@@ -1,10 +1,7 @@
-import { execFile } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { accessSync, constants } from "node:fs";
 import { chmod, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
-import { promisify } from "node:util";
+import { dirname, join, resolve } from "node:path";
 import { runUpdate } from "../cli/updateOrchestrator.js";
 import { activatedControllerEntrypoint } from "../cli/updatePorts.js";
 import { restartFileTaskController, stopFileTaskController } from "../controller/clientRuntime.js";
@@ -14,25 +11,9 @@ import { isConcreteVersion } from "../domain/validation.js";
 import { resolveProject } from "../repository/project.js";
 import { resolveVerificationGate } from "../verification/verificationGateService.js";
 import { findL2ArtifactForCommit } from "../verification/gateArtifactStore.js";
-const defaultRunCommand = async (command, args, cwd, env) => {
-    const exec = promisify(execFile);
-    try {
-        const { stdout, stderr } = await exec(command, args, {
-            cwd,
-            maxBuffer: 16 * 1024 * 1024,
-            ...(env === undefined ? {} : { env: { ...process.env, ...env } })
-        });
-        return { code: 0, stdout, stderr };
-    }
-    catch (error) {
-        const failure = error;
-        return {
-            code: typeof failure.code === "number" ? failure.code : 1,
-            stdout: failure.stdout ?? "",
-            stderr: failure.stderr ?? failure.message ?? String(error)
-        };
-    }
-};
+import { createExecFileCommandRunner, createPinnedCommandRunner, resolveExecutable } from "../external/pinnedCommandRunner.js";
+export { resolveExecutable } from "../external/pinnedCommandRunner.js";
+const defaultRunCommand = createExecFileCommandRunner();
 /**
  * The external commands the production adapter shells out to. Each one is
  * resolved to an absolute path once, at adapter construction time, so a PATH
@@ -47,24 +28,6 @@ const PINNED_EXTERNAL_COMMANDS = ["gh", "git", "npm", "tar", "sh"];
  * command that cannot be resolved returns undefined. Callers must fail closed
  * without invoking a mutable PATH fallback.
  */
-export function resolveExecutable(command, environmentPath) {
-    if (isAbsolute(command))
-        return command;
-    const pathValue = environmentPath ?? "";
-    for (const directory of pathValue.split(delimiter)) {
-        if (directory.length === 0)
-            continue;
-        const candidate = resolve(directory, command);
-        try {
-            accessSync(candidate, constants.X_OK);
-            return candidate;
-        }
-        catch {
-            // Keep walking PATH.
-        }
-    }
-    return undefined;
-}
 /**
  * Wrap the default runner so every external command is pinned to the
  * absolute path resolved at construction. Injected runners (tests) are used
@@ -75,33 +38,7 @@ export function resolveExecutable(command, environmentPath) {
  * unresolvable for the adapter's lifetime.
  */
 export function createPinnedRunner(base) {
-    const pinned = new Map();
-    for (const name of PINNED_EXTERNAL_COMMANDS) {
-        pinned.set(name, resolveExecutable(name, process.env.PATH));
-    }
-    return (command, args, cwd, env) => {
-        // P2 (rr24): `Map.get` returns undefined both for a missing key and for
-        // a key whose resolved value is undefined (a command that was not on
-        // PATH at construction). Use `Map.has` to distinguish them so the
-        // negative cache holds: a command resolved as missing stays missing even
-        // if it appears on PATH later in the adapter's lifetime.
-        let resolved;
-        if (pinned.has(command)) {
-            resolved = pinned.get(command);
-        }
-        else {
-            resolved = isAbsolute(command) ? command : resolveExecutable(command, process.env.PATH);
-            pinned.set(command, resolved);
-        }
-        if (resolved === undefined) {
-            return Promise.resolve({
-                code: 127,
-                stdout: "",
-                stderr: `Unable to resolve trusted executable: ${command}`
-            });
-        }
-        return base(resolved, args, cwd, env);
-    };
+    return createPinnedCommandRunner(base, PINNED_EXTERNAL_COMMANDS);
 }
 /**
  * The real adapter. It is NEVER exercised by the deterministic test suite