@awak-app/simy-cli 0.7.9 → 0.7.11

package/src/orchestrator/instruction.js

@@ -174,20 +174,20 @@ export function buildCodingInstruction(
     section(
       "problem_solving_protocol",
       [
-        "Treat implementation as hypothesis testing: state assumptions, list plausible causes or approaches, inspect discriminating evidence, then choose the smallest strategy supported by that evidence.",
+        "Use the shared scene reasoning cycle for implementation and retries. Let the current issue determine useful perspectives and the smallest next check; do not require a separate reasoning workflow.",
         attemptNumber > 1
           ? "This is a retry. Repair clear failures directly; compare plausible causes when needed. Reasoning notes are advisory, not a prerequisite to editing."
           : "For the first attempt, investigate material uncertainty before a risky operation; use a reasonable assumption for low-impact reversible choices and verify as you proceed.",
         attemptNumber > 1
-          ? "Explain exactly what changed from the previous attempt and why the new evidence supports this strategy."
-          : "Record the uncertainty, first verification, concrete evidence checked, observed result, selected hypothesis, and strategy in the structured result.",
+          ? "When useful, briefly note what changed the interpretation or next check; an extra reasoning explanation is not required to perform the repair."
+          : "Use existing result fields for actual checks and outcomes; reasoning notes and the hypothesis sheet are optional.",
       ].join("\n"),
     ),
     section(
       "execution_contract",
       [
         "Read the repository instructions and current git state before editing.",
-        "Before editing, resolve the highest uncertainty with the first discriminating verification. If it cannot be resolved, stop and report a fallback instead of claiming completion.",
+        "Use the shared scene reasoning cycle to investigate uncertainty that affects the selected operation. If that operation cannot safely proceed, retain its blocker and choose independent authorized work or a smaller useful check. Do not claim unresolved outcomes are complete.",
         "Preserve user changes and keep the diff scoped to the requirement.",
         "Run relevant tests, inspect the final diff, commit, push, and create or update a PR.",
         `The PR must target ${charter.base_branch}.`,

package/src/orchestrator/loop.js

@@ -631,7 +631,7 @@ async function handleFailedAudit({
       state.ai_strategy_diagnoses.push(key);
       state.ai_strategy_diagnoses = state.ai_strategy_diagnoses.slice(-32);
       findings.push({ passed: false, code: 'AI_STRATEGY_CHANGE_REQUIRED', severity: 'blocker', target: 'retry_loop',
-        explanation: 'Investigate the repeated failure with LLM context synthesis, alternatives and tool evidence. Choose a different reversible method before another attempt; do not repeat uncertain effects or ask a person to certify technical correctness.', repairability: 'auto', blocker_kind: 'machine' });
+        explanation: 'Investigate the repeated failure with the shared scene reasoning cycle: understand this scene, derive and select useful perspectives, then connect the interpretation to the next check. Choose a different reversible method before another attempt; do not repeat uncertain effects or ask a person to certify technical correctness.', repairability: 'auto', blocker_kind: 'machine' });
       snapshot.final_audit = { ...(snapshot.final_audit || {}), passed: false, findings, requires_human: false, auto_repairable: true };
       appendEvent(snapshot, 're_instructing', 'AI diagnosis is required before treating technical repetition as an execution blocker.', { code: 'ai_strategy_change', attempt_number: attemptNumber });
       await publish(snapshot, 're_instructing', onUpdate);

package/src/orchestrator/problem-solving.js

@@ -94,9 +94,9 @@ export function evaluateRetryProblemSolving(attempt, previousAttempt) {
 export function problemSolvingResultContract() {
   return [
     hypothesisSheetInstruction,
-    "problem_solving must be an object with hypotheses, selected_hypothesis_id, evidence_checked, strategy, and changed_from_previous.",
+    "problem_solving must be an object; {} is valid when no optional reasoning notes are useful. When recording notes, use hypotheses, selected_hypothesis_id, evidence_checked, strategy, and changed_from_previous.",
     "Each hypothesis must use {id, statement}; evidence_checked must list concrete observations or commands.",
-    "On attempt 1, record the assumptions, hypotheses considered, selected hypothesis, and implementation strategy; changed_from_previous may be null.",
+    "Use the shared scene reasoning cycle on every attempt. Record useful assumptions or interpretations briefly when helpful; changed_from_previous may be null.",
     "On retry, use reasoning proportional to the uncertainty. If the repair is clear, make it and verify it; do not invent a fixed number of hypotheses or change a working strategy merely to satisfy a form. For persistent unexplained failures, compare plausible causes and inspect discriminating evidence. These reasoning notes are advisory; unchanged failures are still subject to the retry circuit.",
   ].join("\n");
 }

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',
   };
@@ -617,7 +624,7 @@ async function frozenNativeSandbox(record, root, signal) {
   return policy;
 }
 
-export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, runPeerReview = runStructuredProviderReview } = {}) {
+export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onStarted = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, runPeerReview = runStructuredProviderReview } = {}) {
   const run = record.run, decision = run.managed?.decision;
   if(run.managed?.enrollment?.nativeAuthorityDigest && run.managed.enrollment.nativeAuthorityDigest!==createHash('sha256').update(JSON.stringify([run.managed.providerSandbox,run.managed.providerSandboxSource])).digest('hex'))throw new CodexAppServerError('permission_narrowed','Frozen native enrollment authority changed; do not dispatch with the altered ceiling.');
   if (!decision || !run.managed.autonomyPolicy) throw new CodexAppServerError('decision', 'An assessed action is required before Codex dispatch.');
@@ -672,7 +679,7 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
   };
   const beforeEvidence = searchEnabled(run.managed) && !reviewing ? await captureWorkspace() : null;
   let evidenceQueue = Promise.resolve(), evidenceFailure = null;
