@zq-silk/yui 0.15.7 → 0.15.8

package/dist/{turn/turn.js → agentRun/agentRun.js}

@@ -1,22 +1,41 @@
 import { validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
-import { createTurnInput, createTurnInputEnvelope, validateTurnInput } from "../context/turnInputContract.js";
-import { boundedTurnFailureDiagnostic, MAX_TURN_FAILURE_DIAGNOSTIC_BYTES, MAX_TURN_RESULT_OUTPUT_BYTES } from "../domain/agentResultTransport.js";
-export { boundedTurnFailureDiagnostic, MAX_TURN_FAILURE_DIAGNOSTIC_BYTES, MAX_TURN_RESULT_OUTPUT_BYTES, transportAgentResult } from "../domain/agentResultTransport.js";
-export function createTurn(id, taskId, roleName, mode, input, now, context) {
+import { createRunInput, createRunInputEnvelope, validateRunInput } from "../context/runInputContract.js";
+import { boundedRunFailureDiagnostic, MAX_RUN_FAILURE_DIAGNOSTIC_BYTES, MAX_RUN_RESULT_OUTPUT_BYTES } from "../domain/agentResultTransport.js";
+export { boundedRunFailureDiagnostic, MAX_RUN_FAILURE_DIAGNOSTIC_BYTES, MAX_RUN_RESULT_OUTPUT_BYTES, transportAgentResult } from "../domain/agentResultTransport.js";
+/** Record lifecycle and observed delivery are separate read-only facts. */
+export function runExecutionObservation(run, binding, events = []) {
+    const current = binding?.run?.runId === run.id ? binding.run : undefined;
+    let delivery = current?.status ?? run.result?.provider?.status ?? "unobserved";
+    const lastError = events.filter((event) => event.type === "runtime.agent-error"
+        && event.payload.runId === run.id && event.payload.phase === "turn-submit"
+        && (current === undefined || event.payload.attemptId === current.attemptId)).at(-1);
+    if ((delivery === "unobserved" || delivery === "submitting") && lastError?.payload.inputDisposition === "unknown") {
+        delivery = "delivery-unknown";
+    }
+    return {
+        recordStatus: run.status,
+        delivery,
+        ...(current === undefined ? {} : {
+            attemptId: current.attemptId, observedAt: current.updatedAt,
+            ...(current.nativeTurnId === undefined ? {} : { nativeTurnId: current.nativeTurnId })
+        })
+    };
+}
+export function createRun(id, taskId, roleName, mode, input, now, context) {
     if (mode !== "new" && mode !== "resume") {
-        throw new Error(`Turn dispatch mode is invalid: ${mode}.`);
+        throw new Error(`AgentRun dispatch mode is invalid: ${mode}.`);
     }
     const timestamp = now.toISOString();
-    const normalizedInput = validateTurnInput(input);
+    const normalizedInput = validateRunInput(input);
     return {
         schemaVersion: 5,
-        id: requireSafeIdentity(id, "Turn id"),
+        id: requireSafeIdentity(id, "AgentRun id"),
         taskId: requireSafeIdentity(taskId, "Task id"),
         roleName: requireSafeIdentity(roleName, "Role name"),
         mode,
-        inputs: [turnInputRecord(normalizedInput, 1, timestamp)],
+        inputs: [runInputRecord(normalizedInput, 1, timestamp)],
         purpose: context.purpose ?? "execution",
         ...(context.workItemId === undefined
             ? {}
@@ -44,48 +63,64 @@ export function createTurn(id, taskId, roleName, mode, input, now, context) {
         updatedAt: timestamp
     };
 }
-export function isActiveTurn(run) {
+export function isActiveRun(run) {
     return run.status === "active";
 }
+/**
+ * The Task lifecycle a Turn of this purpose may run in.
+ *
+ * Delivery requires an active Task with execution admitted. Planning is the
+ * Draft Leader's own conversation, so it is also admitted while the Task is
+ * still a Draft; the execution gate still applies, because a stopped Task must
+ * not gain a live process through the planning door. Nothing here relaxes the
+ * workspace fence — a planning Turn simply has no workspace to be ready.
+ */
+export function runPurposeAdmitsTaskState(purpose, task) {
+    if (task.executionGate.state !== "enabled")
+        return false;
+    return purpose === "planning"
+        ? task.status === "draft" || task.status === "active"
+        : task.status === "active";
+}
 /** Binds a freshly created, not-yet-persisted Turn to its frozen Context. */
-export function withTurnContextSnapshot(run, snapshot, deltaRefIds = []) {
+export function withRunContextSnapshot(run, snapshot, deltaRefIds = []) {
     const initial = run.inputs[0];
     if (run.status !== "active" || initial.input.contextSnapshotRef !== undefined) {
-        throw new Error(`Cannot replace the Turn Context Snapshot: ${run.id}.`);
+        throw new Error(`Cannot replace the AgentRun Context Snapshot: ${run.id}.`);
     }
-    const input = createTurnInput({
+    const input = createRunInput({
         ...initial.input,
         contextSnapshotRef: snapshot,
         deltaRefIds
     });
-    return validateTurn(Object.freeze({
+    return validateRun(Object.freeze({
         ...run,
-        inputs: [turnInputRecord(input, 1, initial.submittedAt), ...run.inputs.slice(1)]
+        inputs: [runInputRecord(input, 1, initial.submittedAt), ...run.inputs.slice(1)]
     }));
 }
-export function appendTurnInput(run, input, now) {
-    validateTurn(run);
+export function appendRunInput(run, input, now) {
+    validateRun(run);
     if (run.status !== "active")
-        throw new Error(`Cannot append input to terminal Turn: ${run.id}.`);
+        throw new Error(`Cannot append input to terminal AgentRun: ${run.id}.`);
     const timestamp = now.toISOString();
     if (Date.parse(timestamp) < Date.parse(run.updatedAt)) {
-        throw new Error("Turn input timestamp moved backwards.");
+        throw new Error("AgentRun input timestamp moved backwards.");
     }
-    return validateTurn({
+    return validateRun({
         ...run,
-        inputs: [...run.inputs, turnInputRecord(input, run.inputs.length + 1, timestamp)],
+        inputs: [...run.inputs, runInputRecord(input, run.inputs.length + 1, timestamp)],
         updatedAt: timestamp
     });
 }
-/** Derives Provider-visible identity from the Turn, the sole semantic owner. */
-export function turnInputEnvelope(run, sequence = 1) {
-    validateTurn(run);
+/** Derives Provider-visible identity from the AgentRun, the sole semantic owner. */
+export function runInputEnvelope(run, sequence = 1) {
+    validateRun(run);
     const record = run.inputs[sequence - 1];
     if (record === undefined)
-        throw new Error(`Turn input does not exist: ${run.id}/${sequence}.`);
-    return createTurnInputEnvelope(turnEnvelopeContext(run), record.input);
+        throw new Error(`AgentRun input does not exist: ${run.id}/${sequence}.`);
+    return createRunInputEnvelope(runEnvelopeContext(run), record.input);
 }
-export function validateTurn(run) {
+export function validateRun(run) {
     rejectUnknownFields(run, [
         "schemaVersion",
         "id",
@@ -105,28 +140,28 @@ export function validateTurn(run) {
         "result",
         "createdAt",
         "updatedAt"
-    ], "Turn");
+    ], "AgentRun");
     if (run.schemaVersion !== 5)
-        throw new Error("Turn must use schemaVersion 5.");
-    validateTaskRecordReference({ taskId: run.taskId, localId: run.id }, "turn");
+        throw new Error("AgentRun must use schemaVersion 5.");
+    validateTaskRecordReference({ taskId: run.taskId, localId: run.id }, "run");
     requireSafeIdentity(run.roleName, "Role name");
     if (run.mode !== "new" && run.mode !== "resume") {
-        throw new Error(`Turn dispatch mode is invalid: ${String(run.mode)}.`);
+        throw new Error(`AgentRun dispatch mode is invalid: ${String(run.mode)}.`);
     }
     if (!Array.isArray(run.inputs) || run.inputs.length === 0) {
-        throw new Error("Turn requires at least one input.");
+        throw new Error("AgentRun requires at least one input.");
     }
     for (const [index, record] of run.inputs.entries()) {
         if (record.sequence !== index + 1)
-            throw new Error("Turn input sequence is invalid.");
-        requireTimestamp(record.submittedAt, "Turn input submittedAt");
-        validateTurnInput(record.input);
+            throw new Error("AgentRun input sequence is invalid.");
+        requireTimestamp(record.submittedAt, "AgentRun input submittedAt");
+        validateRunInput(record.input);
         if (index > 0 && Date.parse(record.submittedAt) < Date.parse(run.inputs[index - 1].submittedAt)) {
-            throw new Error("Turn input timestamps moved backwards.");
+            throw new Error("AgentRun input timestamps moved backwards.");
         }
     }
-    if (!["execution", "review"].includes(run.purpose)) {
-        throw new Error(`Turn purpose is invalid: ${String(run.purpose)}.`);
+    if (!["execution", "review", "planning"].includes(run.purpose)) {
+        throw new Error(`AgentRun purpose is invalid: ${String(run.purpose)}.`);
     }
     if (run.workItemId !== undefined) {
         validateTaskRecordReference({ taskId: run.taskId, localId: run.workItemId }, "workItem");
@@ -135,7 +170,7 @@ export function validateTurn(run) {
         validateTaskRecordReference({ taskId: run.taskId, localId: run.reviewRoundId }, "reviewRound");
     }
     if ((run.executionGroupId === undefined) !== (run.executionLaneId === undefined)) {
-        throw new Error("Turn execution lineage is incomplete.");
+        throw new Error("AgentRun execution lineage is incomplete.");
     }
     if (run.executionGroupId !== undefined) {
         requireSafeIdentity(run.executionGroupId, "ExecutionGroup id");
@@ -143,54 +178,77 @@ export function validateTurn(run) {
     }
     if (run.sourceExecutionGroupId !== undefined) {
         requireSafeIdentity(run.sourceExecutionGroupId, "Source ExecutionGroup id");
+        if (run.purpose === "planning") {
+            throw new Error("A planning Turn cannot aggregate an Execution Lane group.");
+        }
         if ((run.purpose === "execution" && run.workItemId === undefined)
             || (run.purpose === "review" && run.reviewRoundId === undefined)) {
-            throw new Error("A source ExecutionGroup requires a main execution or review Turn.");
+            throw new Error("A source ExecutionGroup requires a main execution or review AgentRun.");
+        }
+        if (run.executionGroupId !== undefined || run.executionLaneId !== undefined) {
+            throw new Error("A main AgentRun cannot also be an Execution Lane AgentRun.");
+        }
+    }
+    if (run.purpose === "planning") {
+        if (run.effective.executionAuthority !== "planning") {
+            throw new Error("A planning AgentRun cannot hold delivery authority.");
+        }
+        // Draft planning is deliberately delivery-free: no WorkItem, ReviewRound,
+        // Lane or workspace. That is what keeps a planning result from ever being
+        // read as execution evidence or promoted into a Candidate.
+        if (run.workItemId !== undefined) {
+            throw new Error("A planning Turn cannot reference a Work Item.");
+        }
+        if (run.reviewRoundId !== undefined) {
+            throw new Error("A planning Turn cannot reference a ReviewRound.");
         }
         if (run.executionGroupId !== undefined || run.executionLaneId !== undefined) {
-            throw new Error("A main Turn cannot also be an Execution Lane Turn.");
+            throw new Error("A planning Turn cannot be an Execution Lane Turn.");
+        }
+        if (run.workspace !== undefined) {
+            throw new Error("A planning Turn cannot own a managed workspace.");
         }
     }
     if (run.workspace !== undefined) {
         validateManagedWorkspace(run.workspace);
         if (run.workspace.owner.taskId !== run.taskId) {
-            throw new Error("Turn workspace belongs to another Task.");
+            throw new Error("AgentRun workspace belongs to another Task.");
         }
         if (run.workspace.owner.type === "work-item"
             && run.workspace.owner.workItemId !== run.workItemId) {
-            throw new Error("Turn workspace belongs to another Work Item.");
+            throw new Error("AgentRun workspace belongs to another Work Item.");
         }
         if (run.workspace.owner.type === "work-item" && run.workItemId === undefined) {
-            throw new Error("A WorkItem workspace requires a WorkItem Turn reference.");
+            throw new Error("A WorkItem workspace requires a WorkItem AgentRun reference.");
         }
         if (run.workspace.owner.type === "review-round" && run.purpose !== "review") {
-            throw new Error("A ReviewRound workspace requires a review Turn.");
+            throw new Error("A ReviewRound workspace requires a review AgentRun.");
         }
         if (run.workspace.owner.type === "integration-attempt") {
-            throw new Error("An IntegrationAttempt workspace cannot be used by a Turn.");
+            throw new Error("An IntegrationAttempt workspace cannot be used by a AgentRun.");
         }
         if (run.workspace.owner.type === "execution-lane") {
             if (run.workspace.owner.executionGroupId !== run.executionGroupId
                 || run.workspace.owner.executionLaneId !== run.executionLaneId) {
-                throw new Error("Turn Execution Lane workspace lineage does not match the Turn.");
+                throw new Error("AgentRun Execution Lane workspace lineage does not match the AgentRun.");
             }
             if (run.workspace.owner.purpose === "execution"
                 && run.workspace.owner.workItemId !== run.workItemId) {
-                throw new Error("Turn Execution Lane workspace WorkItem does not match the Turn.");
+                throw new Error("AgentRun Execution Lane workspace WorkItem does not match the AgentRun.");
             }
             if (run.workspace.owner.purpose === "review"
                 && run.workspace.owner.reviewRoundId !== run.reviewRoundId) {
-                throw new Error("Turn review Lane workspace ReviewRound does not match the Turn.");
+                throw new Error("AgentRun review Lane workspace ReviewRound does not match the AgentRun.");
             }
         }
         if (run.workspace.owner.type === "review-round"
             && run.workspace.owner.reviewRoundId !== run.reviewRoundId) {
-            throw new Error(`Turn ReviewRound workspace owner does not match ${run.reviewRoundId ?? "none"}.`);
+            throw new Error(`AgentRun ReviewRound workspace owner does not match ${run.reviewRoundId ?? "none"}.`);
         }
     }
     if (run.purpose === "review") {
         if (run.reviewRoundId === undefined) {
-            throw new Error("A review Turn requires a ReviewRound reference.");
+            throw new Error("A review AgentRun requires a ReviewRound reference.");
         }
         if (run.workspace === undefined
             || !((run.workspace.owner.type === "review-round"
@@ -198,86 +256,86 @@ export function validateTurn(run) {
                 || (run.workspace.owner.type === "execution-lane"
                     && run.workspace.owner.purpose === "review"
                     && run.workspace.owner.reviewRoundId === run.reviewRoundId))) {
-            throw new Error(`A review Turn requires its exact ReviewRound workspace owner: ${run.reviewRoundId}.`);
+            throw new Error(`A review AgentRun requires its exact ReviewRound workspace owner: ${run.reviewRoundId}.`);
         }
         if (run.workspace.entries.length === 0
             || run.workspace.entries.some(({ access }) => access !== "write")) {
-            throw new Error("A review Turn requires only isolated writable workspace entries.");
+            throw new Error("A review AgentRun requires only isolated writable workspace entries.");
         }
     }
     else {
         if (run.reviewRoundId !== undefined) {
-            throw new Error("An execution Turn cannot reference a ReviewRound.");
+            throw new Error("An execution AgentRun cannot reference a ReviewRound.");
         }
         if (run.workspace?.owner.type === "review-round") {
-            throw new Error("An execution Turn cannot use a ReviewRound-owned workspace.");
+            throw new Error("An execution AgentRun cannot use a ReviewRound-owned workspace.");
         }
         if (run.workspace?.owner.type === "execution-lane" && run.workspace.owner.purpose !== "execution") {
-            throw new Error("An execution Turn cannot use a review Lane workspace.");
+            throw new Error("An execution AgentRun cannot use a review Lane workspace.");
         }
     }
     validateEffectiveLaunchSnapshot(run.effective);
     if (run.workspace !== undefined
         && (run.effective.workspace.root !== run.workspace.root
             || JSON.stringify(run.effective.workspace.entries) !== JSON.stringify(run.workspace.entries))) {
-        throw new Error("Turn effective workspace does not match its managed workspace.");
+        throw new Error("AgentRun effective workspace does not match its managed workspace.");
     }
     if (run.purpose === "review") {
         if (run.effective.reviewRoundId !== run.reviewRoundId) {
-            throw new Error("Review Turn effective provenance does not match its ReviewRound.");
+            throw new Error("Review AgentRun effective provenance does not match its ReviewRound.");
         }
         if (!run.workspace.entries.some(({ baseCommit }) => baseCommit === run.effective.reviewBaseCommit)) {
-            throw new Error("Review Turn effective base does not match its workspace.");
+            throw new Error("Review AgentRun effective base does not match its workspace.");
         }
     }
     else if (run.effective.reviewRoundId !== undefined) {
-        throw new Error("Execution Turn cannot carry Review effective provenance.");
+        throw new Error("Execution AgentRun cannot carry Review effective provenance.");
     }
     for (const record of run.inputs) {
-        createTurnInputEnvelope(turnEnvelopeContext(run), record.input);
+        createRunInputEnvelope(runEnvelopeContext(run), record.input);
     }
     if (!["active", "completed", "failed"].includes(run.status)) {
-        throw new Error(`Turn status is invalid: ${String(run.status)}.`);
+        throw new Error(`AgentRun status is invalid: ${String(run.status)}.`);
     }
-    requireTimestamp(run.createdAt, "Turn createdAt");
-    requireTimestamp(run.updatedAt, "Turn updatedAt");
+    requireTimestamp(run.createdAt, "AgentRun createdAt");
+    requireTimestamp(run.updatedAt, "AgentRun updatedAt");
     if (run.status === "active") {
         if (run.result !== undefined)
-            throw new Error("An active Turn cannot have a result.");
+            throw new Error("An active AgentRun cannot have a result.");
     }
     else {
-        const result = validateTurnResult(run.result);
+        const result = validateRunResult(run.result);
         if (run.status === "failed") {
-            if (!isTurnFailureReason(result.failureReason)) {
-                throw new Error(`Failed Turn reason is invalid: ${String(result.failureReason)}.`);
+            if (!isRunFailureReason(result.failureReason)) {
+                throw new Error(`Failed AgentRun reason is invalid: ${String(result.failureReason)}.`);
             }
             if (result.diagnostic === undefined) {
-                throw new Error("A failed Turn requires a Core diagnostic.");
+                throw new Error("A failed AgentRun requires a Core diagnostic.");
             }
             if (result.systemEvidence !== undefined) {
-                throw new Error("A failed Turn cannot carry successful system evidence.");
+                throw new Error("A failed AgentRun cannot carry successful system evidence.");
             }
         }
         else {
             if (result.output === undefined) {
-                throw new Error("A completed Turn requires an Agent result.");
+                throw new Error("A completed AgentRun requires an Agent result.");
             }
             if (result.failureReason !== undefined || result.diagnostic !== undefined) {
-                throw new Error("A completed Turn cannot carry failure metadata.");
+                throw new Error("A completed AgentRun cannot carry failure metadata.");
             }
         }
     }
     return run;
 }
-export function completeTurn(run, output, now, provider, systemEvidence) {
-    return finishTurn(run, "completed", output, now, undefined, provider, systemEvidence);
+export function completeRun(run, output, now, provider, systemEvidence) {
+    return finishRun(run, "completed", output, now, undefined, provider, systemEvidence);
 }
-export function failTurn(run, reason, diagnostic, now, provider, output) {
-    return finishTurn(run, "failed", output, now, reason, provider, undefined, boundedTurnFailureDiagnostic(diagnostic));
+export function failRun(run, reason, diagnostic, now, provider, output) {
+    return finishRun(run, "failed", output, now, reason, provider, undefined, boundedRunFailureDiagnostic(diagnostic));
 }
-function finishTurn(run, status, output, now, failureReason, provider, systemEvidence, diagnostic) {
+function finishRun(run, status, output, now, failureReason, provider, systemEvidence, diagnostic) {
     if (run.status !== "active") {
-        throw new Error(`Turn is already terminal: ${run.id}.`);
+        throw new Error(`AgentRun is already terminal: ${run.id}.`);
     }
     const timestamp = now.toISOString();
     const terminal = {
@@ -285,24 +343,24 @@ function finishTurn(run, status, output, now, failureReason, provider, systemEvi
         status,
         result: {
             schemaVersion: 2,
-            ...(output === undefined ? {} : { output: requireResultText(output, "Turn result output") }),
+            ...(output === undefined ? {} : { output: requireResultText(output, "AgentRun result output") }),
             ...(diagnostic === undefined
                 ? {}
-                : { diagnostic: requireDiagnosticText(diagnostic, "Turn result diagnostic") }),
+                : { diagnostic: requireDiagnosticText(diagnostic, "AgentRun result diagnostic") }),
             completedAt: timestamp,
-            ...(provider === undefined ? {} : { provider: validateTurnProviderResult(provider) }),
+            ...(provider === undefined ? {} : { provider: validateRunProviderResult(provider) }),
             ...(systemEvidence === undefined
                 ? {}
-                : { systemEvidence: validateTurnSystemEvidence(systemEvidence) }),
+                : { systemEvidence: validateRunSystemEvidence(systemEvidence) }),
             ...(failureReason === undefined ? {} : { failureReason })
         },
         updatedAt: timestamp,
     };
-    return validateTurn(terminal);
+    return validateRun(terminal);
 }
-function validateTurnResult(result) {
+function validateRunResult(result) {
     if (result === undefined || result.schemaVersion !== 2) {
-        throw new Error("A terminal Turn requires TurnResult schemaVersion 2.");
+        throw new Error("A terminal AgentRun requires AgentRunResult schemaVersion 2.");
     }
     rejectUnknownFields(result, [
         "schemaVersion",
@@ -312,48 +370,47 @@ function validateTurnResult(result) {
         "provider",
         "systemEvidence",
         "failureReason"
-    ], "Turn result");
+    ], "AgentRun result");
     if (result.output !== undefined)
-        requireResultText(result.output, "Turn result output");
+        requireResultText(result.output, "AgentRun result output");
     if (result.diagnostic !== undefined) {
-        requireDiagnosticText(result.diagnostic, "Turn result diagnostic");
+        requireDiagnosticText(result.diagnostic, "AgentRun result diagnostic");
     }
-    requireTimestamp(result.completedAt, "Turn result completedAt");
+    requireTimestamp(result.completedAt, "AgentRun result completedAt");
     if (result.provider !== undefined)
-        validateTurnProviderResult(result.provider);
+        validateRunProviderResult(result.provider);
     if (result.systemEvidence !== undefined)
-        validateTurnSystemEvidence(result.systemEvidence);
+        validateRunSystemEvidence(result.systemEvidence);
     return result;
 }
-function validateTurnSystemEvidence(evidence) {
+function validateRunSystemEvidence(evidence) {
     rejectUnknownFields(evidence, [
         "workspaceSnapshot"
-    ], "Turn system evidence");
+    ], "AgentRun system evidence");
     if (evidence.workspaceSnapshot !== undefined) {
         const snapshot = evidence.workspaceSnapshot;
         if (snapshot.schemaVersion !== 1 || !Array.isArray(snapshot.projects)) {
-            throw new Error("Turn workspace snapshot is invalid.");
+            throw new Error("AgentRun workspace snapshot is invalid.");
         }
         const projectIds = new Set();
         for (const project of snapshot.projects) {
-            requireSafeIdentity(project.projectId, "Turn workspace snapshot Project id");
+            requireSafeIdentity(project.projectId, "AgentRun workspace snapshot Project id");
             if (projectIds.has(project.projectId)) {
-                throw new Error("Turn workspace snapshot Project ids must be unique.");
+                throw new Error("AgentRun workspace snapshot Project ids must be unique.");
             }
             projectIds.add(project.projectId);
             if (!/^[0-9a-f]{40}$/u.test(project.headCommit)) {
-                throw new Error("Turn workspace snapshot commit is invalid.");
+                throw new Error("AgentRun workspace snapshot commit is invalid.");
             }
-            requireText(project.branch, "Turn workspace snapshot branch");
+            requireText(project.branch, "AgentRun workspace snapshot branch");
         }
     }
     return evidence;
 }
-function validateTurnProviderResult(provider) {
+function validateRunProviderResult(provider) {
     requireText(provider.providerNamespace, "Provider namespace");
     requireText(provider.accountScope, "Provider account scope");
     requireText(provider.conversationId, "Provider Conversation id");
-    requireText(provider.activationId, "Provider Activation id");
     if (provider.nativeTurnId !== undefined)
         requireText(provider.nativeTurnId, "Provider native Turn id");
     if (provider.attemptId !== undefined)
@@ -362,21 +419,21 @@ function validateTurnProviderResult(provider) {
         throw new Error("Provider result requires a native Turn or exact attempt identity.");
     }
     if (!["completed", "failed", "cancelled"].includes(provider.status)) {
-        throw new Error(`Provider Turn result status is invalid: ${String(provider.status)}.`);
+        throw new Error(`Provider AgentRun result status is invalid: ${String(provider.status)}.`);
     }
     return provider;
 }
-function turnInputRecord(input, sequence, submittedAt) {
-    const normalized = validateTurnInput(input);
+function runInputRecord(input, sequence, submittedAt) {
+    const normalized = validateRunInput(input);
     return Object.freeze({
         sequence,
         submittedAt,
         input: normalized
     });
 }
-function turnEnvelopeContext(run) {
+function runEnvelopeContext(run) {
     return {
-        turnId: run.id,
+        runId: run.id,
         roleName: run.roleName,
         purpose: run.purpose,
         subject: {
@@ -415,8 +472,8 @@ function requireResultText(value, label) {
         throw new Error(`${label} is invalid.`);
     if (value.trim().length === 0)
         throw new Error(`${label} is required.`);
-    if (Buffer.byteLength(value, "utf8") > MAX_TURN_RESULT_OUTPUT_BYTES) {
-        throw new Error(`${label} exceeds ${MAX_TURN_RESULT_OUTPUT_BYTES} bytes.`);
+    if (Buffer.byteLength(value, "utf8") > MAX_RUN_RESULT_OUTPUT_BYTES) {
+        throw new Error(`${label} exceeds ${MAX_RUN_RESULT_OUTPUT_BYTES} bytes.`);
     }
     return value;
 }
@@ -425,8 +482,8 @@ function requireDiagnosticText(value, label) {
         throw new Error(`${label} is invalid.`);
     if (value.trim().length === 0)
         throw new Error(`${label} is required.`);
-    if (Buffer.byteLength(value, "utf8") > MAX_TURN_FAILURE_DIAGNOSTIC_BYTES) {
-        throw new Error(`${label} exceeds ${MAX_TURN_FAILURE_DIAGNOSTIC_BYTES} bytes.`);
+    if (Buffer.byteLength(value, "utf8") > MAX_RUN_FAILURE_DIAGNOSTIC_BYTES) {
+        throw new Error(`${label} exceeds ${MAX_RUN_FAILURE_DIAGNOSTIC_BYTES} bytes.`);
     }
     return value;
 }
@@ -435,7 +492,7 @@ function requireTimestamp(value, label) {
         throw new Error(`${label} must be an ISO timestamp.`);
     }
 }
-function isTurnFailureReason(value) {
+function isRunFailureReason(value) {
     return [
         "startup-failed",
         "runtime-failed",

package/dist/{turn/turnIdentity.js → agentRun/runIdentity.js}

@@ -1,22 +1,22 @@
 import { MAX_SESSION_TITLE_LENGTH } from "../runtime/sessionTitle.js";
 /**
  * Prefixes managed launch input with its session title. The bootstrap body
- * exposes the exact current Turn identity to the Agent, while structured
+ * exposes the exact current AgentRun identity to the Agent, while structured
  * delivery metadata and control hooks retain the delivery fence.
  */
 export function prefixYuiTitleInput(input, title) {
     const text = input.replace(/\r/g, "").trim();
     if (text.length === 0)
         throw new Error("Managed input body is required.");
-    return `${requireTurnTitle(title)}\n\n${text}`;
+    return `${requireRunTitle(title)}\n\n${text}`;
 }
-function requireTurnTitle(value) {
+function requireRunTitle(value) {
     const title = value.trim();
     if (title.length === 0
         || title.length > MAX_SESSION_TITLE_LENGTH
         || /[\r\n\0]/u.test(title)
         || !title.startsWith("Yui ")) {
-        throw new Error("Turn title is invalid.");
+        throw new Error("AgentRun title is invalid.");
     }
     return title;
 }

package/dist/brief/taskBrief.js

@@ -11,6 +11,7 @@ export function createTaskBrief(input, now) {
     };
 }
 export function updateTaskBrief(brief, patch, updatedBy, now) {
+    validateTaskBrief(brief);
     return createTaskBrief({
         objective: patch.objective ?? brief.objective,
         boundaries: patch.boundaries ?? brief.boundaries,
@@ -20,6 +21,17 @@ export function updateTaskBrief(brief, patch, updatedBy, now) {
         updatedBy
     }, now);
 }
+export function validateTaskBrief(brief) {
+    if (brief.schemaVersion !== 2) {
+        throw new Error("Task Brief requires schemaVersion 2.");
+    }
+    if (!Array.isArray(brief.boundaries) || typeof brief.technicalApproach !== "string"
+        || typeof brief.updatedAt !== "string" || !Number.isFinite(Date.parse(brief.updatedAt))) {
+        throw new Error("Task Brief content or timestamp is invalid.");
+    }
+    createTaskBrief(brief, new Date(brief.updatedAt));
+    return brief;
+}
 function normalizeBoundaries(values) {
     const normalized = values.map((value) => {
         if (typeof value !== "string" || value.includes("\0")) {

package/dist/cli/agentConfigurationPicker.js

@@ -78,6 +78,19 @@ export async function selectAgentPermission(resolved, io, current) {
     const mode = await selectPermissionField(resolved, io, "permission.mode", claude?.mode, claude === undefined ? undefined : OMIT);
     if (mode.kind === "cancelled")
         return mode;
+    // ACP's configured permission is exactly the mode, and its adapter requires
+    // one: the value is matched against what the Agent enumerates at launch, so
+    // there is no "configured with nothing set" to fall back to. Claude's remains
+    // optional because its other native options can carry the configuration
+    // instead.
+    if (resolved.catalog.adapterId === "acp") {
+        return mode.value === undefined
+            ? { kind: "cancelled" }
+            : {
+                kind: "selected",
+                permission: { strategy: "configured", mode: mode.value }
+            };
+    }
     const permission = {
         ...(claude ?? { strategy: "configured" })
     };