@akira-tl/forgerelay 0.7.4 → 0.8.1

package/docs/roadmap.md

@@ -284,6 +284,34 @@ Git state, processes, Hooks, Skills, Language services, Activity, and Audit fact
 Workspace Relay is not file synchronization or failover, and Composite Workspace
 never silently chooses a member.
 
+## 0.8 — Persistent Workspace lifecycle and Task Lists
+
+0.8 turns Workspace identity from a disposable logical handle into a persistent
+ForgeRelay work boundary, then layers lightweight Workspace-owned Task Lists and
+safe cross-Workspace inspection on top. Development is release-gated: each stage
+must be published successfully before work begins on the next stage.
+
+- **0.8.0** — fix Composite bootstrap correctness and establish one canonical,
+  persistent Workspace identity per physical checkout/worktree target, including
+  migration compatibility for legacy aliases;
+- **0.8.1** — make checkout close non-destructive and reversible, add explicit
+  Workspace deletion, and prevent GC from deleting persistent Workspace identity;
+- **0.8.2** — carry the persistent lifecycle through managed worktrees and Composite
+  Workspaces, preserving state across close/reopen while keeping safe worktree
+  finalize semantics;
+- **0.8.3** — add versioned file-backed Task Lists in ForgeRelay-owned Workspace
+  state, with mutations scoped to the current Workspace;
+- **0.8.4** — add progressive Task disclosure, forgotten-update reminders, and
+  allowlist-based read-only inspection of other Workspaces and their safe Task
+  projections;
+- **0.8.5** — verify the complete contract across Workspace Relay and publish the
+  accepted 0.8 lifecycle/Task model.
+
+The release boundary is part of the dependency graph, not just a documentation
+milestone: the next stage remains blocked until the previous version's tag-triggered
+release workflow has completed successfully. Runtime acceptance uses only the
+reserved 7677/7678 debug instances and never touches the normal 7676 installation.
+
 ## Later: first-class subagent MCP
 
 ForgeRelay already owns provider adapters and resumable local agent sessions. A
@@ -311,20 +339,20 @@ are ready:
 Checkpoint restore must protect concurrent/external user edits rather than
 blindly overwriting a working tree.
 
-## Later: task orchestration
+## Workspace Task Lists
 
-After first-class subagents are stable, ForgeRelay may add a small persistent
-task graph for parent/worker coordination:
+ForgeRelay may provide persistent, lightweight Task Lists owned by a Workspace for
+work that should survive Host Turns, conversation changes, and Workspace close.
+Task is a checklist/continuation primitive rather than an execution scheduler:
 
-- task identity/title/status;
-- dependencies;
-- assigned local-agent session;
-- workspace/worktree association;
-- structured result/error state.
+- one Workspace may own multiple named Task Lists;
+- a Task records a work requirement, lightweight progress state, and Agent-managed continuation text;
+- Task does not imply a Queue, Goal object, dependency graph, Subagent assignment, Run binding, or autonomous execution policy;
+- current-Workspace Task state may be mutated through a Capability, while information about another Workspace, including Task projections, is exposed only through the read-only Workspace inspection path;
+- Task state is durable Workspace-owned local state and is not deleted by ordinary Workspace close or GC.
 
-Start with DAG-style parent/child orchestration. Peer-to-peer agent-team messaging
-should only be added if real workflows demonstrate that the simpler task model is
-insufficient.
+Subagent coordination can reference Task content when useful, but ForgeRelay does
+not bind Tasks to Subagent Sessions or infer Task completion from execution facts.
 
 ## Compatibility policy
 

package/docs/security.md

@@ -144,10 +144,10 @@ process lifetime. When `bash` is still running after that window, ForgeRelay
 returns a canonical `processId` and leaves the process alive. Regular tool modes
 reuse `bash(action="process")` to poll, wait, write input, resize a PTY, or
 explicitly interrupt that process. An asynchronously completed process
-is reported on a later tool result for the same logical workspace ID, including
-error-result paths, and is never broadcast to another workspace ID. Explicitly
-resuming the same workspace ID in another conversation intentionally transfers
-that completion scope as well. Hook handlers keep their separate bounded timeout
+is reported on a later tool result for the same persistent Workspace ID, including
+error-result paths, and is never broadcast to another Workspace ID. Reusing that
+Workspace from another conversation intentionally shares the same completion scope
+as well. Hook handlers keep their separate bounded timeout
 policy because they are lifecycle gates rather than user-command execution.
 
 ## Lifecycle hooks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.7.4",
+  "version": "0.8.1",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",

package/scripts/debug/accept.mjs

@@ -32,6 +32,7 @@ const stateDir = resolve(acceptanceRoot, "state");
 const worktreeRoot = resolve(acceptanceRoot, "worktrees");
 const hookLog = resolve(acceptanceRoot, "hooks.jsonl");
 const checkoutWorkspace = resolve(acceptanceRoot, "workspace");
