@zq-silk/yui 0.14.1 → 0.15.0

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/observability/runtimeIdentity.js

@@ -13,7 +13,8 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { join } from "node:path";
 import Database from "better-sqlite3";
-import { CURRENT_AGGREGATE_SCHEMA_VERSION, CURRENT_STORAGE_LAYOUT_VERSION } from "../storage/storageVersions.js";
+import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "../storage/storageVersions.js";
+import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
 export const UNSUPPORTED = "unsupported";
 /**
@@ -140,14 +141,7 @@ export function collectRuntimeBuildIdentity(ports) {
 export function createProductionStorageIdentityPorts(env = process.env) {
     return {
         env,
-        readText: (path) => {
-            try {
-                return readFileSync(path, "utf8");
-            }
-            catch {
-                return null;
-            }
-        },
+        inspectStorage: (home) => inspectStorageSchema(home),
         fileSize: (path) => {
             try {
                 return statSync(path).size;
@@ -181,36 +175,12 @@ export function createProductionStorageIdentityPorts(env = process.env) {
  * are never treated as an alternate authority or a repair source.
  */
 export function collectStorageIdentity(home, ports = createProductionStorageIdentityPorts()) {
-    const manifestPath = join(home, "schema.json");
-    const manifestText = ports.readText(manifestPath);
-    let manifestStatus = "uninitialized";
-    let logicalLayout = UNSUPPORTED;
-    let aggregateSchemaVersion = UNSUPPORTED;
-    if (manifestText !== null) {
-        manifestStatus = "current";
-        try {
-            const manifest = JSON.parse(manifestText);
-            if (typeof manifest.storageVersion === "number"
-                && Number.isFinite(manifest.storageVersion)) {
-                logicalLayout = manifest.storageVersion;
-            }
-            if (typeof manifest.aggregateSchemaVersion === "number"
-                && Number.isFinite(manifest.aggregateSchemaVersion)) {
-                aggregateSchemaVersion = manifest.aggregateSchemaVersion;
-            }
-            if (typeof logicalLayout !== "number"
-                || typeof aggregateSchemaVersion !== "number"
-                || logicalLayout !== CURRENT_STORAGE_LAYOUT_VERSION
-                || aggregateSchemaVersion !== CURRENT_AGGREGATE_SCHEMA_VERSION) {
-                manifestStatus = "unsupported";
-            }
-        }
-        catch {
-            manifestStatus = "invalid";
-            logicalLayout = UNSUPPORTED;
-            aggregateSchemaVersion = UNSUPPORTED;
-        }
-    }
+    const storage = ports.inspectStorage(home);
+    const storageVersion = storage.status === "current"
+        || storage.status === "upgradeable"
+        || storage.status === "unsupported"
+        ? storage.currentVersion
+        : UNSUPPORTED;
     const statePath = join(home, "state.json");
     const statePresent = ports.exists(statePath);
     const stateBytes = ports.fileSize(statePath);
@@ -223,7 +193,7 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
     const workerEnabled = resolveStoreWorkerEnabledForHome(home, ports.env);
     const dbHealth = dbPresent ? ports.probeDatabaseHealth(dbPath) : null;
     const findings = [];
-    if (manifestStatus === "current" && !dbPresent) {
+    if (storage.status === "current" && !dbPresent) {
         findings.push({
             code: "current-database-missing",
             severity: "contradiction",
@@ -231,20 +201,48 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
             remediation: "Preserve this Home for diagnosis and initialize a new Home."
         });
     }
-    if (manifestStatus === "unsupported") {
+    if (storage.status === "uninitialized") {
+        findings.push({
+            code: "storage-uninitialized",
+            severity: "needs-repair",
+            message: "Yui storage has not been initialized for this Home.",
+            remediation: "Run `yui setup` for a new, empty Home."
+        });
+    }
+    if (storage.status === "upgradeable") {
+        findings.push({
+            code: "storage-upgrade-required",
+            severity: "needs-repair",
+            message: `Storage version ${storage.currentVersion} requires migration to `
+                + `${CURRENT_STORAGE_VERSION}.`,
+            remediation: "Run `yui upgrade` or `yui update` before resuming writes."
+        });
+    }
+    if (storage.status === "unsupported") {
         findings.push({
             code: "unsupported-storage-contract",
             severity: "contradiction",
-            message: "The Home does not match this release's exact storage contract.",
-            remediation: "Open it read-only with its original Yui version, then let the Operator recreate unfinished work in a new Home."
+            message: `Storage version ${storage.currentVersion} is outside the supported migration range `
+                + `${MIN_SUPPORTED_STORAGE_VERSION}..${CURRENT_STORAGE_VERSION}.`,
+            remediation: storage.direction === "newer"
+                ? "Use a newer Yui release."
+                : "Use a Yui release whose migration floor includes this Home."
         });
     }
-    if (manifestStatus === "invalid") {
+    if (storage.status === "invalid") {
         findings.push({
-            code: "invalid-storage-manifest",
+            code: "invalid-storage",
             severity: "contradiction",
-            message: "schema.json is invalid.",
-            remediation: "Preserve this Home for diagnosis and initialize a new Home."
+            message: storage.detail,
+            remediation: "Preserve this Home for diagnosis and restore a known-good backup."
+        });
+    }
+    if (ports.exists(join(home, "schema.json"))) {
+        findings.push({
+            code: "ignored-legacy-storage-manifest",
+            severity: "warning",
+            message: "schema.json is legacy metadata and is not a storage authority.",
+            remediation: "A successful storage upgrade removes it automatically."
         });
     }
     if (dbPresent && dbHealth !== null && dbHealth !== "ok") {
@@ -274,9 +272,9 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
     }
     return {
         home,
-        manifestStatus,
-        logicalLayout,
-        aggregateSchemaVersion,
+        storageStatus: storage.status,
+        storageVersion,
+        minimumStorageVersion: MIN_SUPPORTED_STORAGE_VERSION,
         configuredBackend,
         workerEnabled,
         physicalStateJson: {

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.");