@zq-silk/yui 0.15.6 → 0.15.8

package/dist/repository/taskBaseFreshness.js

@@ -61,10 +61,10 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
     const task = requireTask(store, taskId);
     const git = options.git ?? newGitWorkspace();
     const workspace = store.getTaskWorkspace(taskId);
-    // Collect active Turn workspace snapshots once so every Project entry can
-    // report whether a live Turn is pinned to a different commit.
-    const activeTurns = store.listTurns(taskId)
-        .filter((turn) => turn.status === "active" && turn.workspace !== undefined);
+    // Collect active AgentRun workspace snapshots once so every Project entry can
+    // report whether a live AgentRun is pinned to a different commit.
+    const activeRuns = store.listRuns(taskId)
+        .filter((run) => run.status === "active" && run.workspace !== undefined);
     const entries = await Promise.all(task.projectBindings.map(async (binding) => {
         const project = requireProject(store, binding.projectId);
         const entry = workspace === null ? undefined : workspaceProjectEntry(workspace, project.id);
@@ -77,12 +77,12 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
         catch {
             physicalHead = undefined;
         }
-        // Find the first active Turn whose workspace snapshot covers this Project.
-        const turnSnapshot = activeTurns.find((turn) => {
-            if (turn.workspace === undefined)
+        // Find the first active AgentRun whose workspace snapshot covers this Project.
+        const runSnapshot = activeRuns.find((run) => {
+            if (run.workspace === undefined)
                 return false;
-            const turnEntry = workspaceProjectEntry(turn.workspace, project.id);
-            return turnEntry !== undefined;
+            const runEntry = workspaceProjectEntry(run.workspace, project.id);
+            return runEntry !== undefined;
         });
         const provenance = latestBaseProvenance(store.listEvents(taskId), project.id);
         const tracked = await resolveTracked(git, project, workspacePath, options.refresh === true);
@@ -99,11 +99,11 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
             workspacePath,
             workspaceClean,
             ...(physicalHead === undefined ? {} : { physicalHead }),
-            ...(turnSnapshot?.workspace === undefined
+            ...(runSnapshot?.workspace === undefined
                 ? {}
                 : {
-                    turnSnapshotCommit: workspaceProjectEntry(turnSnapshot.workspace, project.id)?.baseCommit,
-                    turnSnapshotId: turnSnapshot.id
+                    runSnapshotCommit: workspaceProjectEntry(runSnapshot.workspace, project.id)?.baseCommit,
+                    runSnapshotId: runSnapshot.id
                 }),
             ...(tracked === undefined ? {} : {
                 trackedRef: tracked.ref,
@@ -161,7 +161,7 @@ export function renderTaskBaseFreshnessReport(report) {
         `Task base freshness: ${report.taskId} (source: ${report.refreshed ? "remote refresh" : "local tracking"})`
     ];
     for (const entry of report.entries) {
-        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  physical HEAD: ${entry.physicalHead ?? "-"}`, `  Turn snapshot: ${entry.turnSnapshotCommit ?? "-"}${entry.turnSnapshotId === undefined ? "" : ` (${entry.turnSnapshotId})`}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
+        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  physical HEAD: ${entry.physicalHead ?? "-"}`, `  AgentRun snapshot: ${entry.runSnapshotCommit ?? "-"}${entry.runSnapshotId === undefined ? "" : ` (${entry.runSnapshotId})`}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
         if (entry.risk !== undefined)
             lines.push(`  risk: ${entry.risk}`);
         if (entry.error !== undefined)

package/dist/repository/taskWorkspaceCoordinator.js

@@ -1,5 +1,4 @@
 import { isDeepStrictEqual } from "node:util";
-import { retireConfirmedAbsentInactiveTaskRolePlaceholders } from "../executor/agentExecutor.js";
 import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "./projectMaintenanceLock.js";
@@ -23,10 +22,10 @@ export class TaskWorkspaceCoordinator {
         if (item === null)
             throw new Error(`Work item not found: ${taskId}/${workItemId}.`);
         const assignee = this.#workItemIsolationAssignee(item);
-        const activeDevelopTurn = this.store.listTurns(item.taskId)
+        const activeDevelopRun = this.store.listRuns(item.taskId)
             .find((run) => run.status === "active" && run.workItemId === item.id);
-        if (activeDevelopTurn !== undefined) {
-            throw new Error(`Work Item already has an active Develop Turn: ${activeDevelopTurn.id}.`);
+        if (activeDevelopRun !== undefined) {
+            throw new Error(`Work Item already has an active Develop AgentRun: ${activeDevelopRun.id}.`);
         }
         const task = this.store.getTask(item.taskId);
         const taskProjectIds = task.projectBindings.map(({ projectId }) => projectId);
@@ -155,7 +154,7 @@ export class TaskWorkspaceCoordinator {
             const task = this.store.getTask(taskId);
             if (task === null)
                 throw new Error(`Task not found: ${taskId}.`);
-            if (task.status !== "completed" && task.status !== "retired") {
+            if (task.status !== "completed" && task.status !== "cancelled") {
                 throw new Error(`Task must be completed or retired before archive cleanup: ${task.id}.`);
             }
             const managedWorkspaces = [...this.store.listManagedWorkspaces(task.id)]
@@ -181,7 +180,7 @@ export class TaskWorkspaceCoordinator {
                 const item = this.store.getWorkItem(task.id, workItemId);
                 if (item === null)
                     throw new Error(`Work item not found: ${task.id}/${workItemId}.`);
-                if (item.status !== "completed" && item.status !== "retired") {
+                if (item.status !== "accepted" && item.status !== "retired") {
                     throw new Error(`Work item must be completed or retired before archive cleanup: ${item.id}.`);
                 }
                 return item;
@@ -276,9 +275,9 @@ export class TaskWorkspaceCoordinator {
                 };
             }
             const activeRole = this.store.listRoles(taskId)
-                .find((role) => this.store.getActiveTurn(taskId, role.name) !== null);
+                .find((role) => this.store.getActiveRun(taskId, role.name) !== null);
             if (activeRole !== undefined) {
-                throw new WorkspaceCleanupBlockedError("active-turn", `role:${task.id}/${activeRole.name}`, true, `Task Role still has an active Turn: ${task.id}/${activeRole.name}.`);
+                throw new WorkspaceCleanupBlockedError("active-turn", `role:${task.id}/${activeRole.name}`, true, `Task Role still has an active AgentRun: ${task.id}/${activeRole.name}.`);
             }
             const roleNames = this.store.listRoles(taskId).map(({ name }) => name);
             await this.#stopLiveRoles(taskId, roleNames);
@@ -302,7 +301,7 @@ export class TaskWorkspaceCoordinator {
             }
             for (const item of workItems) {
                 this.#assertTaskArchiveLifecycle(task);
-                await this.preparer.cleanupWorkItemWorkspace(task.id, item.id, item.status === "completed" ? disposition : "abandoned");
+                await this.preparer.cleanupWorkItemWorkspace(task.id, item.id, item.status === "accepted" ? disposition : "abandoned");
             }
             this.#assertTaskArchiveLifecycle(task);
             return this.preparer.cleanupTaskForArchive(taskId);
@@ -353,10 +352,10 @@ export class TaskWorkspaceCoordinator {
         }
     }
     #assertWorkItemRuntimeQuiescent(item) {
-        const activeTurn = this.store.listTurns(item.taskId)
+        const activeRun = this.store.listRuns(item.taskId)
             .find((run) => run.status === "active" && run.workItemId === item.id);
-        if (activeTurn !== undefined) {
-            throw new WorkspaceCleanupBlockedError("active-turn", `work-item:${item.taskId}/${item.id}`, true, `Work item still has an active Turn: ${item.taskId}/${item.id}.`);
+        if (activeRun !== undefined) {
+            throw new WorkspaceCleanupBlockedError("active-turn", `work-item:${item.taskId}/${item.id}`, true, `Work item still has an active AgentRun: ${item.taskId}/${item.id}.`);
         }
     }
     /**
@@ -396,10 +395,10 @@ export class TaskWorkspaceCoordinator {
     }
     async #stopLiveRoles(taskId, roleNames) {
         const targets = [...new Set(roleNames)];
-        const getActiveTurn = this.store.getActiveTurn?.bind(this.store);
+        const getActiveRun = this.store.getActiveRun?.bind(this.store);
         for (const roleName of targets) {
-            if (getActiveTurn !== undefined && getActiveTurn(taskId, roleName) !== null) {
-                throw new Error(`Role has an active Turn: ${taskId}/${roleName}.`);
+            if (getActiveRun !== undefined && getActiveRun(taskId, roleName) !== null) {
+                throw new Error(`Role has an active AgentRun: ${taskId}/${roleName}.`);
             }
             if (this.store.getWorkMailbox !== undefined && hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget({ scope: "task", taskId, roleName })))) {
                 throw new Error(`Role has unsettled runtime lifecycle state: ${taskId}/${roleName}.`);
@@ -421,7 +420,7 @@ export class TaskWorkspaceCoordinator {
         // The aggregate-16 dormant Claude placeholder is the sole exception to
         // strict workspace-session retirement. The synchronous pane inspection is
         // performed while holding the Task store transaction so a normal launch
-        // cannot reserve a Turn/Session between absence proof and terminalization.
+        // cannot reserve a AgentRun/Session between absence proof and terminalization.
         if (inspect === undefined || this.store.transaction === undefined)
             return;
         this.store.transaction((tx) => {
@@ -430,18 +429,12 @@ export class TaskWorkspaceCoordinator {
                 if (panes.some((pane) => pane.roleName === roleName && !pane.dead)) {
                     throw new Error(`Task Role native pane must stop before workspace migration: ${roleName}.`);
                 }
-                if (tx.getActiveTurn(taskId, roleName) !== null) {
-                    throw new Error(`Role has an active Turn: ${taskId}/${roleName}.`);
+                if (tx.getActiveRun(taskId, roleName) !== null) {
+                    throw new Error(`Role has an active AgentRun: ${taskId}/${roleName}.`);
                 }
                 if (tx.getWorkMailbox !== undefined && hasRuntimeLifecycleWork(tx.getWorkMailbox(runtimeLifecycleTarget({ scope: "task", taskId, roleName })))) {
                     throw new Error(`Role has unsettled runtime lifecycle state: ${taskId}/${roleName}.`);
                 }
-                const sessions = tx.getTaskRoleSessionSet(taskId, roleName);
-                if (sessions === null)
-                    continue;
-                const retired = retireConfirmedAbsentInactiveTaskRolePlaceholders(sessions, this.preparer.now());
-                if (retired !== sessions)
-                    tx.saveTaskRoleSessionSet(retired);
             }
         });
     }
@@ -460,8 +453,8 @@ export class TaskWorkspaceCoordinator {
         if (isTerminalWorkItem(item)) {
             throw new Error(`Work item is already terminal: ${item.id}.`);
         }
-        if (item.assignee !== undefined && this.store.getActiveTurn(task.id, item.assignee) !== null) {
-            throw new Error(`Role has an active Turn: ${task.id}/${item.assignee}.`);
+        if (item.assignee !== undefined && this.store.getActiveRun(task.id, item.assignee) !== null) {
+            throw new Error(`Role has an active AgentRun: ${task.id}/${item.assignee}.`);
         }
         if (item.assignee !== undefined && this.store.getRole(task.id, item.assignee) === null) {
             throw new Error(`Role not found: ${task.id}/${item.assignee}.`);
@@ -483,5 +476,5 @@ function sameProjectScope(workspace, taskProjectIds, writeProjectIds) {
         && actual.every((projectId, index) => projectId === expected[index]);
 }
 function isTerminalWorkItem(item) {
-    return ["completed", "failed", "retired"].includes(item.status);
+    return ["accepted", "retired"].includes(item.status);
 }