+const lifecycleDeleteWorkspace = resolve(acceptanceRoot, "delete-workspace");
 const codeIntelligenceLog = resolve(acceptanceRoot, "code-intelligence-lsp.jsonl");
 const fakeLanguageServer = resolve(repoRoot, "src", "lsp", "test-fixtures", "fake-lsp-server.mjs");
 const gitProject = resolve(acceptanceRoot, "git-project");
@@ -45,6 +46,8 @@ await assertDebugPortFree();
 rmSync(acceptanceRoot, { recursive: true, force: true });
 mkdirSync(acceptanceRoot, { recursive: true });
 setupGitProject(checkoutWorkspace);
+setupGitProject(lifecycleDeleteWorkspace);
+writeFileSync(join(lifecycleDeleteWorkspace, "keep.txt"), "keep checkout files\n");
 setupCodeIntelligenceAcceptanceProject({
   root: checkoutWorkspace,
   fakeLanguageServer,
@@ -279,42 +282,52 @@ try {
   assert.equal(capabilityCatalog[0].available, true);
   assert.equal(capabilityCatalog[0].guide.name, "lifecycle-hooks");
 
-  const freshLogical = callTool(oauth.accessToken, sessionId, 84, "open_workspace", {
+  const repeatedOpen = callTool(oauth.accessToken, sessionId, 84, "open_workspace", {
     path: checkoutWorkspace,
     newWorkspace: true,
   }, workspaceConversationMeta);
-  const freshLogicalId = freshLogical.structuredContent.workspaceId;
-  assert.notEqual(freshLogicalId, workspaceId);
-  assert.equal(freshLogical.structuredContent.action, "open");
+  assert.equal(repeatedOpen.structuredContent.workspaceId, workspaceId);
+  assert.equal(repeatedOpen.structuredContent.action, "open");
   assert.equal(
-    freshLogical.structuredContent.contextFingerprint,
+    repeatedOpen.structuredContent.contextFingerprint,
     opened.structuredContent.contextFingerprint,
   );
-  assert.equal(freshLogical.structuredContent.agentsFiles, undefined);
-  assert.equal(freshLogical.structuredContent.capabilityGuides, undefined);
+  assert.equal(repeatedOpen.structuredContent.agentsFiles, undefined);
+  assert.equal(repeatedOpen.structuredContent.capabilityGuides, undefined);
 
   const workspaceInventory = callTool(oauth.accessToken, sessionId, 85, "open_workspace", {
     action: "list",
     root: checkoutWorkspace,
   }, workspaceConversationMeta);
   assert.equal(workspaceInventory.structuredContent.action, "list");
-  assert.equal(workspaceInventory.structuredContent.summary.matching, 2);
+  assert.equal(workspaceInventory.structuredContent.summary.matching, 1);
   const inventoryEntries = workspaceInventory.structuredContent.workspaces;
-  assert.equal(inventoryEntries.length, 2);
-  assert.equal(
-    inventoryEntries.find((entry) => entry.workspaceId === freshLogicalId)?.current,
-    true,
-  );
-  assert.equal(
-    inventoryEntries.find((entry) => entry.workspaceId === workspaceId)?.current,
-    false,
-  );
+  assert.equal(inventoryEntries.length, 1);
+  assert.equal(inventoryEntries[0].workspaceId, workspaceId);
+  assert.equal(inventoryEntries[0].current, true);
+
+  const closedWorkspace = callTool(oauth.accessToken, sessionId, 86, "close_workspace", {
+    workspaceId,
+  });
+  assert.equal(closedWorkspace.isError, undefined);
+  assert.equal(closedWorkspace.structuredContent.workspaceId, workspaceId);
+  assert.equal(closedWorkspace.structuredContent.action, "close");
+
+  const closedInventory = callTool(oauth.accessToken, sessionId, 87, "open_workspace", {
+    action: "list",
+    workspaceId,
+  }, workspaceConversationMeta);
+  assert.equal(closedInventory.structuredContent.workspaces.length, 1);
+  assert.equal(closedInventory.structuredContent.workspaces[0].state, "closed");
+  assert.equal(closedInventory.structuredContent.workspaces[0].current, false);
 
-  const closedFreshLogical = callTool(oauth.accessToken, sessionId, 86, "close_workspace", {
-    workspaceId: freshLogicalId,
+  const closedRead = callTool(oauth.accessToken, sessionId, 89, "read", {
+    workspaceId,
+    path: "AGENTS.md",
   });
-  assert.equal(closedFreshLogical.isError, undefined);
-  const resumedOriginal = callTool(oauth.accessToken, sessionId, 87, "open_workspace", {
+  assert.equal(closedRead.isError, true);
+
+  const resumedOriginal = callTool(oauth.accessToken, sessionId, 90, "open_workspace", {
     workspaceId,
   }, workspaceConversationMeta);
   assert.equal(resumedOriginal.structuredContent.workspaceId, workspaceId);
@@ -323,9 +336,33 @@ try {
     resumedOriginal.structuredContent.contextFingerprint,
     opened.structuredContent.contextFingerprint,
   );
+
+  const deleteOpened = callTool(oauth.accessToken, sessionId, 91, "open_workspace", {
+    path: lifecycleDeleteWorkspace,
+    context: "none",
+  }, { "openai/session": "acceptance-workspace-delete" });
+  const deleteWorkspaceId = deleteOpened.structuredContent.workspaceId;
+  const deleteClosed = callTool(oauth.accessToken, sessionId, 92, "close_workspace", {
+    workspaceId: deleteWorkspaceId,
+  });
+  assert.equal(deleteClosed.structuredContent.action, "close");
+  const deletedWorkspace = callTool(oauth.accessToken, sessionId, 93, "close_workspace", {
+    workspaceId: deleteWorkspaceId,
+    action: "delete",
+  });
+  assert.equal(deletedWorkspace.isError, undefined);
+  assert.equal(deletedWorkspace.structuredContent.workspaceId, deleteWorkspaceId);
+  assert.equal(deletedWorkspace.structuredContent.action, "delete");
+  assert.equal(readFileSync(join(lifecycleDeleteWorkspace, "keep.txt"), "utf8"), "keep checkout files\n");
+  const deletedInventory = callTool(oauth.accessToken, sessionId, 94, "open_workspace", {
+    action: "list",
+    workspaceId: deleteWorkspaceId,
+  });
+  assert.equal(deletedInventory.structuredContent.workspaces.length, 0);
+
   pass(
-    "workspace context + inventory",
-    `${workspaceId} -> ${freshLogicalId} -> list -> close -> resume without bootstrap replay`,
+    "workspace lifecycle + inventory",
+    `${workspaceId} canonical reuse -> close -> list -> reopen; explicit delete preserves checkout files`,
   );
 
   const directCapability = callTool(oauth.accessToken, sessionId, 79, "capability", {
@@ -972,13 +1009,14 @@ function exerciseReleaseTagHooks(accessToken, sessionId) {
 
 function exerciseSubagentHooks(runtimeEnv, debugStateDir, workspaceId, workspaceRoot) {
   const seedScript = [
-    'import { LocalAgentStore } from "./src/local-agent-store.js";',
-    'const store = new LocalAgentStore(process.env.FORGERELAY_STATE_DIR);',
+    'import { SubagentSessionStore } from "./src/subagents/sessions/store.js";',
+    'const store = new SubagentSessionStore(process.env.FORGERELAY_STATE_DIR);',
     'const record = store.create({',
     `  workspaceId: ${JSON.stringify(workspaceId)},`,
     `  workspaceRoot: ${JSON.stringify(workspaceRoot)},`,
     '  profileName: "debug-missing-profile",',
     '  provider: "codex",',
+    '  activeRun: { id: "run_debug_acceptance", startedAt: new Date().toISOString() },',
     '});',
     'store.close();',
     'process.stdout.write(record.id);',
@@ -1006,11 +1044,13 @@ function exerciseSubagentHooks(runtimeEnv, debugStateDir, workspaceId, workspace
   }
 
   const inspectScript = [
-    'import { LocalAgentStore } from "./src/local-agent-store.js";',
-    'const store = new LocalAgentStore(process.env.FORGERELAY_STATE_DIR);',
+    'import { SubagentSessionStore } from "./src/subagents/sessions/store.js";',
+    'import { SubagentDeliveryMailbox } from "./src/subagents/sessions/delivery-mailbox.js";',
+    'const store = new SubagentSessionStore(process.env.FORGERELAY_STATE_DIR);',
     `const record = store.get(${JSON.stringify(agentId)});`,
+    `const deliveries = new SubagentDeliveryMailbox(process.env.FORGERELAY_STATE_DIR).claimSession(${JSON.stringify(workspaceId)}, ${JSON.stringify(agentId)});`,
     'store.close();',
-    'process.stdout.write(JSON.stringify({ status: record?.status, error: record?.error }));',
+    'process.stdout.write(JSON.stringify({ status: record?.status, latestRun: record?.latestRun, delivery: deliveries[0] }));',
   ].join("\n");
   const inspected = spawnSync(process.execPath, ["--import", "tsx", "--input-type=module", "-e", inspectScript], {
     cwd: repoRoot,
@@ -1021,9 +1061,11 @@ function exerciseSubagentHooks(runtimeEnv, debugStateDir, workspaceId, workspace
     throw new Error(`unable to inspect debug subagent: ${inspected.stderr.trim()}`);
   }
   const record = JSON.parse(inspected.stdout);
-  assert.equal(record.status, "error");
-  assert.match(record.error, /Subagent profile not found/);
-  pass("subagent hook path", `${agentId} stopped in deterministic error path without calling a provider`);
+  assert.equal(record.status, "idle");
+  assert.equal(record.latestRun?.status, "failed");
+  assert.equal(record.delivery?.outcome, "failed");
+  assert.match(record.delivery?.error ?? "", /Subagent profile not found/);
+  pass("subagent hook path", `${agentId} stopped in deterministic failed Run without calling a provider`);
 }
 
 function toolText(result) {