-  let activeTurnId = null, turnCompleted = false, turnStart = null;
+  let activeTurnId = null, turnCompleted = false, turnStart = null, startReceipt = null;
   let usage = null, lastTotal = null;
   try {
     // An unavailable login is a connection dependency, not an action approval.
@@ -789,7 +796,7 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
     }
     if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Worker dispatch was cancelled during preparation.');
     const done = new Promise((resolve, reject) => {
-      let turnId = null, completion = null, settled = false;
+      let turnId = null, completion = null, settled = false, startRecorded = false;
       const messages = new Map();
       const activeTools = new Set();
       const earlyActivity = [];
@@ -819,7 +826,7 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       const cancelled = () => finish(new CodexAppServerError('cancelled', 'Codex turn was cancelled.'));
       const closed = () => finish(new CodexAppServerError('closed', 'Codex app-server closed before turn completion.'));
       const complete = () => {
-        if (!completion || !turnId || completion.turn?.id !== turnId) return;
+        if (!completion || !turnId || !startRecorded || completion.turn?.id !== turnId) return;
         turnCompleted = true;
         if (completion.turn.status !== 'completed') return finish(new CodexAppServerError('turn_failed', 'Codex turn did not complete.'));
         const message = messages.get(turnId);
@@ -846,7 +853,10 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       client.child.once('close', closed);
       turnStart = client.request('turn/start', { threadId: targetSession, input: [{ type: 'text', text: `${prompt}\n${purposeInstruction}` }], cwd: isolated ? executionCwd : record.cwd,
         model: run.managed.resumeModel, ...(isolated ? {sandboxPolicy} : {}) })
-        .then(response => { turnId = response?.turn?.id; activeTurnId = turnId; if (!turnId) finish(new CodexAppServerError('turn_failed', 'Codex did not start a turn.')); else {
+        .then(async response => { turnId = response?.turn?.id; activeTurnId = turnId; if (!turnId) finish(new CodexAppServerError('turn_failed', 'Codex did not start a turn.')); else {
+          startReceipt = Promise.resolve().then(() => onStarted({ turnId, session: targetSession }));
+          await startReceipt;
+          startRecorded = true;
           for (const params of earlyUsage) if (params.turnId === turnId) observeUsage(params);
           for (const params of earlyActivity) if (params.turnId === turnId) observeActivity(params.method, params);
           complete();
@@ -912,6 +922,7 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
     await evidenceQueue;
     throw error;
   } finally {
+    if (startReceipt) await startReceipt.catch(() => {});
     if (turnStart && !client.closed) {
       // Only the controller-owned target may be interrupted. Isolated reads
       // never load or change the original conversation's policy defaults.

package/src/session-supervision/continuation-analysis.js

@@ -1,3 +1,4 @@
+import { withSceneReasoning } from '../codex-plugins/simy/hooks/scene-reasoning.mjs';
 import { readCodexConversation } from './codex-app-server.js';
 import { readClaudeConversation } from './claude-sessions.js';
 import { boundConversation, boundProviderGoal, providerGoalEvidence, sanitizedText } from './conversation-context.js';
@@ -5,7 +6,7 @@ import { runStructuredProviderReview } from '../sqm/review-worker.js';
 import { inspectProviderStatus } from '../desktop-status.js';
 import { createHash } from 'node:crypto';
 
-export const CONTINUATION_ANALYSIS_VERSION = 5;
+export const CONTINUATION_ANALYSIS_VERSION = 6;
 const BLOCKER_TYPES = ['approval', 'missing_information', 'external_dependency', 'execution_failure'];
 const STATES = ['continue', 'no_action', 'needs_user', 'waiting', 'uncertain'];
 const string = maximum => ({ type: 'string', maxLength: maximum });
@@ -228,7 +229,7 @@ export async function analyzeContinuation(candidate, {
     await beforeProviderDispatch();
     if (signal?.aborted) return uncertain('Conversation analysis was cancelled.', 'cancelled');
     result = await runProvider(candidate.provider, {
-      system: SYSTEM, prompt: `Classify this conversation evidence only (older history omitted: ${context.truncated}):\n${JSON.stringify(context.providerGoal ? { originalProviderGoal: context.providerGoal, messages: context.messages } : context.messages)}`, output_schema: OUTPUT_SCHEMA,
+      system: withSceneReasoning(SYSTEM), prompt: `Classify this conversation evidence only (older history omitted: ${context.truncated}):\n${JSON.stringify(context.providerGoal ? { originalProviderGoal: context.providerGoal, messages: context.messages } : context.messages)}`, output_schema: OUTPUT_SCHEMA,
     }, { ...providerOptions, signal, readOnlyAnalysis: true, beforeDispatch: beforeProviderDispatch });
   } catch (error) {
     if (error?.code === 'desktop_access_required') return uncertain('SIMY organization access is required before checking this conversation.', 'desktop_access_required');

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/purpose-instruction.js

@@ -1,3 +1,5 @@
+import { withSceneReasoning } from '../codex-plugins/simy/hooks/scene-reasoning.mjs';
+import { currentRecoveryIncident, unresolvedRecoveryContext } from '../codex-plugins/simy/hooks/recovery-incident.mjs';
 import { recallPerspectives, perspectiveInstruction } from '../codex-plugins/simy/hooks/perspective-memory.mjs';
 import { loadHypothesisKnowledge, hypothesisKnowledgeInstruction } from '../sqm/hypothesis-knowledge.js';
 import { selectiveRuleReview, applicableRuleIds } from '../codex-plugins/simy/hooks/purpose-rule-policy.mjs';
@@ -40,12 +42,18 @@ export async function loadPurposeRuleSet() {
   return { digest: createHash('sha256').update(JSON.stringify(sources)).digest('hex'), rules };
 }
 export async function buildPurposeInstruction(managed, { reviewer = false, cwd, webOrigin, allowNetwork = false, signal, knowledgeLoader = loadHypothesisKnowledge, authorizeKnowledgeNetwork, root: memoryRoot, record, memoryLoader = recallPerspectives } = {}) {
-  if (!managed?.purpose?.enabled) return '';
+  if (!managed?.purpose?.enabled) return withSceneReasoning();
   const ruleSet = await loadPurposeRuleSet();
   if (ruleSet.digest !== managed.purpose.ruleDigest) throw Object.assign(new Error('Purpose workflow changed; refresh its rule inventory before dispatch.'), { code: 'purpose_rules_changed' });
   if (reviewer && selectiveRuleReview(managed)) return `${llmDecisionInstruction}\nIndependently verify the original acceptance criteria and applicable canonical obligations from actual evidence. Consult the inventory as needed after forming an LLM judgment; do not enumerate every ID or impose core controls as universal checklist gates. Report only rules actually evaluated; omitted inventory entries are not passed or not_applicable. Known applicable obligations ${JSON.stringify(applicableRuleIds(managed))} must be independently assessed and cannot be discarded by worker claims. Do not copy worker dispositions as proof. Failed, unavailable or missing evidence remains unverified with a concrete acquisition/repair finding. No unrelated rule coverage obligation is implied.\nruleSet: ${JSON.stringify(ruleSet.rules.map(rule => ({ ...rule, path: fileURLToPath(new URL(rule.file, root)) })))}`;
   if (reviewer) return `${llmDecisionInstruction}\nCanonical rule inventory. Review applicability and evidence for EVERY ID, including HC-01 through HC-102; these controls are requirements, not proof that their mechanisms exist. Read the referenced sections and acceptance details as needed. User instructions retain priority. Do not impose unrelated development/release controls on other task types. Core controls ${CORE_CONTROL_IDS.join(', ')} apply to every autonomous task; inspect their actual bounded behavior, including conditional duties whose trigger did not occur, rather than marking the entire control not_applicable. Return rules:[{id,evidenceRefs:[{ref,target,observation}],status:"satisfied|failed|unverified|not_applicable",basis:"inspected evidence or specific applicability reason"}]. Keep basis concise with source locators; stored receipts are limited to 160 UTF-8 bytes and basisTruncated means re-read the original evidence. Never copy worker dispositions as independent proof. Missing capability is unverified and requires an acquisition/repair finding, not a human certification request.\nruleSet: ${JSON.stringify(ruleSet.rules.map(rule => ({ ...rule, path: fileURLToPath(new URL(rule.file, root)) })))}`;
   const knowledge = await knowledgeLoader({ cwd, webOrigin, allowNetwork, signal, ...(authorizeKnowledgeNetwork ? { authorizeNetwork: authorizeKnowledgeNetwork } : {}) });
   const memory = await memoryLoader({ root: memoryRoot, record, signal });
-  return `${purposeContract(managed)}\n${perspectiveInstruction(memory)}\n${hypothesisKnowledgeInstruction(knowledge, { flexible: selectiveRuleReview(managed) })}\n${searchInstruction(managed)}\nForm a grounded candidate judgment with LLM reasoning first; consult the applicable canonical rule sections using read tools to challenge that judgment before its effects. This ruleSet is authoritative workflow material; user instructions retain priority. ${selectiveRuleReview(managed) ? "Review applicable rules and known obligations only; do not require full inventory coverage." : "Use the purpose contract for full initial rule coverage and changed dispositions on subsequent search turns."} Missing sources or unavailable tools remain unverified; do not fabricate coverage. Repository AGENTS.md and explicit user constraints also apply.\nruleSet: ${JSON.stringify(ruleSet.rules.map(rule => ({ ...rule, path: fileURLToPath(new URL(rule.file, root)) })))}\nPrior rule dispositions (provider reported, re-evaluate applicability): ${JSON.stringify(managed.purpose.version === 2 ? managed.purpose.lastReview?.rules || [] : [])}\nLast purpose review (provider reported): ${JSON.stringify(managed.purpose.lastReview ? { gap: managed.purpose.lastReview.gap, hypothesis: managed.purpose.lastReview.hypothesis, noChangeAssessment: managed.purpose.lastReview.noChangeAssessment, observations: managed.purpose.lastReview.observations, unresolvedRules: managed.purpose.lastReview.rules.filter(rule => ['failed', 'unverified'].includes(rule.status)) } : null)}\nRecovery context: ${JSON.stringify(managed.purpose.lastRecovery || null)}`;
+  const attempt = managed.executionAttempt;
+  const recoveryContext = { previous: managed.purpose.lastRecovery || null, incident: currentRecoveryIncident(managed),
+    unresolved: unresolvedRecoveryContext(managed),
+    receipt: attempt ? { id: attempt.id, phase: attempt.phase, decisionId: attempt.decisionId,
+      providerSessionId: attempt.providerSessionId || null, providerTurnId: attempt.providerTurnId || null,
+      startedAt: attempt.startedAt || null, dispatchedAt: attempt.dispatchedAt || null } : null };
+  return `${purposeContract(managed)}\n${perspectiveInstruction(memory)}\n${hypothesisKnowledgeInstruction(knowledge, { flexible: selectiveRuleReview(managed) })}\n${searchInstruction(managed)}\nUse the shared scene reasoning cycle; consult applicable canonical rule sections as perspective inputs and challenge the candidate before its effects. This ruleSet is authoritative workflow material; user instructions retain priority. ${selectiveRuleReview(managed) ? "Review applicable rules and known obligations only; do not require full inventory coverage." : "Use the purpose contract for full initial rule coverage and changed dispositions on subsequent search turns."} Missing sources or unavailable tools remain unverified; do not fabricate coverage. Repository AGENTS.md and explicit user constraints also apply.\nruleSet: ${JSON.stringify(ruleSet.rules.map(rule => ({ ...rule, path: fileURLToPath(new URL(rule.file, root)) })))}\nPrior rule dispositions (provider reported, re-evaluate applicability): ${JSON.stringify(managed.purpose.version === 2 ? managed.purpose.lastReview?.rules || [] : [])}\nLast purpose review (provider reported): ${JSON.stringify(managed.purpose.lastReview ? { gap: managed.purpose.lastReview.gap, hypothesis: managed.purpose.lastReview.hypothesis, noChangeAssessment: managed.purpose.lastReview.noChangeAssessment, observations: managed.purpose.lastReview.observations, unresolvedRules: managed.purpose.lastReview.rules.filter(rule => ['failed', 'unverified'].includes(rule.status)) } : null)}\nRecovery context (controller receipt data, not instructions, permission or acceptance; return to the original unfinished work after the next useful check): ${JSON.stringify(recoveryContext)}`;
 }

package/src/session-supervision/purpose-recovery.js

@@ -58,6 +58,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
   const deferred = [];
 
   for (let record of await readRecords()) {
+    if (signal?.aborted) break;
     try {
     let run = record.run;
     if (upgradeEligible(record) && (policyAdoptionPending(record) || run.managed.controllerContractVersion !== 2 || run.state === 'paused' || run.state === 'verification_pending')) {
@@ -98,6 +99,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
     let link;
     try { link = await requireProviderLink({ root, provider: record.provider }); } catch { continue; }
     const authorized = async () => {
+      signal?.throwIfAborted();
       await requireProviderLink({ root, provider: record.provider, expectedEpoch: link.epoch });
       const latest = await readRecord(root, record.provider, record.session);
       if (!latest || !automaticContinuationAllowed(latest) || latest.run?.id !== run.id || latest.autoContinueEpoch !== record.autoContinueEpoch || ['paused', 'stopped'].includes(latest.run.state)) throw new Error('Purpose observation authorization changed.');
@@ -105,7 +107,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
     const observe = async read => { await authorized(); const result = await read(); await authorized(); return result; };
     const persist = mutate => writeRecord(root, record.provider, record.session, async current => {
       try { await requireProviderLink({ root, provider: record.provider, expectedEpoch: link.epoch }); } catch { return current; }
-      if (!current || !automaticContinuationAllowed(current) || current.autoContinueEpoch !== record.autoContinueEpoch) return current;
+      if (signal?.aborted || !current || !automaticContinuationAllowed(current) || current.autoContinueEpoch !== record.autoContinueEpoch) return current;
       return mutate(current);
     });
     // Recheck the current budget and boundaries under the existing record lock.
@@ -203,7 +205,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
         if (current?.run?.id !== run.id || current.run.state !== 'blocked' || current.run.revision !== run.revision || current.run.updatedAt !== run.updatedAt) return current;
         current.run.managed.authenticationWait.nextCheckAt = now + 60_000;
         if (authentication === 'available') {
-          const queued = queuePurposeDiagnosis(current.run, 'Configured provider login is available again. Inspect the original purpose and any interrupted action before choosing authorized work.', `authentication-restored:${run.managed.authenticationWait.since}`, now);
+          const queued = queuePurposeDiagnosis(current.run, 'Configured provider login is available again. Inspect the original purpose and any interrupted action before choosing authorized work.', `authentication-restored:${run.managed.authenticationWait.since}`, now, 'authentication');
           if (queued) delete current.run.managed.authenticationWait;
         }
         return current;
@@ -219,7 +221,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
         current.run.managed.purpose.observationState = observed.state;
         return current;
       });
-      if (observed.state === 'idle') obstacle = { type: 'idle_without_checkpoint', detail: observed.turnId };
+      if (observed.state === 'idle' && (!observed.session || observed.session === record.session)) obstacle = { type: 'idle_without_checkpoint', detail: observed.turnId };
     } else if (run.state === 'blocked' && ['missing_information', 'authorization', 'external_dependency'].includes(run.blocker)) {
       if (run.blockerSource === 'provider' || run.managed.attempts?.at(-1)?.errorCode === 'provider_approval') {
         if (now < (run.managed.purpose.lastObservedAt || 0) + 60_000) continue;
@@ -309,7 +311,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
       if (['native_wait_updated', 'native_wait_diagnosis'].includes(obstacle.type) && !nativeCurrent(current)) return current;
       if (searchEnabled(current.run.managed) && ['original_context_updated', 'native_wait_updated'].includes(obstacle.type)) current.run.managed.purpose.nextSearchAt = 0;
       const queued = queuePurposeDiagnosis(current.run,
-        `Reassess the original purpose after ${obstacle.type}: ${obstacle.detail}. Gather evidence before deciding that a person is needed. Preserve unresolved approvals/dependencies; choose independent work or a safe alternative where possible.`, key, Date.now());
+        `Reassess the original purpose after ${obstacle.type}: ${obstacle.detail}. Use the shared scene reasoning cycle to select the next useful check. Preserve unresolved approvals/dependencies; choose independent work or a safe alternative where possible, then return to the original unfinished work.`, key, now, obstacle.type);
       if (queued && obstacle.type === 'external_dependency') {
         const purpose = current.run.managed.purpose;
         purpose.dependencyChecks = (purpose.dependencyChecks || 0) + 1;
@@ -318,6 +320,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
       return current;
     });
     } catch (error) {
+      if (signal?.aborted) break;
       if (!/^Delivery state (?:is busy; retry the command\.|lock owner is unavailable; inspect the lock before retrying\.)$/.test(error.message)) throw error;
       // One unavailable record cannot prevent independent conversations from
       // progressing. Never delete or reclaim an ambiguous writer lock.