@zq-silk/yui 0.15.7 → 0.15.8

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);
 }