@awak-app/simy-cli 0.7.10 → 0.7.11

package/README.md

@@ -290,7 +290,23 @@ unavailable; a single observed activity event is a measured zero-duration sample
 Missing usage records remain distinct from recorded zero tokens.
 
 The desktop Sessions page loads a recent window of up to 200 conversations,
-ranked by last activity. Codex candidates come from CLI, VS Code and app-server
+selected by last activity. The macOS work list then prioritizes verified running
+conversations, including families with running children, followed by work needing
+a human response and recent activity. Its All, Running, Needs attention, Completed
+and Archived views combine with search. Tracking and auto-continue settings never
+prove that an AI is running; observations older than 45 seconds or a failed
+provider refresh display an unknown execution state.
+
+List-only hiding supports multiple selection and restoration without changing
+provider archive state or execution consent. Codex archive/restore is a separate
+explicit operation; Claude archive/restore must be performed in Claude, and SIMY
+reads its Desktop archive metadata on refresh. Related GitHub PR summaries are
+read from structured provider metadata and refreshed through an installed,
+authenticated `gh` CLI, with bounded reads, a one-minute cache, timestamps and
+failure indicators. A merge alone never completes a conversation, and known
+unfinished children or open PRs keep a completed task out of the Completed view.
+
+Codex candidates come from CLI, VS Code and app-server
 conversation sources; non-interactive exec, unknown sources and delegated agents
 are excluded. A hook observation alone cannot restore a filtered conversation.
 Explicitly tracked, monitored, auto-continue and unsettled supervision records

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.10",
+  "version": "0.7.11",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.10";
+export const CLI_VERSION = "0.7.11";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/delivery-hooks/desktop.js

@@ -30,7 +30,7 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
     })),
     runs: records.filter(r => r.run && r.providerArchived !== true).sort((a, b) => b.run.updatedAt - a.run.updatedAt).slice(0, 30).map(r => ({
       provider: r.provider, session: r.session, originalSessionTarget: originalSessionTarget(r.provider, r.session),
-      objective: r.run.objective, state: r.run.state, reason: r.run.reason, runId: r.run.id, revision: deliveryDecisionRevision(r.run), recoveryCause: r.run.recoveryCause, autoRecovery: r.run.managed?.autoRecovery === true,
+      objective: r.run.objective, state: r.run.state, reason: r.run.reason, runId: r.run.id, revision: deliveryDecisionRevision(r.run), recoveryCause: r.run.recoveryCause, stopReason: r.run.stopReason || null, autoRecovery: r.run.managed?.autoRecovery === true,
       continuations: r.run.continuations,
       continuationPolicy: r.run.managed?.continuationPolicy || 'bounded',
       startedAt: r.run.startedAt,

package/src/desktop-host.js

@@ -1,3 +1,5 @@
+import { sessionWorkState, compareSessionWork, reconcileFamilyCompletion, expireSessionWorkState } from './session-supervision/work-state.js';
+import { createPullRequestObserver } from './session-supervision/pull-requests.js';
 import { sessionDecisionPresentation } from './session-supervision/decision-presentation.js';
 import { PROVIDER_LINKS, readProviderLinks, writeProviderLink, requireProviderLink } from "./provider-links.js";
 import { randomUUID } from "node:crypto";
@@ -11,7 +13,7 @@ import { stopDesktopWorkForUpdate } from './desktop-update-stop.js';
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
-import { controlDelivery, verifyDelivery, createRecordReader, updateRecord, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { controlDelivery, verifyDelivery, createRecordReader, updateRecord, recordProviderArchive, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { createStopNotifier } from "./session-supervision/stop-notifications.js";
@@ -101,7 +103,7 @@ function desktopActionError(action, error) {
   if (action === "session_deadline_decide") return error?.code === "conflict"
     ? "Deadline changed; refresh before deciding." : "The deadline is unavailable. Refresh this conversation before deciding.";
   if (typeof action === "string" && action.startsWith("session_")) {
-    return action.startsWith("session_action_") ? associationActionError(error) : sessionActionError(error);
+    return action.startsWith("session_action_") ? associationActionError(error) : sessionActionError(error, action);
   }
   if (["organization_select", "organization_cancel", "organizations_refresh"].includes(action)) {
     return error?.code === "desktop_organization_busy"
@@ -411,6 +413,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     });
     unfinishedDesktopWork = false;
   })();
+  const observePullRequests = dependencies.observePullRequests || createPullRequestObserver();
   const refreshSessions = (force = false) => {
     if (discoveryStopped && !closed && !relay) return sessionStatus;
     if (closed || relay || !desktopAccessReady(currentAccess)) return { sessions: [], providers: {}, refreshedAt: null };
@@ -428,7 +431,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
             sessionRefreshAgain = desktopAccessReady(latestAccess);
             return;
           }
-          const sessions = linkedSessions(value.sessions);
+          const sessions = await observePullRequests(linkedSessions(value.sessions), { signal: controller.signal });
+          const afterObservation = await accessSnapshot();
+          if (controller.signal.aborted || !desktopAccessReady(afterObservation) || accessScope(afterObservation) !== requestedScope) {
+            await analysisManager.update([]); sessionRefreshAgain = desktopAccessReady(afterObservation); return;
+          }
           await analysisManager.update(analysisSessions(sessions));
           if (controller.signal.aborted) return;
           sessionStatus = { ...value, sessions, initialLoading: false }; sessionRefreshedAt = Date.now(); })
@@ -626,7 +633,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       // Cached enrichment must follow the current connection preference even
       // while a full projection is waiting on records or remote metadata.
       status.deliveryHooks.runs = linkedSessions(status.deliveryHooks.runs || []);
-      status.sessionSupervision.sessions = linkedSessions(status.sessionSupervision.sessions || []);
+      status.sessionSupervision.sessions = linkedSessions(status.sessionSupervision.sessions || []).map(candidate => expireSessionWorkState(candidate)).sort(compareSessionWork);
       status.sessionSupervision.providers ||= {};
       for (const provider of PROVIDER_LINKS) {
         if (!providerLinks[provider].connected) status.sessionSupervision.providers[provider] = { discovery: 'disconnected', reason: null };
@@ -705,6 +712,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       automaticContinuation?.tick(discovery.sessions);
       const sessions = discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate)));
       await actionAssociations.decorateSessions?.(sessions, projection);
