@zq-silk/yui 0.15.6 → 0.15.8

package/dist/executor/workspacePreflightClassification.js

@@ -20,7 +20,7 @@ function ownerLabel(owner) {
  * This is a read-only check: it never mutates Git state, creates Sessions, or
  * writes recovery records.
  */
-export function classifyWorkspacePreflight(store, task, roleName, activeTurn, inspectPhysical) {
+export function classifyWorkspacePreflight(store, task, roleName, activeRun, inspectPhysical) {
     const main = store.getTaskWorkspace(task.id);
     const bindings = task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory }));
     // 1. Owner validation: the Task main workspace must be a durable,
@@ -41,26 +41,26 @@ export function classifyWorkspacePreflight(store, task, roleName, activeTurn, in
             actual
         };
     }
-    // 2. Turn snapshot validation: when the active Turn carries a workspace
+    // 2. AgentRun snapshot validation: when the active AgentRun carries a workspace
     //    snapshot its launch-stable identity must match the durable
     //    ManagedWorkspace. Audit timestamps may change without changing the
-    //    owner, root, or Project entries authorized for the Turn.
-    if (activeTurn?.workspace !== undefined) {
-        const durableRunWorkspace = store.getManagedWorkspace(activeTurn.workspace.owner);
+    //    owner, root, or Project entries authorized for the AgentRun.
+    if (activeRun?.workspace !== undefined) {
+        const durableRunWorkspace = store.getManagedWorkspace(activeRun.workspace.owner);
         if (durableRunWorkspace === null
-            || !sameManagedWorkspaceIdentity(durableRunWorkspace, activeTurn.workspace)) {
+            || !sameManagedWorkspaceIdentity(durableRunWorkspace, activeRun.workspace)) {
             const diff = [];
             if (durableRunWorkspace === null) {
-                diff.push(`durable ManagedWorkspace for owner ${JSON.stringify(activeTurn.workspace.owner)} is missing`);
+                diff.push(`durable ManagedWorkspace for owner ${JSON.stringify(activeRun.workspace.owner)} is missing`);
             }
             else {
-                if (durableRunWorkspace.root !== activeTurn.workspace.root) {
-                    diff.push(`root: durable=${durableRunWorkspace.root} run=${activeTurn.workspace.root}`);
+                if (durableRunWorkspace.root !== activeRun.workspace.root) {
+                    diff.push(`root: durable=${durableRunWorkspace.root} run=${activeRun.workspace.root}`);
                 }
-                if (durableRunWorkspace.entries.length !== activeTurn.workspace.entries.length) {
-                    diff.push(`entries: durable=${durableRunWorkspace.entries.length} run=${activeTurn.workspace.entries.length}`);
+                if (durableRunWorkspace.entries.length !== activeRun.workspace.entries.length) {
+                    diff.push(`entries: durable=${durableRunWorkspace.entries.length} run=${activeRun.workspace.entries.length}`);
                 }
-                for (const [index, entry] of activeTurn.workspace.entries.entries()) {
+                for (const [index, entry] of activeRun.workspace.entries.entries()) {
                     const durableEntry = durableRunWorkspace.entries[index];
                     if (durableEntry === undefined) {
                         diff.push(`entry[${index}] ${entry.projectId}: missing from durable`);
@@ -76,10 +76,10 @@ export function classifyWorkspacePreflight(store, task, roleName, activeTurn, in
             }
             return {
                 kind: "workspace-stale",
-                reason: `Role Turn workspace is not the durable owner: ${task.id}/${roleName}.`,
+                reason: `Role AgentRun workspace is not the durable owner: ${task.id}/${roleName}.`,
                 taskId: task.id,
                 roleName,
-                turnId: activeTurn.id,
+                runId: activeRun.id,
                 diff
             };
         }
@@ -89,7 +89,7 @@ export function classifyWorkspacePreflight(store, task, roleName, activeTurn, in
     // from that immutable boundary. A reset/repoint outside the lineage is
     // physical drift and must fail before Provider launch.
     if (inspectPhysical !== undefined) {
-        const effective = activeTurn?.workspace ?? main;
+        const effective = activeRun?.workspace ?? main;
         for (const entry of effective.entries) {
             const physical = inspectPhysical(entry);
             if (!physical.recordedBaseIsAncestor) {
@@ -121,7 +121,7 @@ export function formatWorkspacePreflightError(classification) {
                 + "` to inspect the binding, ManagedWorkspace, and physical HEAD.");
             break;
         case "workspace-stale":
-            lines.push(`  Turn ${classification.turnId} snapshot differs from the durable ManagedWorkspace:`);
+            lines.push(`  AgentRun ${classification.runId} snapshot differs from the durable ManagedWorkspace:`);
             for (const entry of classification.diff) {
                 lines.push(`    - ${entry}`);
             }

package/dist/grant/capabilityGrant.js

@@ -68,8 +68,8 @@ export function grantUseReservations(grant) {
 }
 /**
  * Record one use against the grant, failing closed once the limit is reached.
- * The reservation key is appended to the grant's durable reservations so a
- * later resume recognizes this exact attempt and avoids a double charge.
+ * Supply a reservation key when a later resume must recognize the attempt.
+ * Non-resumable calls only advance the counter; historical keys stay intact.
  */
 export function recordGrantUse(grant, now, reservationKey) {
     validateCapabilityGrant(grant);
@@ -79,7 +79,10 @@ export function recordGrantUse(grant, now, reservationKey) {
     return validateCapabilityGrant({
         ...grant,
         usesUsed: grant.usesUsed + 1,
-        useReservations: Object.freeze([...grantUseReservations(grant), reservationKey]),
+        useReservations: Object.freeze([
+            ...grantUseReservations(grant),
+            ...(reservationKey === undefined ? [] : [reservationKey])
+        ]),
         updatedAt: now.toISOString()
     });
 }

package/dist/input/inputRequest.js

@@ -89,12 +89,11 @@ export function validateInputRequest(value) {
         updatedAt: requireTimestamp(request.updatedAt, "Input request updatedAt")
     };
     validateTaskRecordReference({ taskId: base.taskId, localId: base.id }, "inputRequest");
-    validateTaskRecordReference({
-        taskId: base.requester.taskId,
-        localId: base.requester.turnId
-    }, "turn");
+    if (base.requester.runId !== undefined) {
+        validateTaskRecordReference({ taskId: base.requester.taskId, localId: base.requester.runId }, "run");
+    }
     for (const reference of base.blockedRefs) {
-        validateTaskRecordReference({ taskId: reference.taskId, localId: reference.id }, reference.type === "turn" ? "turn" : "workItem");
+        validateTaskRecordReference({ taskId: reference.taskId, localId: reference.id }, reference.type === "run" ? "run" : "workItem");
     }
     if (base.requester.taskId !== base.taskId
         || base.blockedRefs.some(({ taskId }) => taskId !== base.taskId)) {
@@ -175,7 +174,7 @@ function normalizeBlockedRefs(value) {
     const references = value.map((reference) => {
         const item = record(reference, "Input blocked reference");
         exact(item, ["type", "taskId", "id"], "Input blocked reference");
-        if (item.type !== "work-item" && item.type !== "turn") {
+        if (item.type !== "work-item" && item.type !== "run") {
             throw new Error("Input blocked reference type must be work-item or turn.");
         }
         return {
@@ -223,16 +222,19 @@ function validateBlockedRefs(value) {
 }
 function normalizeRequester(value) {
     const requester = record(value, "Input requester");
-    exact(requester, requester.nativeSessionId === undefined
-        ? ["taskId", "roleName", "agentId", "turnId"]
-        : ["taskId", "roleName", "agentId", "turnId", "nativeSessionId"], "Input requester");
+    exact(requester, ["taskId", "roleName", "agentId",
+        ...(requester.runId === undefined ? [] : ["runId"]),
+        ...(requester.nativeSessionId === undefined ? [] : ["nativeSessionId"])], "Input requester");
     if (requester.roleName !== "leader")
         throw new Error("Input requester must be the Task Leader.");
+    if (requester.runId === undefined && requester.nativeSessionId === undefined) {
+        throw new Error("Input requester requires an originating Run or native Session.");
+    }
     return {
         taskId: requireIdentity(requester.taskId, "Input requester Task id"),
         roleName: "leader",
         agentId: requireIdentity(requester.agentId, "Input requester Agent id"),
-        turnId: requireIdentity(requester.turnId, "Input requester Turn id"),
+        ...(requester.runId === undefined ? {} : { runId: requireIdentity(requester.runId, "Input requester AgentRun id") }),
         ...(requester.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireIdentity(requester.nativeSessionId, "Input requester native session id") })

package/dist/integration/gitIntegrationService.js

@@ -549,8 +549,6 @@ export class GitIntegrationService {
     #runtimePreparation(attempt, workspace) {
         return this.runtimeIsolation.preflight({
             workspace,
-            runtimeGenerationId: integrationRuntimeRuntimeGenerationId(this.home, attempt.id),
-            generationId: "integration-checks",
             allowExactActive: true
         });
     }
@@ -1083,7 +1081,7 @@ function isNodeCode(error, code) {
 function defaultIntegrationRuntimeIsolation(home, homeId) {
     const controlHome = resolve(home);
     return new FileTaskRuntimeIsolation({
-        runtimeRoot: integrationRuntimeRoot(),
+        runtimeRoot: integrationRuntimeRoot(controlHome),
         pathLayout: "compact",
         controlPlane: {
             yuiHome: controlHome,
@@ -1093,15 +1091,10 @@ function defaultIntegrationRuntimeIsolation(home, homeId) {
         }
     });
 }
-function integrationRuntimeRoot() {
+function integrationRuntimeRoot(home) {
     const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-    return join("/tmp", `yi-${uid.toString(36)}`);
-}
-function integrationRuntimeRuntimeGenerationId(home, integrationId) {
-    const homeDigest = createHash("sha256")
-        .update(resolve(home))
-        .digest("hex");
-    return `${integrationId}-${homeDigest}`;
+    const homeDigest = createHash("sha256").update(resolve(home)).digest("hex").slice(0, 16);
+    return join("/tmp", `yi-${uid.toString(36)}-${homeDigest}`);
 }
 /**
  * Reuse is enabled only for an immutable installed release. Development

package/dist/integration/integrationQueueService.js

@@ -3,6 +3,7 @@ import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 import { createIntegrationAttempt, recordResolutionDecision, updateIntegrationAttempt } from "./integrationAttempt.js";
 import { createConvergedIntegrationQueueEntry, createIntegrationQueueEntry, markIntegrationQueueBlocked, markIntegrationQueueCommitted, markIntegrationQueueRequeued, markIntegrationQueueRunning, markIntegrationQueueSuperseded, recordIntegrationQueueAffectedPaths, recordIntegrationQueueAttempt } from "./integrationQueueEntry.js";
 import { GitIntegrationService } from "./gitIntegrationService.js";
+import { governingWorkItemCandidate } from "../workItem/workItem.js";
 /**
  * Producer WorkItem statuses that close the WorkItem lifecycle.  A ChangeSet
  * captured from a WorkItem that reached one of these without ever producing a
@@ -11,8 +12,7 @@ import { GitIntegrationService } from "./gitIntegrationService.js";
  * Candidate.
  */
 const TERMINAL_PRODUCER_STATUSES = new Set([
-    "completed",
-    "failed",
+    "accepted",
     "retired"
 ]);
 /**
@@ -59,11 +59,11 @@ function assertCurrentCandidateInStore(store, taskId, changeSet) {
         throw new Error(`ChangeSet producer WorkItem not found: ${changeSet.workItemId}.`);
     }
     // A running WorkItem has no current Candidate: a new one is expected.
-    if (workItem.status === "running") {
+    if (workItem.status === "open" && workItem.currentCandidateId === undefined) {
         throw new Error(`ChangeSet ${changeSet.id} has no current Candidate: `
             + `WorkItem ${workItem.id} is running.`);
     }
-    const latestCandidate = workItem.candidates.at(-1);
+    const latestCandidate = governingWorkItemCandidate(workItem);
     if (latestCandidate !== undefined) {
         const snapshotHead = candidateHeadCommit(latestCandidate, changeSet.projectId);
         if (snapshotHead !== undefined && snapshotHead !== changeSet.headCommit) {

package/dist/interaction/operatorPresentation.js

@@ -34,7 +34,7 @@ function eventLabel(event) {
         case "task.completed": return "Task completed";
         case "task.retired": return "Task retired";
         case "leader.attention-required": return "Task Leader needs attention";
-        case "turn.stalled": return "Task Leader stalled";
+        case "run.stalled": return "Task Leader stalled";
         default: return `Task event ${event.type}`;
     }
 }