@akira-tl/forgerelay 0.8.3 → 0.8.4

package/dist/workspace-tasks.js

@@ -80,6 +80,20 @@ export class WorkspaceTaskStore {
     read(workspaceId) {
         return this.ensureWorkspace(workspaceId);
     }
+    readSummary(workspaceId) {
+        return taskSummary(this.ensureWorkspace(workspaceId));
+    }
+    inspectSummary(workspaceId) {
+        const id = normalizeWorkspaceId(workspaceId);
+        const loaded = this.tryReadState(id);
+        return loaded ? taskSummary(snapshot(loaded.state, loaded.fingerprint)) : undefined;
+    }
+    readHeaders(workspaceId, listId) {
+        return taskHeaders(this.ensureWorkspace(workspaceId), listId);
+    }
+    readTaskDetail(workspaceId, listId, taskId) {
+        return taskDetail(this.ensureWorkspace(workspaceId), listId, taskId);
+    }
     createList(workspaceId, input) {
         return this.mutate(workspaceId, (state) => {
             if (state.lists.length >= MAX_TASK_LISTS) {
@@ -266,6 +280,61 @@ function snapshot(state, stateFingerprint) {
         fingerprint: stateFingerprint,
     };
 }
+function taskSummary(snapshotValue) {
+    return {
+        level: "summary",
+        version: snapshotValue.version,
+        revision: snapshotValue.revision,
+        fingerprint: snapshotValue.fingerprint,
+        lists: snapshotValue.lists.map((list) => ({
+            id: list.id,
+            name: list.name,
+            state: list.state,
+            revision: list.revision,
+            taskCount: list.tasks.length,
+            unfinishedTaskCount: list.tasks.filter((task) => task.status !== "completed").length,
+        })),
+    };
+}
+function taskHeaders(snapshotValue, listId) {
+    const lists = listId === undefined
+        ? snapshotValue.lists
+        : [snapshotValue.lists[requireListIndex(snapshotValue, listId)]];
+    return {
+        level: "headers",
+        version: snapshotValue.version,
+        revision: snapshotValue.revision,
+        fingerprint: snapshotValue.fingerprint,
+        lists: lists.map((list) => ({
+            id: list.id,
+            name: list.name,
+            state: list.state,
+            revision: list.revision,
+            tasks: list.tasks.map((task) => ({
+                id: task.id,
+                status: task.status,
+                subject: task.subject,
+            })),
+        })),
+    };
+}
+function taskDetail(snapshotValue, listId, taskId) {
+    const list = requireList(snapshotValue, listId);
+    const task = list.tasks[requireTaskIndex(list, taskId)];
+    return {
+        level: "detail",
+        version: snapshotValue.version,
+        revision: snapshotValue.revision,
+        fingerprint: snapshotValue.fingerprint,
+        list: {
+            id: list.id,
+            name: list.name,
+            state: list.state,
+            revision: list.revision,
+        },
+        task: { ...task },
+    };
+}
 function cloneState(state) {
     return {
         version: state.version,

package/dist/workspaces.js

@@ -46,6 +46,37 @@ export class WorkspaceRegistry {
         }
         return this.openReusableCheckout(workspaceInput.path, openOptions.conversationScopeId, bootstrapContext);
     }
+    async inspectWorkspace(workspaceId) {
+        let session = this.store?.getSession(workspaceId);
+        if (!session) {
+            const workspace = this.workspaces.get(workspaceId);
+            if (workspace) {
+                session = {
+                    id: workspace.id,
+                    root: workspace.root,
+                    status: "active",
+                    mode: workspace.mode,
+                    sourceRoot: workspace.sourceRoot,
+                    baseRef: workspace.worktree?.baseRef,
+                    baseSha: workspace.worktree?.baseSha,
+                    branch: workspace.worktree?.branch,
+                    targetBranch: workspace.worktree?.targetBranch,
+                    managed: workspace.worktree?.managed ?? false,
+                    createdAt: "",
+                    lastUsedAt: "",
+                };
+            }
+        }
+        if (!session)
+            throw new Error(`Unknown workspaceId: ${workspaceId}.`);
+        const entry = await this.inventoryEntryForSession(session, Date.now(), false);
+        const { current: _current, ...inspection } = entry;
+        return {
+            kind: "workspace",
+            location: "local",
+            ...inspection,
+        };
+    }
     async listWorkspaces(input = {}, openOptions = {}) {
         this.pruneIdleWorkspaceSessions(openOptions.protectedWorkspaceIds ?? new Set());
         const now = Date.now();
@@ -77,36 +108,7 @@ export class WorkspaceRegistry {
         const rootKey = input.root
             ? await canonicalPath(assertAllowedPath(input.root, [...this.config.allowedRoots, this.config.worktreeRoot]))
             : undefined;
-        const entries = await Promise.all(sessions.map(async (session) => {
-            const rootValid = await this.validSessionRoot(session) !== undefined;
-            const lastUsedAt = Date.parse(session.lastUsedAt);
-            const idleMs = Number.isFinite(lastUsedAt) ? Math.max(0, now - lastUsedAt) : 0;
-            const state = session.status !== "active"
-                ? "closed"
-                : !rootValid
-                    ? "invalid"
-                    : idleMs >= WORKSPACE_STALE_REMINDER_MS
-                        ? "stale"
-                        : "active";
-            const projectRoot = session.sourceRoot ?? session.root;
-            return {
-                label: `${basename(resolve(projectRoot)) || "workspace"}/${session.id}`,
-                workspaceId: session.id,
-                root: session.root,
-                status: session.status,
-                state,
-                mode: session.mode,
-                sourceRoot: session.sourceRoot,
-                branch: session.branch,
-                targetBranch: session.targetBranch,
-                managed: session.managed,
-                createdAt: session.createdAt,
-                lastUsedAt: session.lastUsedAt,
-                idleMs,
-                rootValid,
-                current: currentWorkspaceIds.has(session.id),
-            };
-        }));
+        const entries = await Promise.all(sessions.map((session) => this.inventoryEntryForSession(session, now, currentWorkspaceIds.has(session.id))));
         const filtered = [];
         for (let index = 0; index < sessions.length; index += 1) {
             const session = sessions[index];
@@ -151,6 +153,36 @@ export class WorkspaceRegistry {
             },
         };
     }
+    async inventoryEntryForSession(session, now, current) {
+        const rootValid = await this.validSessionRoot(session) !== undefined;
+        const lastUsedAt = Date.parse(session.lastUsedAt);
+        const idleMs = Number.isFinite(lastUsedAt) ? Math.max(0, now - lastUsedAt) : 0;
+        const state = session.status !== "active"
+            ? "closed"
+            : !rootValid
+                ? "invalid"
+                : idleMs >= WORKSPACE_STALE_REMINDER_MS
+                    ? "stale"
+                    : "active";
+        const projectRoot = session.sourceRoot ?? session.root;
+        return {
+            label: `${basename(resolve(projectRoot)) || "workspace"}/${session.id}`,
+            workspaceId: session.id,
+            root: session.root,
+            status: session.status,
+            state,
+            mode: session.mode,
+            sourceRoot: session.sourceRoot,
+            branch: session.branch,
+            targetBranch: session.targetBranch,
+            managed: session.managed,
+            createdAt: session.createdAt,
+            lastUsedAt: session.lastUsedAt,
+            idleMs,
+            rootValid,
+            current,
+        };
+    }
     async resumeWorkspace(workspaceId, conversationScopeId, bootstrapContext = "auto") {
         const session = this.store?.getSession(workspaceId);
         const context = session?.status === "closed" && session.mode === "worktree"

package/docs/chatgpt-coding-workflow.md

@@ -49,9 +49,9 @@ returning the full project context and does not record the current fingerprint a
 already delivered. Context-delivery state remains conversation-scoped and does not
 change the persistent Workspace identity.
 
-Do not enumerate Workspace state on every normal open. When the user wants to
-continue earlier work, inspect known Workspaces, or clean up accumulated state, use
-the same Core tool in inventory mode:
+Do not enumerate Workspace state on every normal open. Use the same Core tool in
+inventory mode only when the user wants to discover known Workspaces, continue earlier
+work, or organize accumulated state:
 
 ```text
 open_workspace(action="list")
@@ -66,6 +66,16 @@ root/source root, or stale-only state. Entries include a compact label such as
 root validity, and whether that Workspace is currently selected by this
 conversation. Listing is observational and does not refresh `lastUsedAt`.
 
+When one known Workspace needs more bounded detail but must not be opened or resumed,
+use `open_workspace(action="inspect", workspaceId="...")`. Inspection is a strict
+allowlist projection: ordinary/worktree lifecycle metadata, Composite member
+summaries, safe Relay presentation metadata, and an existing Task List summary may be
+returned. It does not return bootstrap instructions, Skills, Capability guides,
+Subagent bodies, files, process/Activity output, credentials, routes, or Task bodies;
+it does not bind the conversation, mark bootstrap delivered, refresh `lastUsedAt`, or
+grant execution authority. Explicitly open the target Workspace before mutating or
+executing against it.
+
 Treat persisted status and derived state separately. `status="active"` means the
 record has not been explicitly closed. A valid recent record has `state="active"`;
 a valid active record idle for more than two days has `state="stale"`; an active

package/docs/configuration.md

@@ -327,17 +327,52 @@ Hooks, Skills, language services, and Activity facts remain owned by the underly
 Workspace. The Composite Activity Panel only aggregates their presentation into one
 Host Turn.
 
-Use `open_workspace(action="list")` only when the Agent needs to inspect known
-Workspaces, continue earlier work, or organize Workspace state. The inventory is
-paginated (50 records by default, at most 100) and can filter by Workspace ID,
-persisted status, derived state, mode, canonical root/source root, or stale-only
-state. Reading inventory does not refresh `lastUsedAt`. Persisted
-`status="active"` means the record has not been explicitly closed; the derived
-`state` distinguishes `active`, `stale`, `invalid`, and `closed`. A missing checkout
-or externally removed managed-worktree root can therefore remain diagnostically
-`status="active"` while appearing as `state="invalid"`. Canonical identity means
-ordinary same-target opens no longer accumulate duplicate inventory rows;
-`action="list"` remains the formal on-demand inventory path.
+## Workspace Tasks
+
+`workspace.tasks` keeps lightweight Task Lists in ForgeRelay-owned private Workspace
+state. Task data is not project bootstrap context and is not written into checkout or
+managed-worktree Git contents. Reads use progressive disclosure: default `get` returns
+List summaries and unfinished counts, `level="headers"` adds Task ID/status/subject,
+and `level="detail"` returns full content for one explicitly selected Task.
+
+ForgeRelay can append a bounded forgotten-update reminder after semantic Workspace
+work when active Lists still contain unfinished Tasks. The counter defaults to 30
+successful semantic work calls, resets on any Task mutation, treats one
+`batch.execute` as one call, and does not count Workspace inventory/lifecycle UI,
+Activity queries, Task reads, or Bash/process follow-up polling/input as new work.
+The counter is process-local and may reset on server restart; Task state itself
+remains durable.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `FORGERELAY_TASK_REMINDER_INTERVAL` | `30` | Successful semantic work calls between Task update reminders; `0` disables reminders. |
+
+The same value may be persisted as `taskReminderInterval` in `config.json`. The
+legacy-compatible `DEVSPACE_TASK_REMINDER_INTERVAL` environment name is also accepted.
+
+Use `open_workspace(action="list")` only when the Agent needs lightweight inventory
+to discover known Workspaces, continue earlier work, or organize Workspace state. The
+inventory is paginated (50 records by default, at most 100) and can filter by Workspace
+ID, persisted status, derived state, mode, canonical root/source root, or stale-only
+state. Reading inventory does not refresh `lastUsedAt`. Persisted `status="active"`
+means the record has not been explicitly closed; the derived `state` distinguishes
+`active`, `stale`, `invalid`, and `closed`. A missing checkout or externally removed
+managed-worktree root can therefore remain diagnostically `status="active"` while
+appearing as `state="invalid"`. Canonical identity means ordinary same-target opens no
+longer accumulate duplicate inventory rows; `action="list"` remains the formal
+on-demand inventory path.
+
+`open_workspace(action="inspect", workspaceId="...")` is the bounded read-only detail
+path for one known Workspace. It uses an explicit allowlist and never opens/resumes the
+target, changes conversation bindings or bootstrap-delivery records, refreshes
+`lastUsedAt`, or grants file/process/Git/Capability authority. Safe projections include
+ordinary/worktree lifecycle metadata, Composite member availability summaries, Relay
+alias/execution-location presentation metadata, and an already-existing Task List
+summary. Inspection never returns AGENTS/CLAUDE contents, Skills, Capability-guide
+paths or contents, Subagent bodies/sessions, files, Git diffs, process/Activity output,
+Hook/review artifacts, credentials, network/SSH routes, or Task bodies. Relay inspection
+reports only that the Gateway route is known; it does not probe or claim the remote
+Workspace lifecycle state.
 
 For checkout-backed Workspaces, `close_workspace` defaults to `action="close"`:
 it marks the persistent Workspace closed, removes current conversation bindings, and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -47,7 +47,7 @@
     "release:publish": "node scripts/release/publish.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "node --test scripts/debug/runtime.test.mjs scripts/release-proof.test.mjs scripts/release/release-gate.test.mjs scripts/release/release-version.test.mjs && tsx src/oauth/router.test.ts && tsx src/remote-auth-cli.test.ts && tsx src/remote-ssh-auth-cli.test.ts && tsx src/remote-workspace-relay.test.ts && tsx src/remote-workspace-relay-process.test.ts && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/workspace-lifecycle-app.test.ts && tsx src/ui/activity/model.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/subagents/providers/adapters/codex.test.ts && tsx src/subagents/providers/registry.test.ts && tsx src/subagents/providers/availability.test.ts && tsx src/subagents/profiles.test.ts && tsx src/subagents/cli-target.test.ts && tsx src/subagents/sessions/store.test.ts && tsx src/subagents/sessions/manager.test.ts && tsx src/subagents/sessions/mcp/capability.server.test.ts && tsx src/subagents/sessions/mcp/continuation.server.test.ts && tsx src/subagents/sessions/mcp/lifecycle.server.test.ts && tsx src/subagents/sessions/mcp/reconciliation.server.test.ts && tsx src/subagents/sessions/mcp/routing.server.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/operations/edit-preflight.test.ts && tsx src/skills.test.ts && tsx src/db/migrations.test.ts && tsx src/workspace-store.test.ts && tsx src/workspace-tasks.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/bash-output-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/activity/query-service.test.ts && tsx src/operations/core-operation-executor.test.ts && tsx src/operations/bulk-mutation.test.ts && tsx src/operations/batch/scheduler.test.ts && tsx src/operations/batch/executor-policy.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && npm run build:app && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "node --test scripts/debug/runtime.test.mjs scripts/release-proof.test.mjs scripts/release/release-gate.test.mjs scripts/release/release-version.test.mjs && tsx src/oauth/router.test.ts && tsx src/remote-auth-cli.test.ts && tsx src/remote-ssh-auth-cli.test.ts && tsx src/remote-workspace-relay.test.ts && tsx src/remote-workspace-relay-process.test.ts && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/workspace-lifecycle-app.test.ts && tsx src/ui/activity/model.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/subagents/providers/adapters/codex.test.ts && tsx src/subagents/providers/registry.test.ts && tsx src/subagents/providers/availability.test.ts && tsx src/subagents/profiles.test.ts && tsx src/subagents/cli-target.test.ts && tsx src/subagents/sessions/store.test.ts && tsx src/subagents/sessions/manager.test.ts && tsx src/subagents/sessions/mcp/capability.server.test.ts && tsx src/subagents/sessions/mcp/continuation.server.test.ts && tsx src/subagents/sessions/mcp/lifecycle.server.test.ts && tsx src/subagents/sessions/mcp/reconciliation.server.test.ts && tsx src/subagents/sessions/mcp/routing.server.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/operations/edit-preflight.test.ts && tsx src/skills.test.ts && tsx src/db/migrations.test.ts && tsx src/workspace-store.test.ts && tsx src/workspace-tasks.test.ts && tsx src/workspace-task-reminders.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/bash-output-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/activity/query-service.test.ts && tsx src/operations/core-operation-executor.test.ts && tsx src/operations/bulk-mutation.test.ts && tsx src/operations/batch/scheduler.test.ts && tsx src/operations/batch/executor-policy.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && npm run build:app && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",

package/scripts/debug/accept.mjs

@@ -48,6 +48,10 @@ mkdirSync(acceptanceRoot, { recursive: true });
 setupGitProject(checkoutWorkspace);
 setupGitProject(lifecycleDeleteWorkspace);
 writeFileSync(join(lifecycleDeleteWorkspace, "keep.txt"), "keep checkout files\n");
+writeFileSync(
+  join(lifecycleDeleteWorkspace, "AGENTS.md"),
+  "INSPECTION_ACCEPTANCE_BOOTSTRAP_SECRET\n",
+);
 setupCodeIntelligenceAcceptanceProject({
   root: checkoutWorkspace,
   fakeLanguageServer,
@@ -316,16 +320,77 @@ try {
     workspaceId,
     name: "workspace.tasks",
     action: "run",
-    arguments: { operation: "get" },
+    arguments: {
+      operation: "get",
+      level: "detail",
+      listId: checkoutListId,
+      taskId: checkoutTaskId,
+    },
   });
   assert.equal(reloadedCheckoutTasks.isError, undefined);
-  assert.equal(reloadedCheckoutTasks.structuredContent.result.lists[0].tasks[0].id, checkoutTaskId);
-  assert.equal(
-    reloadedCheckoutTasks.structuredContent.result.lists[0].tasks[0].content,
-    "reloaded external task edit",
-  );
+  assert.equal(reloadedCheckoutTasks.structuredContent.result.task.id, checkoutTaskId);
+  assert.equal(reloadedCheckoutTasks.structuredContent.result.task.content, "reloaded external task edit");
   assert.notEqual(reloadedCheckoutTasks.structuredContent.result.fingerprint, taskFingerprintBeforeExternal);
 
+  const checkoutTaskSummary = callTool(oauth.accessToken, sessionId, 150, "capability", {
+    workspaceId,
+    name: "workspace.tasks",
+    action: "run",
+    arguments: { operation: "get" },
+  });
+  const summaryProjection = checkoutTaskSummary.structuredContent.result;
+  assert.equal(summaryProjection.level, "summary");
+  assert.equal(summaryProjection.lists[0].id, checkoutListId);
+  assert.equal(summaryProjection.lists[0].taskCount, 1);
+  assert.equal(summaryProjection.lists[0].unfinishedTaskCount, 1);
+  assert.equal(JSON.stringify(summaryProjection).includes(checkoutTaskId), false);
+  assert.equal(JSON.stringify(summaryProjection).includes("reloaded external task edit"), false);
+
+  const checkoutTaskHeaders = callTool(oauth.accessToken, sessionId, 151, "capability", {
+    workspaceId,
+    name: "workspace.tasks",
+    action: "run",
+    arguments: { operation: "get", level: "headers", listId: checkoutListId },
+  });
+  const headersProjection = checkoutTaskHeaders.structuredContent.result;
+  assert.equal(headersProjection.level, "headers");
+  assert.equal(headersProjection.lists.length, 1);
+  assert.equal(headersProjection.lists[0].tasks[0].id, checkoutTaskId);
+  assert.equal(headersProjection.lists[0].tasks[0].subject, "Verify v0.8.3 Task persistence");
+  assert.equal("content" in headersProjection.lists[0].tasks[0], false);
+
+  const checkoutTaskDetail = callTool(oauth.accessToken, sessionId, 152, "capability", {
+    workspaceId,
+    name: "workspace.tasks",
+    action: "run",
+    arguments: {
+      operation: "get",
+      level: "detail",
+      listId: checkoutListId,
+      taskId: checkoutTaskId,
+    },
+  });
+  const detailProjection = checkoutTaskDetail.structuredContent.result;
+  assert.equal(detailProjection.level, "detail");
+  assert.equal(detailProjection.task.id, checkoutTaskId);
+  assert.equal(detailProjection.task.content, "reloaded external task edit");
+  pass("workspace.tasks progressive disclosure", "summary -> headers -> one Task detail through real MCP");
+
+  for (let index = 0; index < 29; index += 1) {
+    const semanticWork = callTool(oauth.accessToken, sessionId, 160 + index, "read", {
+      workspaceId,
+      path: "README.md",
+    });
+    assert.doesNotMatch(toolText(semanticWork), /Reminder: this Workspace has unfinished active Tasks/);
+  }
+  const reminderWork = callTool(oauth.accessToken, sessionId, 189, "read", {
+    workspaceId,
+    path: "README.md",
+  });
+  assert.match(toolText(reminderWork), /Reminder: this Workspace has unfinished active Tasks/);
+  assert.equal(toolText(reminderWork).includes("reloaded external task edit"), false);
+  pass("workspace.tasks reminder", "default 30 semantic work calls emitted one body-free reminder");
+
   const repeatedOpen = callTool(oauth.accessToken, sessionId, 84, "open_workspace", {
     path: checkoutWorkspace,
     newWorkspace: true,
@@ -391,14 +456,16 @@ try {
     workspaceId,
     name: "workspace.tasks",
     action: "run",
-    arguments: { operation: "get" },
+    arguments: {
+      operation: "get",
+      level: "detail",
+      listId: checkoutListId,
+      taskId: checkoutTaskId,
+    },
   });
   assert.equal(resumedCheckoutTasks.isError, undefined);
-  assert.equal(resumedCheckoutTasks.structuredContent.result.lists[0].tasks[0].id, checkoutTaskId);
-  assert.equal(
-    resumedCheckoutTasks.structuredContent.result.lists[0].tasks[0].content,
-    "reloaded external task edit",
-  );
+  assert.equal(resumedCheckoutTasks.structuredContent.result.task.id, checkoutTaskId);
+  assert.equal(resumedCheckoutTasks.structuredContent.result.task.content, "reloaded external task edit");
   assert.equal(resumedOriginal.structuredContent.contextFingerprint, opened.structuredContent.contextFingerprint);
 
   const deleteOpened = callTool(oauth.accessToken, sessionId, 91, "open_workspace", {
@@ -414,7 +481,72 @@ try {
     arguments: { operation: "list.create", name: "delete with workspace" },
   });
   assert.equal(deleteTaskList.isError, undefined);
+  const deleteTaskListId = deleteTaskList.structuredContent.result.lists[0].id;
+  const inspectionTask = callTool(oauth.accessToken, sessionId, 190, "capability", {
+    workspaceId: deleteWorkspaceId,
+    name: "workspace.tasks",
+    action: "run",
+    arguments: {
+      operation: "task.create",
+      listId: deleteTaskListId,
+      subject: "Inspect safely",
+      content: "INSPECTION_ACCEPTANCE_TASK_BODY_SECRET",
+      status: "in_progress",
+    },
+  });
+  assert.equal(inspectionTask.isError, undefined);
   assert.ok(existsSync(deleteTaskStatePath));
+
+  const inspectionBefore = callTool(oauth.accessToken, sessionId, 191, "open_workspace", {
+    action: "list",
+    workspaceId: deleteWorkspaceId,
+  }, workspaceConversationMeta);
+  const inspectionBeforeEntry = inspectionBefore.structuredContent.workspaces[0];
+  assert.equal(inspectionBeforeEntry.current, false);
+  const inspectedWorkspace = callTool(oauth.accessToken, sessionId, 192, "open_workspace", {
+    action: "inspect",
+    workspaceId: deleteWorkspaceId,
+  }, workspaceConversationMeta);
+  assert.equal(inspectedWorkspace.structuredContent.action, "inspect");
+  const inspectionProjection = inspectedWorkspace.structuredContent.inspection;
+  assert.equal(inspectionProjection.workspaceId, deleteWorkspaceId);
+  assert.equal(inspectionProjection.kind, "workspace");
+  assert.equal(inspectionProjection.location, "local");
+  assert.equal(inspectionProjection.root, lifecycleDeleteWorkspace);
+  assert.equal(inspectionProjection.taskSummary.level, "summary");
+  assert.equal(inspectionProjection.taskSummary.lists[0].taskCount, 1);
+  assert.equal(inspectionProjection.taskSummary.lists[0].unfinishedTaskCount, 1);
+  const inspectionJson = JSON.stringify(inspectedWorkspace);
+  for (const forbidden of [
+    "INSPECTION_ACCEPTANCE_BOOTSTRAP_SECRET",
+    "INSPECTION_ACCEPTANCE_TASK_BODY_SECRET",
+    "\"fingerprint\"",
+    "\"agentsFiles\"",
+    "\"availableAgentsFiles\"",
+    "\"capabilityGuides\"",
+    "\"skillDiagnostics\"",
+    "\"agentProviders\"",
+    "\"contextFingerprint\"",
+    "\"capabilityFingerprint\"",
+    "\"memberContext\"",
+  ]) {
+    assert.equal(inspectionJson.includes(forbidden), false, `Workspace inspect leaked ${forbidden}`);
+  }
+  const inspectionAfter = callTool(oauth.accessToken, sessionId, 193, "open_workspace", {
+    action: "list",
+    workspaceId: deleteWorkspaceId,
+  }, workspaceConversationMeta);
+  assert.equal(inspectionAfter.structuredContent.workspaces[0].lastUsedAt, inspectionBeforeEntry.lastUsedAt);
+  assert.equal(inspectionAfter.structuredContent.workspaces[0].current, false);
+  const callerAfterInspection = callTool(oauth.accessToken, sessionId, 194, "open_workspace", {
+    workspaceId,
+    context: "auto",
+  }, workspaceConversationMeta);
+  assert.equal(callerAfterInspection.structuredContent.workspaceId, workspaceId);
+  assert.equal(callerAfterInspection.structuredContent.agentsFiles, undefined);
+  assert.equal(callerAfterInspection.structuredContent.capabilityGuides, undefined);
+  pass("Workspace inspection", "cross-Workspace metadata + Task summary stayed read-only and bootstrap-free");
+
   const deleteClosed = callTool(oauth.accessToken, sessionId, 92, "close_workspace", {
     workspaceId: deleteWorkspaceId,
   });
@@ -729,6 +861,18 @@ try {
   });
   assert.equal(closedWorktreeInventory.structuredContent.workspaces.length, 1);
   assert.equal(closedWorktreeInventory.structuredContent.workspaces[0].state, "closed");
+  const closedWorktreeInspection = callTool(oauth.accessToken, sessionId, 195, "open_workspace", {
+    action: "inspect",
+    workspaceId: worktreeWorkspaceId,
+  });
+  const closedWorktreeProjection = closedWorktreeInspection.structuredContent.inspection;
+  assert.equal(closedWorktreeProjection.kind, "workspace");
+  assert.equal(closedWorktreeProjection.mode, "worktree");
+  assert.equal(closedWorktreeProjection.managed, true);
+  assert.equal(closedWorktreeProjection.state, "closed");
+  assert.equal(closedWorktreeProjection.rootValid, false);
+  assert.equal(existsSync(managedWorktreePath), false);
+  assert.equal(JSON.stringify(closedWorktreeInspection).includes("\"fingerprint\""), false);
 
   const reopenedWorktree = callTool(oauth.accessToken, sessionId, 111, "open_workspace", {
     workspaceId: worktreeWorkspaceId,
@@ -848,6 +992,20 @@ try {
     arguments: { operation: "get" },
   });
   assert.equal(closedCompositeTasks.isError, true);
+  const closedCompositeInspection = callTool(oauth.accessToken, sessionId, 196, "open_workspace", {
+    action: "inspect",
+    workspaceId: compositeWorkspaceId,
+  });
+  const closedCompositeProjection = closedCompositeInspection.structuredContent.inspection;
+  assert.equal(closedCompositeProjection.kind, "composite");
+  assert.equal(closedCompositeProjection.state, "closed");
+  assert.equal(closedCompositeProjection.members[0].workspaceId, workspaceId);
+  assert.equal(closedCompositeProjection.members[0].known, true);
+  assert.equal(closedCompositeProjection.taskSummary.lists[0].taskCount, 1);
+  assert.equal(
+    JSON.stringify(closedCompositeInspection).includes("Composite-owned state"),
+    false,
+  );
 
   const reopenedComposite = callTool(oauth.accessToken, sessionId, 121, "open_workspace", {
     workspaceId: compositeWorkspaceId,
@@ -860,14 +1018,16 @@ try {
     workspaceId: compositeWorkspaceId,
     name: "workspace.tasks",
     action: "run",
-    arguments: { operation: "get" },
+    arguments: {
+      operation: "get",
+      level: "detail",
+      listId: compositeTaskListId,
+      taskId: compositeTaskId,
+    },
   });
   assert.equal(reopenedCompositeTasks.isError, undefined);
-  assert.equal(reopenedCompositeTasks.structuredContent.result.lists[0].tasks[0].id, compositeTaskId);
-  assert.equal(
-    reopenedCompositeTasks.structuredContent.result.lists[0].tasks[0].content,
-    "Composite-owned state",
-  );
+  assert.equal(reopenedCompositeTasks.structuredContent.result.task.id, compositeTaskId);
+  assert.equal(reopenedCompositeTasks.structuredContent.result.task.content, "Composite-owned state");
   const reopenedCompositeRead = callTool(oauth.accessToken, sessionId, 122, "read", {
     workspaceId: compositeWorkspaceId,
     member: "code",