+      const stateRunsBySession = new Map((projection?.records || records).filter(record => record.run).map(record => [`${record.provider}:${record.session}`, record.run]));
       const runsBySession = new Map((status.deliveryHooks.runs || []).map(run => [`${run.provider}:${run.session}`, run]));
       for (const session of sessions) {
         const key = `${session.provider}:${session.session}`;
@@ -727,8 +735,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const run = runsBySession.get(`${session.provider}:${session.session}`);
         if (run) run.actionDeadline = session.actionDeadline;
       }
-      status.sessionSupervision = { ...discovery, refreshing: Boolean(sessionRefresh), sessions: sessions.map(candidate => ({ ...candidate,
-        decisionRequest: sessionDecisionPresentation(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`)) })) };
+      status.sessionSupervision = { ...discovery, refreshing: Boolean(sessionRefresh), sessions: reconcileFamilyCompletion(sessions.map(candidate => ({ ...candidate,
+        decisionRequest: sessionDecisionPresentation(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`)),
+        workState: sessionWorkState(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`) || stateRunsBySession.get(`${candidate.provider}:${candidate.session}`), { provider: discovery.providers?.[candidate.provider] }) }))).sort(compareSessionWork) };
       const latestAccess = await accessSnapshot();
       if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks ||
         !desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope ||
@@ -1339,6 +1348,25 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await authorizeWork(commandScope);
           const result = await deadlines.decide(context, { ...command, requestId: command.requestId || command.decisionId });
           if (result.status === 'conflict') throw Object.assign(new Error('Deadline changed; refresh before deciding.'), { code: 'conflict' });
+        } else if (action === "session_archive" || action === "session_restore") {
+          const candidate = await selectedSession(command, { preferObserved: true });
+          await authorizeWork(commandScope);
+          if (!['local', 'provider'].includes(command.scope)) throw new Error('Choose local or provider archive explicitly.');
+          const archived = action === 'session_archive';
+          if (command.scope === 'provider') {
+            if (command.provider !== 'codex') throw new Error('Archive or restore this conversation in Claude, then refresh SIMY.');
+            const client = await (dependencies.openCodexAppServer || openCodexAppServer)();
+            try { await client.request(archived ? 'thread/archive' : 'thread/unarchive', { threadId: command.session });
+              if (archived) await recordProviderArchive(deliveryRoot, command.provider, command.session, true, Date.now());
+            }
+            finally { await client.close(); }
+          } else {
+            await updateRecord(deliveryRoot, command.provider, command.session, previous => ({
+              ...(previous || { schemaVersion: 1, provider: command.provider, session: command.session, cwd: candidate.cwd, observedAt: Date.now() }),
+              listHidden: archived,
+            }));
+          }
+          refreshSessions(true);
         } else if (action === "session_track" || action === "session_untrack") {
           const candidate = await selectedSession(command);
           if (candidate.capabilities?.canMonitor !== true) throw new Error('Tracking is unavailable for this conversation.');
@@ -1439,7 +1467,7 @@ function associationActionError(error) {
   return 'The Action service is unavailable. Your conversation continues with its existing settings.';
 }
 
-function sessionActionError(error) {
+function sessionActionError(error, action) {
   if (error instanceof AutoContinueUnavailableError) return error.message.replace(/[\r\n\x00-\x1f]/g, ' ').slice(0, 600);
   const message = String(error?.message || "");
   if (/already has a Delivery Loop|budgets cannot be reset/i.test(message)) return "This conversation already has a task. Open its existing supervision instead.";
@@ -1447,6 +1475,7 @@ function sessionActionError(error) {
   if (/workspace changed|metadata.*unavailable|session.*changed/i.test(message)) return "The conversation identity or workspace changed. Refresh and select it again.";
   if (/objective|acceptance|autonomy policy|budget/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
   if (/question changed|answer is empty|session understanding|context/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
+  if (action === "session_answer") return "Answer acceptance is unconfirmed. Check the original conversation before sending again.";
   return "This conversation could not be enrolled. Refresh its provider status and try again.";
 }
 

package/src/provider-stream.js

@@ -206,6 +206,9 @@ function formatClaudeToolResults(prefix, content) {
 }
 
 function contentLines(prefix, label, value) {
+  // Native providers wrap machine results in assistant events too. Keep the
+  // result available to the parser without flooding the user transcript.
+  if (label === "assistant" && STRUCTURED_MARKERS.some(marker => String(value || "").trimStart().startsWith(marker))) return [];
   return String(value || "")
     .split(/\r?\n/)
     .map((line) => cleanLine(line))

package/src/session-supervision/claude-desktop-lineage.js

@@ -1,3 +1,4 @@
+import { normalizePullRequests } from './pull-requests.js';
 import { constants } from 'node:fs';
 import { lstat, open, readdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
@@ -70,12 +71,14 @@ async function metadata(path, desktopId, sessions) {
     let value = null;
     if (item.sessionId === desktopId && UUID.test(item.cliSessionId || '') && typeof item.cwd === 'string' && isAbsolute(item.cwd)) {
       value = { desktopId, session: item.cliSessionId, cwd: resolve(item.cwd),
+        ...(complete ? { providerArchived: typeof item.isArchived === 'boolean' ? item.isArchived : typeof item.archived === 'boolean' ? item.archived : undefined,
+          pullRequests: normalizePullRequests(item.pullRequests || item.gitHubPullRequests || item.githubPullRequests || item.githubPRs || item.gitHubPRs || item.gitHubPR || item.pullRequest || (item.prUrl ? { url: item.prUrl, state: item.prStatus } : null)) } : {}),
         parentDesktopId: complete && LOCAL.test(item.spawnedFrom?.sessionId || '') ? item.spawnedFrom.sessionId : null };
     }
     const after = await lstat(path, { bigint: true });
     if (fingerprint(after) !== key || fingerprint(await handle.stat({ bigint: true })) !== key || after.isSymbolicLink()) return null;
     if (!complete && !value) return null;
-    // Cache only identity/lineage. Desktop files also contain private settings;
+    // Cache only identity, lineage, archive and PR summaries. Desktop files also contain private settings;
     // none of those fields or conversation text leave this bounded reader.
     cache.delete(path); cache.set(path, { key, value, complete });
     while (cache.size > MAX_FILES) cache.delete(cache.keys().next().value);
@@ -86,7 +89,7 @@ async function metadata(path, desktopId, sessions) {
 
 // Desktop spawn parents use local_* IDs, whereas transcripts and SIMY use CLI
 // UUIDs. Resolve them within the same account AND organization partition.
-export async function readClaudeDesktopLineage({ home = homedir(), root = claudeDesktopSessionRoot(home), signal, sessions = null } = {}) {
+export async function readClaudeDesktopLineage({ home = homedir(), root = claudeDesktopSessionRoot(home), signal, sessions = null, includeState = false } = {}) {
   if (signal?.aborted) return new Map();
   const files = [];
   for (const account of await directories(root)) {
@@ -122,12 +125,23 @@ export async function readClaudeDesktopLineage({ home = homedir(), root = claude
       parentSession: { provider: 'claude', session: parent.session },
       source: 'claude_desktop_spawned_from' });
   }
+  if (includeState) for (const partition of partitions.values()) for (const item of partition.values()) {
+    if (claims.get(item.session) !== 1 || sessions && !sessions.has(item.session)) continue;
+    lineage.set(item.session, { cwd: item.cwd, ...lineage.get(item.session),
+      providerArchived: item.providerArchived, pullRequests: item.pullRequests || [], observedAt: Date.now() });
+  }
   // Reject cyclic Desktop metadata rather than inventing a root or parent.
   for (const session of [...lineage.keys()]) {
     const seen = new Set(); let cursor = session;
     while (lineage.has(cursor)) {
-      if (seen.has(cursor)) { for (const id of seen) lineage.delete(id); break; }
-      seen.add(cursor); cursor = lineage.get(cursor).parentSession.session;
+      if (seen.has(cursor)) {
+        for (const id of seen) {
+          if (!includeState) lineage.delete(id);
+          else { const { parentSession, parentCwd, source, ...state } = lineage.get(id); lineage.set(id, state); }
+        }
+        break;
+      }
+      seen.add(cursor); cursor = lineage.get(cursor).parentSession?.session;
     }
   }
   return lineage;
@@ -138,7 +152,7 @@ export async function readClaudeDesktopLineage({ home = homedir(), root = claude
 // discovery and unrelated provider controls must not wait for the entire scan.
 export async function observeClaudeDesktopLineage(options = {}, { read = readClaudeDesktopLineage, budgetMs = 1500 } = {}) {
   if (options.signal?.aborted) return new Map();
-  const root = options.root || claudeDesktopSessionRoot(options.home);
+  const root = (options.root || claudeDesktopSessionRoot(options.home)) + (options.includeState ? ':state' : ':lineage');
   let entry = observations.get(root);
   if (!entry) {
     entry = { value: new Map(), pending: null };

package/src/session-supervision/claude-sessions.js

@@ -6,7 +6,7 @@ import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { boundConversation, CONVERSATION_LIMITS, textContent } from './conversation-context.js';
 import { sessionTitle } from './session-titles.js';
 import { RECENT_SESSION_LIMIT, recentSessionWindow } from './discovery-window.js';
-import { observeClaudeDesktopLineage } from './claude-desktop-lineage.js';
+import { observeClaudeDesktopLineage, readClaudeDesktopLineage } from './claude-desktop-lineage.js';
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const MAX_PROJECTS = 256;
@@ -186,17 +186,19 @@ async function collect({ home = homedir(), limit = 100, session = null, priority
     }));
   }
   if (signal?.aborted) return [];
-  const desktopLineage = !session && cacheMetadata
-    ? await observeClaudeDesktopLineage({ home, signal, sessions: new Set(descriptors.map(item => item.session)) }) : new Map();
+  const desktopOptions = { home, signal, includeState: true, sessions: new Set(descriptors.map(item => item.session)) };
+  const desktopLineage = await (session ? readClaudeDesktopLineage(desktopOptions) : observeClaudeDesktopLineage(desktopOptions));
   const decorateLineage = candidate => {
     const origin = desktopLineage.get(candidate.session);
-    if (origin?.cwd === candidate.cwd && !candidate.parentSession)
-      return { ...candidate, parentSession: origin.parentSession, parentSessionSource: origin.source };
+    if (origin?.cwd === candidate.cwd)
+      return { ...candidate, ...(typeof origin.providerArchived === 'boolean' ? { archived: origin.providerArchived } : {}), pullRequests: origin.pullRequests || [],
+        ...(!candidate.parentSession && origin.parentSession ? { parentSession: origin.parentSession, parentSessionSource: origin.source } : {}) };
     return candidate;
   };
-  const selected = session ? descriptors : recentSessionWindow(descriptors, {
-    limit: maximum, priority: item => priorities.has(item.session),
-  });
+  const selected = session ? descriptors : [
+    ...recentSessionWindow(descriptors.filter(item => desktopLineage.get(item.session)?.providerArchived !== true), { limit: maximum, priority: item => priorities.has(item.session) }),
+    ...recentSessionWindow(descriptors.filter(item => desktopLineage.get(item.session)?.providerArchived === true), { limit: maximum, priority: item => priorities.has(item.session) }),
+  ];
   const filesToInspect = selected.slice(0, MAX_TRANSCRIPTS);
   let nextFile = 0;
   // Catalog prefixes are bounded independently of full transcript size. Use a
@@ -218,7 +220,7 @@ async function collect({ home = homedir(), limit = 100, session = null, priority
     const attempted = new Set(result.keys());
     for (const child of result.values()) {
       const origin = desktopLineage.get(child.session);
-      if (!origin || child.parentSessionSource !== origin.source || [...result.values()].some(item => item.session === origin.parentSession.session && item.cwd === origin.parentCwd)) continue;
+      if (!origin?.parentSession || child.parentSessionSource !== origin.source || [...result.values()].some(item => item.session === origin.parentSession.session && item.cwd === origin.parentCwd)) continue;
       for (const file of descriptors.filter(item => item.session === origin.parentSession.session)) {
         const key = `${file.session}\0${origin.parentCwd}`;
         if (attempted.has(key) || attempted.size >= MAX_TRANSCRIPTS || signal?.aborted) break;
@@ -243,7 +245,10 @@ async function collect({ home = homedir(), limit = 100, session = null, priority
     }
   }
   const sorted = [...result.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt || a.session.localeCompare(b.session));
-  return session ? sorted : recentSessionWindow(sorted, { limit: maximum, priority: item => priorities.has(item.session) });
+  return session ? sorted : [
+    ...recentSessionWindow(sorted.filter(item => item.archived !== true), { limit: maximum, priority: item => priorities.has(item.session) }),
+    ...recentSessionWindow(sorted.filter(item => item.archived === true), { limit: maximum, priority: item => priorities.has(item.session) }),
+  ];
 }
 
 export async function listClaudeSessions({ home, limit, prioritySessions, signal } = {}) {
@@ -256,6 +261,7 @@ export async function readClaudeSession(session, { home } = {}) {
   const matches = await collect({ home, limit: RECENT_SESSION_LIMIT, session: id });
   const selected = typeof session === 'object' && typeof session.cwd === 'string'
     ? matches.filter(item => item.cwd === session.cwd) : matches;
+  if (selected.length === 1 && selected[0].archived === true) throw Object.assign(new Error('Restore the original provider conversation before continuing.'), { code: 'session_archived' });
   return selected.length === 1 ? selected[0] : null;
 }
 

package/src/session-supervision/codex-app-server.js

@@ -1,3 +1,4 @@
+import { normalizePullRequests } from './pull-requests.js';
 import { delegatedNativeSandbox, canWriteWorkspace, authorizedWorktreeGitRoots } from './native-delegation.js';
 import { flexibleReasoning } from '../codex-plugins/simy/hooks/purpose-cycle.mjs';
 import { collectPurposeObservations, refreshPurposeObservations, repositoryIdentity } from './purpose-observer.js';
@@ -202,13 +203,19 @@ export function codexThreadMetadata(thread) {
   if (thread.parentThreadId || thread.source?.subAgent || thread.source?.subagent) return null;
   return {
     provider: 'codex', session: thread.id, cwd: thread.cwd,
+    pullRequests: normalizePullRequests(thread.pullRequests || thread.artifacts?.filter?.(item => item.type === 'pull_request')),
     ...(typeof thread.forkedFromId === 'string' && /^[0-9a-f-]{36}$/i.test(thread.forkedFromId) && thread.forkedFromId !== thread.id
       ? { parentSession: { provider: 'codex', session: thread.forkedFromId } } : {}),
     title: typeof thread.name === 'string' && thread.name.trim() ? thread.name.slice(0, 200) : '',
     source: typeof thread.source === 'string' ? thread.source : thread.source?.type || 'unknown',
     lastActivityAt: Number.isFinite(thread.updatedAt) ? thread.updatedAt * 1000 : null,
     model: typeof thread.model === 'string' ? thread.model : null,
-    observation: { source: 'codex_app_server', observedAt: Date.now() },
+    // Preserve native wait flags for presentation without changing isRunning,
+    // which also protects the provider writer lock. Unknown flags fail closed.
+    observation: { source: 'codex_app_server', observedAt: Date.now(),
+      ...(thread.status?.type === 'active' ? { activeFlags: Array.isArray(thread.status.activeFlags)
+        && thread.status.activeFlags.every(flag => ['waitingOnApproval', 'waitingOnUserInput'].includes(flag))
+        ? [...new Set(thread.status.activeFlags)] : null } : {}) },
     ...(thread.status?.type === 'active' || thread.status?.type === 'idle' ? { isRunning: thread.status.type === 'active' } : {}),
     availability: 'unknown',
   };

package/src/session-supervision/index.js

@@ -1,3 +1,5 @@
+import { sessionWorkState, compareSessionWork } from './work-state.js';
+import { normalizePullRequests } from './pull-requests.js';
 import { completionClaimUnbound } from '../codex-plugins/simy/hooks/completion-binding.mjs';
 import { pauseOrigin } from './autonomous-upgrade.js';
 import { effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/acceptance-policy.mjs';
@@ -123,7 +125,8 @@ function navigationParent(item, record) {
 }
 
 export async function discoverSessions({ root, openClient = openCodexAppServer, listClaude = listClaudeSessions,
-  inspectProcess = processIdentity, now = Date.now(), signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false } = {}) {
+  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false } = {}) {
+  const now = requestedNow ?? Date.now();
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
   const connected = new Set(connectedProviders);
@@ -174,11 +177,13 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   for (let index = 0; index < records.length; index++) {
     assertActive();
     const record = records[index];
-    if (record.provider !== 'codex') continue;
-    const isArchived = archiveStates.get(record.session) === true;
+    const claudeItem = record.provider === 'claude' ? claude.find(item => item.session === record.session && item.cwd === record.cwd) : null;
+    const archiveState = record.provider === 'codex' ? archiveStates.get(record.session) ?? (activeCodex.has(record.session) ? false : undefined) : claudeItem?.archived;
+    if (typeof archiveState !== 'boolean') continue;
+    const isArchived = archiveState;
     if (isArchived) await recordProviderArchive(root, record.provider, record.session, true, now);
     if (isArchived && record.providerArchived === true) continue;
-    if (!isArchived && !(record.providerArchived === true && (activeCodex.has(record.session) || archiveStates.get(record.session) === false))) continue;
+    if (!isArchived && !(record.providerArchived === true && archiveState === false)) continue;
     try { records[index] = await updateRecord(root, record.provider, record.session, current => {
       if (!current) return current;
       current.providerArchived = isArchived;
@@ -204,7 +209,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   const recordsByKey = new Map(records.map(record => [`${record.provider}:${record.session}`, record]));
   for (const item of [...discovered, ...claude, ...archivedCodex]) {
     if (includeArchived && item.archived === true) { byKey.set(`${item.provider}:${item.session}`, item); continue; }
-    if ((item.provider !== 'codex' || archiveStates.get(item.session) !== true) && recordsByKey.get(`${item.provider}:${item.session}`)?.providerArchived !== true) byKey.set(`${item.provider}:${item.session}`, item);
+    if (item.archived !== true && (item.provider !== 'codex' || archiveStates.get(item.session) !== true) && recordsByKey.get(`${item.provider}:${item.session}`)?.providerArchived !== true) byKey.set(`${item.provider}:${item.session}`, item);
   }
   const requiredAncestors = new Set();
   for (const item of byKey.values()) {
@@ -224,7 +229,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     const key = `${record.provider}:${record.session}`;
     // A hook observation can belong to an AI-created worker. Only explicit
     // supervision may restore a conversation absent from provider discovery.
-    if (!byKey.has(key) && (retainedSession(record) || requiredAncestors.has(key) && (record.observedAt || record.admission?.validatedAt))) byKey.set(key, {
+    if (!byKey.has(key) && (retainedSession(record) || includeArchived && record.listHidden === true || requiredAncestors.has(key) && (record.observedAt || record.admission?.validatedAt))) byKey.set(key, {
       provider: record.provider, session: record.session, cwd: record.cwd, title: '', archived, source: record.admission?.source || 'hook',
       lastActivityAt: record.observedAt || record.admission?.validatedAt || record.run?.updatedAt || null,
       observation: { source: record.admission?.source || `${record.provider}_hook`, observedAt: record.observedAt || record.admission?.validatedAt || null },
@@ -236,11 +241,11 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   const catalog = [...byKey.values()].map(item => {
     const record = recordsByKey.get(`${item.provider}:${item.session}`);
     const parentSession = navigationParent(item, record);
-    return { ...item, ...(parentSession ? { parentSession } : {}) };
+    return { ...item, localHidden: record?.listHidden === true, ...(parentSession ? { parentSession } : {}) };
   });
-  const items = [...recentSessionWindow(catalog.filter(item => item.archived !== true), {
+  const items = [...recentSessionWindow(catalog.filter(item => item.archived !== true && !item.localHidden), {
     priority: item => retainedSession(recordsByKey.get(`${item.provider}:${item.session}`)),
-  }), ...recentSessionWindow(catalog.filter(item => item.archived === true))];
+  }), ...recentSessionWindow(catalog.filter(item => item.archived === true || item.localHidden), { priority: item => item.localHidden })];
   // Include archived ancestors of active rows even when archive visibility is off.
   const catalogByKey = new Map(catalog.map(item => [`${item.provider}:${item.session}`, item]));
   const includedKeys = new Set(items.map(item => `${item.provider}:${item.session}`));
@@ -295,14 +300,14 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     const continuationIssue = liveHook && run ? !run.managed && !upgradeable
       ? { code: 'existing_loop', reason: 'This conversation already has a Delivery Loop. Use its existing controls.' }
       : TERMINAL_RUNS.has(run.state) ? { code: 'task_settled', reason: 'This supervised task has settled. Review its existing status before continuing.' } : null : null;
-    let isRunning = item.isRunning;
+    let isRunning = item.isRunning, observation = item.observation;
     const hookIsNewer = Number.isFinite(record?.runtime?.observedAt) && Number.isFinite(item.lastActivityAt) && record.runtime.observedAt > item.lastActivityAt;
     if ((isRunning === undefined || isRunning === false && hookIsNewer) && record?.runtime?.process?.identity && record.cwd === item.cwd) {
       try {
         // A hook newer than the persisted provider activity may describe a
         // new turn. Require its same live process; older hooks cannot override
         // a more recent completed provider turn.
-        if (record.runtime.isRunning && await inspectProcess(record.runtime.process.pid) === record.runtime.process.identity) isRunning = true;
+        if (record.runtime.isRunning && await inspectProcess(record.runtime.process.pid) === record.runtime.process.identity) { isRunning = true; observation = { ...item.observation, observedAt: record.runtime.observedAt }; }
         else if (isRunning === undefined && !record.runtime.isRunning) isRunning = false;
       } catch { /* Unverified process leaves runtime status unknown. */ }
     }
@@ -314,12 +319,14 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       ...(item.providerGoal !== undefined ? { providerGoal: item.providerGoal } : {}),
       ...(item.goalReadState ? { goalReadState: item.goalReadState } : {}),
       tracked: typeof record?.tracked === 'boolean' ? record.tracked : record?.monitor === true,
+      providerArchived: archived, localHidden: record?.listHidden === true,
       archived,
+      pullRequests: normalizePullRequests(item.pullRequests),
       autoContinue: !archived && record?.autoContinue === true,
       autoContinueEpoch: record?.autoContinue === true ? record.autoContinueEpoch : null,
       autoContinueAvailability: availability,
       ...autoContinueState(record, isRunning, availability),
-      lastActivityAt: item.lastActivityAt, observation: item.observation, availability: item.availability,
+      lastActivityAt: item.lastActivityAt, observation, availability: item.availability,
       taskId: run?.managed?.taskId || record?.associationTaskId || null,
       binding: { mode, taskId: run?.managed?.taskId || record?.associationTaskId || null },
       originalSessionTarget: originalSessionTarget(item.provider, item.session),
@@ -343,8 +350,12 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     }
   }));
   assertActive();
-  projected.sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
-  return { sessions: projected, providers: { codex: { discovery: !connected.has('codex') ? 'disconnected' : codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: !connected.has('claude') ? 'disconnected' : claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
+  // Provider reads stamp observations after discovery starts. Compare them at
+  // projection time, while preserving an explicitly supplied verification clock.
+  const stateNow = requestedNow ?? Date.now();
+  for (const candidate of projected) candidate.workState = sessionWorkState(candidate, recordsByKey.get(`${candidate.provider}:${candidate.session}`)?.run, { now: stateNow });
+  projected.sort(compareSessionWork);
+  return { sessions: includeArchived ? projected : projected.filter(item => !item.archived && !item.localHidden), providers: { codex: { discovery: !connected.has('codex') ? 'disconnected' : codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: !connected.has('claude') ? 'disconnected' : claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
 }
 
 // Saving consent needs an exact admitted identity, not another provider RPC.

package/src/session-supervision/pull-requests.js

@@ -0,0 +1,52 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execute = promisify(execFile);
+const PR_URL = /^https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)\/?$/;
+export function normalizePullRequests(value) {
+  const rows = Array.isArray(value) ? value : value ? [value] : [];
+  const unique = new Map();
+  for (const row of rows.slice(0, 32)) {
+    const url = typeof row === 'string' ? row : row?.url;
+    if (!PR_URL.test(url || '')) continue;
+    const state = String(row.state || row.status || '').toUpperCase();
+    unique.set(url, { url, state: row.merged === true || row.mergedAt ? 'MERGED' : ['OPEN', 'CLOSED', 'MERGED'].includes(state) ? state : 'UNKNOWN',
+      reviewDecision: ['CHANGES_REQUESTED', 'APPROVED', 'REVIEW_REQUIRED'].includes(row.reviewDecision) ? row.reviewDecision : null,
+      checkedAt: Number.isFinite(row.checkedAt) ? row.checkedAt : null });
+  }
+  return [...unique.values()];
+}
+
+// One cache per host, bounded concurrency, no network work on the 3s status tick.
+export function createPullRequestObserver({ read = async url => {
+  const match = PR_URL.exec(url);
+  const { stdout } = await execute('gh', ['pr', 'view', match[3], '--repo', `${match[1]}/${match[2]}`, '--json', 'url,state,reviewDecision,mergedAt'], { timeout: 2000, maxBuffer: 64 * 1024, windowsHide: true });
+  return JSON.parse(stdout);
+}, now = Date.now, ttlMs = 60_000, budgetMs = 3500 } = {}) {
+  const cache = new Map();
+  let cursor = 0;
+  return async (sessions, { signal } = {}) => {
+    const catalog = [...new Set(sessions.flatMap(item => (item.pullRequests || []).map(pr => pr.url)))];
+    // Continue after the last attempted URL, including when slow reads consume
+    // the budget. Restarting at row zero can starve the tail indefinitely.
+    const start = catalog.length ? cursor % catalog.length : 0;
+    const urls = [...catalog.slice(start), ...catalog.slice(0, start)].slice(0, 128);
+    let next = 0; const started = now();
+    await Promise.all(Array.from({ length: Math.min(4, urls.length) }, async () => {
+      while (next < urls.length && !signal?.aborted && now() - started < budgetMs) {
+        const url = urls[next++], previous = cache.get(url);
+        if (previous && now() - previous.at < ttlMs) continue;
+        try { const rows = normalizePullRequests(await read(url));
+          if (rows[0]?.url !== url) throw new Error('PR identity mismatch');
+          cache.set(url, { at: now(), value: { ...rows[0], checkedAt: now(), fetchFailed: false } });
+        } catch { cache.set(url, { at: now(), value: { ...(previous?.value || { url, state: 'UNKNOWN' }), fetchFailed: true } }); }
+      }
+    }));
+    cursor = catalog.length ? (start + next) % catalog.length : 0;
+    while (cache.size > 512) cache.delete(cache.keys().next().value);
+    return sessions.map(item => ({ ...item, pullRequests: (item.pullRequests || []).map(pr => {
+      const observed = cache.get(pr.url)?.value;
+      const value = observed ? { ...pr, ...observed, ...(observed.state === 'UNKNOWN' ? { state: pr.state } : {}) } : pr;
+      return { ...value, stale: !Number.isFinite(value.checkedAt) || now() - value.checkedAt > ttlMs };
+    }) }));
+  };
+}

package/src/session-supervision/work-state.js

@@ -0,0 +1,84 @@
+// Display-only state. Tracking/auto-continue consent is never evidence of execution.
+export const WORK_STATE_TTL_MS = 45_000;
+const freshObservation = (checkedAt, now) => Number.isFinite(checkedAt) && checkedAt <= now && now - checkedAt <= WORK_STATE_TTL_MS;
+export function sessionWorkState(candidate, run, { now = Date.now(), provider } = {}) {
+  const checkedAt = candidate.observation?.observedAt ?? null;
+  const stale = !freshObservation(checkedAt, now);
+  const fetchFailed = provider?.discovery === 'unavailable';
+  const freshness = { checkedAt, stale, fetchFailed };
+  const result = (state, label, reason, nextAction = null, needsAttention = false) =>
+    ({ state, label, reason, nextAction, needsAttention, ...freshness });
+  if (candidate.archived || candidate.localHidden) return result('archived', 'アーカイブ済み', candidate.localHidden ? 'この一覧だけで非表示にしています。' : '元の会話がアーカイブされています。', 'restore');
+  let nativeRuntimeUnknown = false;
+  if (Object.hasOwn(candidate.observation || {}, 'activeFlags')) {
+    const flags = candidate.observation.activeFlags;
+    nativeRuntimeUnknown = stale || fetchFailed || !Array.isArray(flags) || flags.some(flag => !['waitingOnApproval', 'waitingOnUserInput'].includes(flag));
+    if (!nativeRuntimeUnknown && flags.includes('waitingOnApproval')) return result('approval', '承認待ち', '元のAIが操作の承認を待っています。', 'review_approval', true);
+    if (!nativeRuntimeUnknown && flags.includes('waitingOnUserInput')) return result('question', '回答待ち', '元のAIが回答を待っています。', 'answer', true);
+  }
+  // Never display a cached active flag as a live observation after a sleep/outage.
+  if (!nativeRuntimeUnknown && !stale && !fetchFailed && candidate.isRunning === true) return result('running', 'AIが対応中', '元のAIが実行中です。');
+  const approval = run?.pendingApproval || run?.managed?.pendingApproval;
+  const question = run?.understandingQuestion || run?.managed?.understandingQuestion || run?.managed?.userQuestion;
+  const phase = run?.phase || run?.managed?.phase;
+  const stopped = run?.state === 'stopped' || run?.stopReason?.actor === 'user' ||
+    run?.state === 'paused' && /^(Paused by user\.|Automatic continuation paused by user\.|User interrupted the provider\.|Stopped by user\.)$/.test(run.reason || '');
+  if (stopped) return result('stopped', '自分で停止', '停止の指示を維持しています。', 'resume');
+  if (approval && !approval.denied || candidate.decisionRequest?.kind === 'approval')
+    return result('approval', '承認待ち', candidate.decisionRequest?.context || '実行する操作の確認が必要です。', 'review_approval', true);
+  if (question || phase === 'needs_clarification' || candidate.analysis?.state === 'needs_user' || candidate.decisionRequest?.kind === 'question')
+    return result('question', '回答待ち', candidate.decisionRequest?.question || '続けるために回答が必要です。', 'answer', true);
+  if ((run?.autoRecovery || run?.managed?.autoRecovery) && ['recovery_required', 'auto_resuming'].includes(run.state)) return result('checking', 'AIが状況確認中', '自動復旧の結果を待っています。');
+  if (['failed', 'recovery_required', 'budget_exhausted'].includes(run?.state) || candidate.analysis?.state === 'failed' || candidate.autoContinueStatus === 'error')
+    return result('error', '対応が必要', run?.reason || '作業が中断されています。', run?.canResume || run?.canReplan ? 'resume' : 'open_original', true);
+  if (run?.dependencyWait || run?.managed?.dependencyWait) return result('waiting', '依存条件待ち', '条件が変わるまで待機します。');
+  if (['blocked', 'verification_pending', 'reported_done', 'paused'].includes(run?.state) || candidate.analysis?.state === 'continue' && candidate.autoContinue !== true || candidate.autoContinueStatus === 'needs_user')
+    return result('unfinished', '残りの作業あり', run?.reason || candidate.analysis?.reason || '未完了の作業を再開できます。', 'resume', true);
+  if (nativeRuntimeUnknown) return result('unknown', '実行状態を確認できません', '元のAIの最新の実行状態を確認できません。', 'refresh');
+  const prs = candidate.pullRequests || [];
+  if (prs.some(pr => pr.state === 'OPEN' && pr.reviewDecision === 'CHANGES_REQUESTED')) return result('changes_requested', 'PRの修正要求', '関連PRに修正要求があります。', 'open_pr', true);
+  if (prs.some(pr => pr.state === 'OPEN')) return result('review', 'PRレビュー待ち', '関連PRのレビュー・統合を待っています。', 'open_pr');
+  if (prs.some(pr => pr.state === 'UNKNOWN' || pr.fetchFailed || pr.stale)) return result('pr_unknown', 'PRの状態確認待ち', '関連PRの最新状態を確認できません。', 'refresh');
+  // A merge or no-follow-up recommendation is not task completion. no_action
+  // also covers casual chat, cancellation and optional future improvements.
+  if (run?.state === 'completed' || !run && candidate.providerGoal?.status === 'complete')
+    return result('completed', '完了', '会話の作業完了を確認しました。');
+  if (candidate.isRunning === true && (stale || fetchFailed)) return result('unknown', '実行状態を確認できません', '最終確認後の実行状態は不明です。', 'refresh');
+  if (run && ['active', 'auto_resuming'].includes(run.state) || ['queued', 'analyzing'].includes(candidate.analysis?.state)) return result('checking', 'AIの対応待ち', '次の処理・状態確認を待っています。');
+  return result('idle', '次の依頼待ち', '現在の実行や対応依頼は確認されていません。');
+}
+
+export function compareSessionWork(a, b) {
+  const priority = item => item.workState?.state === 'running' ? 0 : item.workState?.needsAttention ? 1 : 2;
+  return priority(a) - priority(b) || (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || `${a.provider}:${a.session}`.localeCompare(`${b.provider}:${b.session}`);
+}
+
+// Completion belongs to the whole known family. Idle history alone does not
+// create a human task; positively unfinished descendants do prevent completion.
+export function reconcileFamilyCompletion(sessions) {
+  const byKey = new Map(sessions.map(item => [`${item.provider}:${item.session}`, item]));
+  for (const child of sessions) {
+    if (['idle', 'completed', 'archived'].includes(child.workState?.state)) continue;
+    const seen = new Set(); let parent = child.parentSession;
+    while (parent) {
+      const key = `${parent.provider}:${parent.session}`;
+      if (seen.has(key)) break;
+      seen.add(key); const ancestor = byKey.get(key);
+      if (!ancestor) break;
+      if (ancestor.workState?.state === 'completed') ancestor.workState = { ...ancestor.workState,
+        state: 'family_unfinished', label: '子の作業が未完了', reason: '関連する子の作業が残っています。', nextAction: 'review_children', needsAttention: false };
+      parent = ancestor.parentSession;
+    }
+  }
+  return sessions;
+}
+
+// Fast connection heartbeats may carry the previous full projection while a
+// reader is blocked. Expire live labels there too, without losing pending work.
+export function expireSessionWorkState(candidate, now = Date.now()) {
+  const previous = candidate.workState;
+  if (!previous || freshObservation(previous.checkedAt, now)) return candidate;
+  if (previous.state !== 'running') return previous.stale ? candidate : { ...candidate, workState: { ...previous, stale: true } };
+  return { ...candidate, workState: { ...previous, state: 'unknown', label: '実行状態を確認できません',
+    reason: '最終確認後の実行状態は不明です。', nextAction: 'refresh', needsAttention: false, stale: true } };
+}