@jmoyers/harness 0.1.8 → 0.1.9

package/README.md

@@ -92,6 +92,7 @@ harness --session my-session
 - Runs with `--watch` by default.
 - Install actions are availability-aware and config-driven (`*.install.command`), opening a terminal thread to run the configured install command when a tool is missing.
 - Global command palette (`ctrl+p` / `cmd+p`) includes:
+  - `Critique AI Review: Unstaged Changes`
   - `Critique AI Review: Staged Changes`
   - `Critique AI Review: Current Branch vs Base`
 - These start a terminal thread and run `critique review ...`, preferring `claude` when available and otherwise using `opencode` when installed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmoyers/harness",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "private": false,
   "repository": {
     "type": "git",
@@ -77,6 +77,8 @@
     "test": "bun run build:ptyd && bun test",
     "test:integration:codex-status": "bun scripts/integration-codex-status-sequence.ts",
     "test:integration:codex-status:long": "bun scripts/integration-codex-status-sequence.ts --timeout-ms 180000 --prompt \"Write three short poems titled Dawn, Voltage, and Orbit. Before each poem, perform one repository inspection action and include one factual line from that action. Use at least three total tool actions and do not edit any files.\"",
+    "test:integration:agent-prompts": "bun scripts/integration-agent-prompt-parity.ts",
+    "test:integration:agent-prompts:long": "bun scripts/integration-agent-prompt-parity.ts --timeout-ms 180000",
     "smoke:harness-ai": "bun scripts/harness-ai-smoke.ts",
     "smoke:harness-ai:parity": "bun scripts/harness-ai-parity-smoke.mts",
     "test:coverage": "bun run build:ptyd && bun test --coverage --coverage-reporter=lcov --coverage-dir .harness/coverage-bun && bun run coverage:check",

package/scripts/codex-live-mux-runtime.ts

@@ -2619,17 +2619,23 @@ async function main(): Promise<number> {
 
   const runCritiqueReviewFromCommandMenu = (
     directoryId: string,
-    mode: 'staged' | 'base-branch',
+    mode: 'unstaged' | 'staged' | 'base-branch',
   ): void => {
     queueControlPlaneOp(async () => {
       const agent = resolveCritiqueReviewAgentFromEnvironment();
-      if (mode === 'staged') {
+      if (mode !== 'base-branch') {
         const commandText = buildCritiqueReviewCommand({
-          mode: 'staged',
+          mode,
           agent,
         });
         await runCommandInNewTerminalThread(directoryId, commandText);
-        setCommandNotice(`running critique staged review (${agent ?? 'default'})`);
+        const reviewLabelByMode: Readonly<Record<'unstaged' | 'staged', string>> = {
+          unstaged: 'unstaged',
+          staged: 'staged',
+        };
+        setCommandNotice(
+          `running critique ${reviewLabelByMode[mode]} review (${agent ?? 'default'})`,
+        );
         return;
       }
       const baseBranch = await resolveCritiqueReviewBaseBranchForDirectory(directoryId);
@@ -2653,6 +2659,16 @@ async function main(): Promise<number> {
       return [];
     }
     return [
+      {
+        id: 'critique.review.unstaged',
+        title: 'Critique AI Review: Unstaged Changes',
+        aliases: ['critique unstaged review', 'review unstaged diff', 'ai review unstaged'],
+        keywords: ['critique', 'review', 'unstaged', 'diff', 'ai'],
+        detail: 'runs critique review',
+        run: () => {
+          runCritiqueReviewFromCommandMenu(directoryId, 'unstaged');
+        },
+      },
       {
         id: 'critique.review.staged',
         title: 'Critique AI Review: Staged Changes',

package/src/control-plane/agent-realtime-api.ts

@@ -54,6 +54,7 @@ interface AgentEventTypeMap {
   'session.status': Extract<StreamObservedEvent, { type: 'session-status' }>;
   'session.event': Extract<StreamObservedEvent, { type: 'session-event' }>;
   'session.telemetry': Extract<StreamObservedEvent, { type: 'session-key-event' }>;
+  'session.prompt': Extract<StreamObservedEvent, { type: 'session-prompt-event' }>;
   'session.control': Extract<StreamObservedEvent, { type: 'session-control' }>;
   'session.output': Extract<StreamObservedEvent, { type: 'session-output' }>;
 }
@@ -1155,6 +1156,9 @@ function mapObservedEventType(observed: StreamObservedEvent): AgentRealtimeEvent
   if (observed.type === 'session-key-event') {
     return 'session.telemetry';
   }
+  if (observed.type === 'session-prompt-event') {
+    return 'session.prompt';
+  }
   if (observed.type === 'session-control') {
     return 'session.control';
   }

package/src/control-plane/prompt/agent-prompt-extractor.ts

@@ -0,0 +1,191 @@
+import { createHash } from 'node:crypto';
+import type {
+  StreamPromptCaptureSource,
+  StreamPromptConfidence,
+  StreamSessionPromptRecord,
+  StreamTelemetrySource,
+} from '../stream-protocol.ts';
+
+export interface PromptFromNotifyInput {
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+export interface PromptFromTelemetryInput {
+  readonly source: StreamTelemetrySource;
+  readonly eventName: string | null;
+  readonly summary: string | null;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+export interface AgentPromptExtractor {
+  readonly agentType: string;
+  fromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null;
+  fromTelemetry(input: PromptFromTelemetryInput): StreamSessionPromptRecord | null;
+}
+
+export function readTrimmedString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function normalizeEventToken(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '');
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function stableSerialize(value: unknown, depth = 0): string {
+  if (depth > 4) {
+    return '[depth-limit]';
+  }
+  if (value === null) {
+    return 'null';
+  }
+  if (typeof value === 'string') {
+    return JSON.stringify(value);
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value
+      .slice(0, 24)
+      .map((entry) => stableSerialize(entry, depth + 1))
+      .join(',')}]`;
+  }
+  const record = asRecord(value);
+  if (record === null) {
+    return typeof value;
+  }
+  const keys = Object.keys(record).sort().slice(0, 24);
+  return `{${keys
+    .map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key], depth + 1)}`)
+    .join(',')}}`;
+}
+
+function hashPromptPayload(input: {
+  readonly text: string | null;
+  readonly providerEventName: string | null;
+  readonly payload: Record<string, unknown>;
+}): string {
+  const hash = createHash('sha256');
+  hash.update(input.providerEventName ?? '');
+  hash.update('\n');
+  hash.update(input.text ?? '');
+  hash.update('\n');
+  hash.update(stableSerialize(input.payload));
+  return hash.digest('hex');
+}
+
+function lookupRecordValue(
+  record: Record<string, unknown>,
+  candidateKeys: readonly string[],
+): string | null {
+  const normalizedKeys = new Set(candidateKeys.map((key) => key.toLowerCase()));
+  for (const [key, value] of Object.entries(record)) {
+    if (!normalizedKeys.has(key.toLowerCase())) {
+      continue;
+    }
+    const text = readTrimmedString(value);
+    if (text !== null) {
+      return text;
+    }
+  }
+  return null;
+}
+
+export function findPromptText(
+  value: unknown,
+  options: {
+    readonly keys: readonly string[];
+    readonly maxDepth?: number;
+  },
+): string | null {
+  const maxDepth = options.maxDepth ?? 3;
+  const visited = new Set<unknown>();
+  const queue: Array<{ value: unknown; depth: number }> = [{ value, depth: 0 }];
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (next === undefined) {
+      continue;
+    }
+    if (next.depth > maxDepth) {
+      continue;
+    }
+    if (next.value !== null && typeof next.value === 'object') {
+      if (visited.has(next.value)) {
+        continue;
+      }
+      visited.add(next.value);
+    }
+    if (typeof next.value === 'string') {
+      if (next.depth === 0) {
+        const text = readTrimmedString(next.value);
+        if (text !== null) {
+          return text;
+        }
+      }
+      continue;
+    }
+    const record = asRecord(next.value);
+    if (record !== null) {
+      const match = lookupRecordValue(record, options.keys);
+      if (match !== null) {
+        return match;
+      }
+      if (next.depth >= maxDepth) {
+        continue;
+      }
+      for (const nested of Object.values(record)) {
+        queue.push({ value: nested, depth: next.depth + 1 });
+      }
+      continue;
+    }
+    if (Array.isArray(next.value) && next.depth < maxDepth) {
+      for (const nested of next.value.slice(0, 24)) {
+        queue.push({ value: nested, depth: next.depth + 1 });
+      }
+    }
+  }
+  return null;
+}
+
+function providerPayloadKeys(payload: Record<string, unknown>): string[] {
+  return Object.keys(payload).sort().slice(0, 12);
+}
+
+export function createPromptRecord(input: {
+  readonly text: string | null;
+  readonly confidence: StreamPromptConfidence;
+  readonly captureSource: StreamPromptCaptureSource;
+  readonly providerEventName: string | null;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}): StreamSessionPromptRecord {
+  return {
+    text: input.text,
+    hash: hashPromptPayload({
+      text: input.text,
+      providerEventName: input.providerEventName,
+      payload: input.payload,
+    }),
+    confidence: input.confidence,
+    captureSource: input.captureSource,
+    providerEventName: input.providerEventName,
+    providerPayloadKeys: providerPayloadKeys(input.payload),
+    observedAt: input.observedAt,
+  };
+}

package/src/control-plane/prompt/extractors/claude-prompt-extractor.ts

@@ -0,0 +1,53 @@
+import type { StreamSessionPromptRecord } from '../../stream-protocol.ts';
+import type {
+  AgentPromptExtractor,
+  PromptFromNotifyInput,
+  PromptFromTelemetryInput,
+} from '../agent-prompt-extractor.ts';
+import {
+  createPromptRecord,
+  findPromptText,
+  normalizeEventToken,
+  readTrimmedString,
+} from '../agent-prompt-extractor.ts';
+
+function fromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+  const hookEventName =
+    readTrimmedString(input.payload['hook_event_name']) ??
+    readTrimmedString(input.payload['hookEventName']);
+  if (hookEventName === null) {
+    return null;
+  }
+  const hookToken = normalizeEventToken(hookEventName);
+  if (hookToken !== 'userpromptsubmit') {
+    return null;
+  }
+  const directPrompt =
+    readTrimmedString(input.payload['prompt']) ??
+    readTrimmedString(input.payload['user_prompt']) ??
+    readTrimmedString(input.payload['userPrompt']);
+  const fallbackPrompt =
+    directPrompt ??
+    findPromptText(input.payload, {
+      keys: ['prompt', 'user_prompt', 'userPrompt', 'text', 'input', 'query', 'message'],
+      maxDepth: 3,
+    });
+  return createPromptRecord({
+    text: fallbackPrompt,
+    confidence: directPrompt !== null ? 'high' : fallbackPrompt !== null ? 'medium' : 'low',
+    captureSource: 'hook-notify',
+    providerEventName: `claude.${hookToken}`,
+    payload: input.payload,
+    observedAt: input.observedAt,
+  });
+}
+
+function fromTelemetry(_input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+  return null;
+}
+
+export const claudePromptExtractor: AgentPromptExtractor = {
+  agentType: 'claude',
+  fromNotify,
+  fromTelemetry,
+};

package/src/control-plane/prompt/extractors/codex-prompt-extractor.ts

@@ -0,0 +1,50 @@
+import type { StreamSessionPromptRecord } from '../../stream-protocol.ts';
+import type {
+  AgentPromptExtractor,
+  PromptFromNotifyInput,
+  PromptFromTelemetryInput,
+} from '../agent-prompt-extractor.ts';
+import {
+  createPromptRecord,
+  findPromptText,
+  readTrimmedString,
+} from '../agent-prompt-extractor.ts';
+
+function fromNotify(_input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+  return null;
+}
+
+function fromTelemetry(input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+  const normalizedEventName = (input.eventName ?? '').trim().toLowerCase();
+  if (normalizedEventName !== 'codex.user_prompt' && normalizedEventName !== 'user_prompt') {
+    return null;
+  }
+  if (input.source !== 'otlp-log' && input.source !== 'history') {
+    return null;
+  }
+  const textFromPayload = findPromptText(input.payload, {
+    keys: ['prompt', 'user_prompt', 'userPrompt', 'message', 'text', 'content', 'input', 'body'],
+    maxDepth: 4,
+  });
+  const normalizedSummary = readTrimmedString(input.summary);
+  const textFromSummary =
+    normalizedSummary !== null && normalizedSummary.toLowerCase().startsWith('prompt:')
+      ? readTrimmedString(normalizedSummary.slice('prompt:'.length))
+      : null;
+  const promptText = textFromPayload ?? textFromSummary;
+  const confidence = promptText === null ? 'low' : textFromPayload !== null ? 'high' : 'medium';
+  return createPromptRecord({
+    text: promptText,
+    confidence,
+    captureSource: input.source === 'history' ? 'history' : 'otlp-log',
+    providerEventName: input.eventName,
+    payload: input.payload,
+    observedAt: input.observedAt,
+  });
+}
+
+export const codexPromptExtractor: AgentPromptExtractor = {
+  agentType: 'codex',
+  fromNotify,
+  fromTelemetry,
+};

package/src/control-plane/prompt/extractors/cursor-prompt-extractor.ts

@@ -0,0 +1,56 @@
+import type { StreamSessionPromptRecord } from '../../stream-protocol.ts';
+import type {
+  AgentPromptExtractor,
+  PromptFromNotifyInput,
+  PromptFromTelemetryInput,
+} from '../agent-prompt-extractor.ts';
+import {
+  createPromptRecord,
+  findPromptText,
+  normalizeEventToken,
+  readTrimmedString,
+} from '../agent-prompt-extractor.ts';
+
+function fromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+  const hookEventName =
+    readTrimmedString(input.payload['hook_event_name']) ??
+    readTrimmedString(input.payload['hookEventName']) ??
+    readTrimmedString(input.payload['event_name']) ??
+    readTrimmedString(input.payload['eventName']) ??
+    readTrimmedString(input.payload['event']);
+  if (hookEventName === null) {
+    return null;
+  }
+  const hookToken = normalizeEventToken(hookEventName);
+  if (hookToken !== 'beforesubmitprompt') {
+    return null;
+  }
+  const directPrompt =
+    readTrimmedString(input.payload['prompt']) ??
+    readTrimmedString(input.payload['user_prompt']) ??
+    readTrimmedString(input.payload['userPrompt']);
+  const promptText =
+    directPrompt ??
+    findPromptText(input.payload, {
+      keys: ['prompt', 'user_prompt', 'userPrompt', 'text', 'input', 'query', 'message'],
+      maxDepth: 3,
+    });
+  return createPromptRecord({
+    text: promptText,
+    confidence: directPrompt !== null ? 'high' : promptText !== null ? 'medium' : 'low',
+    captureSource: 'hook-notify',
+    providerEventName: `cursor.${hookToken}`,
+    payload: input.payload,
+    observedAt: input.observedAt,
+  });
+}
+
+function fromTelemetry(_input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+  return null;
+}
+
+export const cursorPromptExtractor: AgentPromptExtractor = {
+  agentType: 'cursor',
+  fromNotify,
+  fromTelemetry,
+};

package/src/control-plane/prompt/session-prompt-engine.ts

@@ -0,0 +1,69 @@
+import type { StreamSessionPromptRecord, StreamTelemetrySource } from '../stream-protocol.ts';
+import type { AgentPromptExtractor } from './agent-prompt-extractor.ts';
+import { claudePromptExtractor } from './extractors/claude-prompt-extractor.ts';
+import { codexPromptExtractor } from './extractors/codex-prompt-extractor.ts';
+import { cursorPromptExtractor } from './extractors/cursor-prompt-extractor.ts';
+
+type SupportedAgentType = 'codex' | 'claude' | 'cursor';
+
+const DEFAULT_EXTRACTORS: Record<SupportedAgentType, AgentPromptExtractor> = {
+  codex: codexPromptExtractor,
+  claude: claudePromptExtractor,
+  cursor: cursorPromptExtractor,
+};
+
+function normalizeAgentType(value: string): SupportedAgentType | null {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'codex' || normalized === 'claude' || normalized === 'cursor') {
+    return normalized;
+  }
+  return null;
+}
+
+interface PromptFromNotifyInput {
+  readonly agentType: string;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+interface PromptFromTelemetryInput {
+  readonly agentType: string;
+  readonly source: StreamTelemetrySource;
+  readonly eventName: string | null;
+  readonly summary: string | null;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+export class SessionPromptEngine {
+  private readonly extractors: Record<SupportedAgentType, AgentPromptExtractor>;
+
+  constructor(extractors: Record<SupportedAgentType, AgentPromptExtractor> = DEFAULT_EXTRACTORS) {
+    this.extractors = extractors;
+  }
+
+  extractFromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+    const agentType = normalizeAgentType(input.agentType);
+    if (agentType === null) {
+      return null;
+    }
+    return this.extractors[agentType].fromNotify({
+      payload: input.payload,
+      observedAt: input.observedAt,
+    });
+  }
+
+  extractFromTelemetry(input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+    const agentType = normalizeAgentType(input.agentType);
+    if (agentType === null) {
+      return null;
+    }
+    return this.extractors[agentType].fromTelemetry({
+      source: input.source,
+      eventName: input.eventName,
+      summary: input.summary,
+      payload: input.payload,
+      observedAt: input.observedAt,
+    });
+  }
+}

package/src/control-plane/stream-protocol.ts

@@ -6,6 +6,8 @@ export type StreamSessionRuntimeStatus = 'running' | 'needs-input' | 'completed'
 export type StreamSessionListSort = 'attention-first' | 'started-desc' | 'started-asc';
 export type StreamTelemetrySource = 'otlp-log' | 'otlp-metric' | 'otlp-trace' | 'history';
 export type StreamTelemetryStatusHint = 'running' | 'completed' | 'needs-input';
+export type StreamPromptCaptureSource = 'otlp-log' | 'hook-notify' | 'history';
+export type StreamPromptConfidence = 'high' | 'medium' | 'low';
 export type StreamSessionControllerType = 'human' | 'agent' | 'automation';
 export type StreamSessionDisplayPhase = 'needs-action' | 'starting' | 'working' | 'idle' | 'exited';
 
@@ -46,6 +48,16 @@ export interface StreamSessionKeyEventRecord {
   statusHint: StreamTelemetryStatusHint | null;
 }
 
+export interface StreamSessionPromptRecord {
+  text: string | null;
+  hash: string;
+  confidence: StreamPromptConfidence;
+  captureSource: StreamPromptCaptureSource;
+  providerEventName: string | null;
+  providerPayloadKeys: string[];
+  observedAt: string;
+}
+
 interface DirectoryUpsertCommand {
   type: 'directory.upsert';
   directoryId?: string;
@@ -708,6 +720,14 @@ export type StreamObservedEvent =
       directoryId: string | null;
       conversationId: string | null;
     }
+  | {
+      type: 'session-prompt-event';
+      sessionId: string;
+      prompt: StreamSessionPromptRecord;
+      ts: string;
+      directoryId: string | null;
+      conversationId: string | null;
+    }
   | {
       type: 'session-control';
       sessionId: string;
@@ -1057,6 +1077,20 @@ function parseTelemetryStatusHint(value: unknown): StreamTelemetryStatusHint | n
   return undefined;
 }
 
+function parsePromptCaptureSource(value: unknown): StreamPromptCaptureSource | null {
+  if (value === 'otlp-log' || value === 'hook-notify' || value === 'history') {
+    return value;
+  }
+  return null;
+}
+
+function parsePromptConfidence(value: unknown): StreamPromptConfidence | null {
+  if (value === 'high' || value === 'medium' || value === 'low') {
+    return value;
+  }
+  return null;
+}
+
 function parseTelemetrySummary(value: unknown): StreamTelemetrySummary | null | undefined {
   if (value === undefined) {
     return undefined;
@@ -1189,6 +1223,50 @@ function parseSessionKeyEventRecord(value: unknown): StreamSessionKeyEventRecord
   };
 }
 
+function parseSessionPromptRecord(value: unknown): StreamSessionPromptRecord | null {
+  const record = asRecord(value);
+  if (record === null) {
+    return null;
+  }
+  const text = record['text'] === null ? null : readString(record['text']);
+  const hash = readString(record['hash']);
+  const confidence = parsePromptConfidence(record['confidence']);
+  const captureSource = parsePromptCaptureSource(record['captureSource']);
+  const providerEventName =
+    record['providerEventName'] === null ? null : readString(record['providerEventName']);
+  const providerPayloadKeysValue = record['providerPayloadKeys'];
+  const observedAt = readString(record['observedAt']);
+  if (
+    (text === null && record['text'] !== null) ||
+    hash === null ||
+    hash.trim().length === 0 ||
+    confidence === null ||
+    captureSource === null ||
+    (providerEventName === null && record['providerEventName'] !== null) ||
+    !Array.isArray(providerPayloadKeysValue) ||
+    observedAt === null
+  ) {
+    return null;
+  }
+  const providerPayloadKeys: string[] = [];
+  for (const entry of providerPayloadKeysValue) {
+    const key = readString(entry);
+    if (key === null) {
+      return null;
+    }
+    providerPayloadKeys.push(key);
+  }
+  return {
+    text: record['text'] === null ? null : text,
+    hash,
+    confidence,
+    captureSource,
+    providerEventName: record['providerEventName'] === null ? null : providerEventName,
+    providerPayloadKeys,
+    observedAt,
+  };
+}
+
 function parseStreamObservedEvent(value: unknown): StreamObservedEvent | null {
   const record = asRecord(value);
   if (record === null) {
@@ -1609,6 +1687,31 @@ function parseStreamObservedEvent(value: unknown): StreamObservedEvent | null {
     };
   }
 
+  if (type === 'session-prompt-event') {
+    const sessionId = readString(record['sessionId']);
+    const prompt = parseSessionPromptRecord(record['prompt']);
+    const ts = readString(record['ts']);
+    const directoryId = readString(record['directoryId']);
+    const conversationId = readString(record['conversationId']);
+    if (
+      sessionId === null ||
+      prompt === null ||
+      ts === null ||
+      (record['directoryId'] !== null && directoryId === null) ||
+      (record['conversationId'] !== null && conversationId === null)
+    ) {
+      return null;
+    }
+    return {
+      type,
+      sessionId,
+      prompt,
+      ts,
+      directoryId: record['directoryId'] === null ? null : directoryId,
+      conversationId: record['conversationId'] === null ? null : conversationId,
+    };
+  }
+
   if (type === 'session-control') {
     const sessionId = readString(record['sessionId']);
     const action = readString(record['action']);

package/src/control-plane/stream-server-session-runtime.ts

@@ -5,10 +5,12 @@ import type {
   StreamSessionController,
   StreamSessionEvent,
   StreamSessionKeyEventRecord,
+  StreamSessionPromptRecord,
   StreamSessionRuntimeStatus,
   StreamSessionStatusModel,
   StreamSignal,
 } from './stream-protocol.ts';
+import { SessionPromptEngine } from './prompt/session-prompt-engine.ts';
 
 const CLAUDE_NEEDS_INPUT_NOTIFICATION_TYPES = new Set([
   'permissionrequest',
@@ -22,6 +24,7 @@ const CLAUDE_RUNNING_NOTIFICATION_TYPES = new Set([
   'approvalapproved',
   'approvalgranted',
 ]);
+const sessionPromptEngine = new SessionPromptEngine();
 
 interface RuntimeSession {
   id: string;
@@ -83,6 +86,7 @@ interface StreamRuntimeContext {
     state: RuntimeSession,
     keyEvent: StreamSessionKeyEventRecord,
   ): void;
+  publishSessionPromptObservedEvent(state: RuntimeSession, prompt: StreamSessionPromptRecord): void;
   refreshSessionStatusModel(state: RuntimeSession, observedAt: string): void;
   toPublicSessionController(
     controller: StreamSessionController | null,
@@ -557,6 +561,14 @@ export function handleSessionEvent(
       ctx.stateStore.updateConversationAdapterState(sessionState.id, mergedAdapterState);
     }
     if (mapped.type === 'notify') {
+      const promptEvent = sessionPromptEngine.extractFromNotify({
+        agentType: sessionState.agentType,
+        payload: mapped.record.payload,
+        observedAt,
+      });
+      if (promptEvent !== null) {
+        ctx.publishSessionPromptObservedEvent(sessionState, promptEvent);
+      }
       const keyEvent =
         notifyKeyEventFromPayload(sessionState.agentType, mapped.record.payload, observedAt) ??
         unmappedNotifyKeyEventFromPayload(

package/src/control-plane/stream-server.ts

@@ -18,6 +18,7 @@ import {
   encodeStreamEnvelope,
   type StreamObservedEvent,
   type StreamSessionKeyEventRecord,
+  type StreamSessionPromptRecord,
   type StreamSessionController,
   type StreamSessionListSort,
   type StreamSessionRuntimeStatus,
@@ -83,6 +84,7 @@ import {
 } from './stream-server-session-runtime.ts';
 import { closeOwnedStateStore as closeOwnedStreamServerStateStore } from './stream-server-state-store.ts';
 import { SessionStatusEngine } from './status/session-status-engine.ts';
+import { SessionPromptEngine } from './prompt/session-prompt-engine.ts';
 import {
   eventIncludesRepositoryId as filterEventIncludesRepositoryId,
   eventIncludesTaskId as filterEventIncludesTaskId,
@@ -413,6 +415,8 @@ const DEFAULT_GITHUB_POLL_MS = 15_000;
 const HISTORY_POLL_JITTER_RATIO = 0.35;
 const SESSION_DIAGNOSTICS_BUCKET_MS = 10_000;
 const SESSION_DIAGNOSTICS_BUCKET_COUNT = 6;
+const PROMPT_EVENT_DEDUPE_TTL_MS = 5 * 60 * 1000;
+const MAX_PROMPT_EVENT_DEDUPE_ENTRIES = 4096;
 const DEFAULT_BOOTSTRAP_SESSION_COLS = 80;
 const DEFAULT_BOOTSTRAP_SESSION_ROWS = 24;
 const DEFAULT_TENANT_ID = 'tenant-local';
@@ -1054,6 +1058,8 @@ export class ControlPlaneStreamServer {
   };
   private readonly readGitDirectorySnapshot: GitDirectorySnapshotReader;
   private readonly statusEngine = new SessionStatusEngine();
+  private readonly promptEngine = new SessionPromptEngine();
+  private readonly promptEventDedupeByKey = new Map<string, number>();
   private readonly server: Server;
   private readonly telemetryServer: HttpServer | null;
   private telemetryAddress: AddressInfo | null = null;
@@ -1943,6 +1949,31 @@ export class ControlPlaneStreamServer {
         event.observedAt,
       );
     }
+    if (inserted && resolvedSessionId !== null) {
+      const promptEvent = this.promptEngine.extractFromTelemetry({
+        agentType: 'codex',
+        source: event.source,
+        eventName: event.eventName,
+        summary: event.summary,
+        payload: event.payload,
+        observedAt: event.observedAt,
+      });
+      if (promptEvent !== null) {
+        const liveState = this.sessions.get(resolvedSessionId);
+        if (liveState !== undefined) {
+          this.publishSessionPromptObservedEvent(liveState, promptEvent);
+        } else {
+          const observedScope = this.observedScopeForSessionId(resolvedSessionId);
+          if (observedScope !== null) {
+            this.publishSessionPromptObservedEventForScope(
+              resolvedSessionId,
+              observedScope,
+              promptEvent,
+            );
+          }
+        }
+      }
+    }
     if (!inserted || resolvedSessionId === null) {
       return;
     }
@@ -2674,6 +2705,75 @@ export class ControlPlaneStreamServer {
     });
   }
 
+  private promptEventSecondBucket(observedAt: string): string {
+    const normalized = observedAt.trim();
+    if (normalized.length >= 19) {
+      return normalized.slice(0, 19);
+    }
+    return normalized;
+  }
+
+  private shouldPublishPromptEvent(sessionId: string, prompt: StreamSessionPromptRecord): boolean {
+    const bucket = this.promptEventSecondBucket(prompt.observedAt);
+    const dedupeKey = `${sessionId}:${prompt.hash}:${prompt.providerEventName ?? ''}:${bucket}`;
+    if (this.promptEventDedupeByKey.has(dedupeKey)) {
+      return false;
+    }
+    const nowMs = Date.now();
+    this.promptEventDedupeByKey.set(dedupeKey, nowMs);
+    if (this.promptEventDedupeByKey.size > MAX_PROMPT_EVENT_DEDUPE_ENTRIES) {
+      for (const [key, observedMs] of this.promptEventDedupeByKey) {
+        if (nowMs - observedMs > PROMPT_EVENT_DEDUPE_TTL_MS) {
+          this.promptEventDedupeByKey.delete(key);
+        }
+      }
+      if (this.promptEventDedupeByKey.size > MAX_PROMPT_EVENT_DEDUPE_ENTRIES) {
+        let dropCount = this.promptEventDedupeByKey.size - MAX_PROMPT_EVENT_DEDUPE_ENTRIES;
+        for (const key of this.promptEventDedupeByKey.keys()) {
+          this.promptEventDedupeByKey.delete(key);
+          dropCount -= 1;
+          if (dropCount <= 0) {
+            break;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  private publishSessionPromptObservedEventForScope(
+    sessionId: string,
+    scope: StreamObservedScope,
+    prompt: StreamSessionPromptRecord,
+  ): void {
+    if (!this.shouldPublishPromptEvent(sessionId, prompt)) {
+      return;
+    }
+    this.publishObservedEvent(scope, {
+      type: 'session-prompt-event',
+      sessionId,
+      prompt: {
+        text: prompt.text,
+        hash: prompt.hash,
+        confidence: prompt.confidence,
+        captureSource: prompt.captureSource,
+        providerEventName: prompt.providerEventName,
+        providerPayloadKeys: [...prompt.providerPayloadKeys],
+        observedAt: prompt.observedAt,
+      },
+      ts: new Date().toISOString(),
+      directoryId: scope.directoryId,
+      conversationId: scope.conversationId,
+    });
+  }
+
+  private publishSessionPromptObservedEvent(
+    state: SessionState,
+    prompt: StreamSessionPromptRecord,
+  ): void {
+    this.publishSessionPromptObservedEventForScope(state.id, this.sessionScope(state), prompt);
+  }
+
   private setSessionStatus(
     state: SessionState,
     status: StreamSessionRuntimeStatus,
@@ -3212,6 +3312,9 @@ export class ControlPlaneStreamServer {
     if (event.type === 'session-key-event') {
       return event.sessionId;
     }
+    if (event.type === 'session-prompt-event') {
+      return event.sessionId;
+    }
     if (event.type === 'session-control') {
       return event.sessionId;
     }

package/src/mux/live-mux/critique-review.ts

@@ -8,6 +8,10 @@ interface CritiqueReviewAgentAvailability {
 }
 
 type CritiqueReviewCommandInput =
+  | {
+      readonly mode: 'unstaged';
+      readonly agent: CritiqueReviewAgent | null;
+    }
   | {
       readonly mode: 'staged';
       readonly agent: CritiqueReviewAgent | null;
@@ -54,7 +58,7 @@ export function buildCritiqueReviewCommand(input: CritiqueReviewCommandInput): s
   const tokens = ['critique', 'review'];
   if (input.mode === 'staged') {
     tokens.push('--staged');
-  } else {
+  } else if (input.mode === 'base-branch') {
     const normalizedBaseBranch = normalizeBranchName(input.baseBranch) ?? 'main';
     tokens.push(normalizedBaseBranch, 'HEAD');
   }

package/src/pty/pty_host.ts

@@ -68,6 +68,8 @@ class PtySession extends EventEmitter {
   private nextProbeId = 1;
   private outputWindow = Buffer.alloc(0);
   private static readonly MAX_OUTPUT_WINDOW_BYTES = 8192;
+  private static readonly MAX_PENDING_ROUNDTRIP_PROBES = 64;
+  private static readonly ROUNDTRIP_PROBE_MAX_AGE_NS = 5_000_000_000n;
 
   constructor(child: ChildProcessWithoutNullStreams) {
     super();
@@ -101,6 +103,12 @@ class PtySession extends EventEmitter {
         matchPayloads: PtySession.buildMatchPayloads(payload),
         startedAtNs: perfNowNs(),
       });
+      if (this.pendingRoundtripProbes.length > PtySession.MAX_PENDING_ROUNDTRIP_PROBES) {
+        this.pendingRoundtripProbes.splice(
+          0,
+          this.pendingRoundtripProbes.length - PtySession.MAX_PENDING_ROUNDTRIP_PROBES,
+        );
+      }
       this.nextProbeId += 1;
     }
 
@@ -148,12 +156,22 @@ class PtySession extends EventEmitter {
       );
     }
 
+    const maxMatchPayloadLength = this.compactPendingRoundtripProbes(perfNowNs());
+    if (this.pendingRoundtripProbes.length === 0) {
+      return;
+    }
+    const searchWindowLength = Math.max(
+      1,
+      Math.min(this.outputWindow.length, chunk.length + Math.max(1, maxMatchPayloadLength) - 1),
+    );
+    const searchWindow = this.outputWindow.subarray(this.outputWindow.length - searchWindowLength);
+
     let idx = 0;
     while (idx < this.pendingRoundtripProbes.length) {
       const probe = this.pendingRoundtripProbes[idx];
       if (
         probe !== undefined &&
-        probe.matchPayloads.some((matchPayload) => this.outputWindow.includes(matchPayload))
+        probe.matchPayloads.some((matchPayload) => searchWindow.includes(matchPayload))
       ) {
         recordPerfDuration('pty.keystroke.roundtrip', probe.startedAtNs, {
           'probe-id': probe.probeId,
@@ -166,6 +184,33 @@ class PtySession extends EventEmitter {
     }
   }
 
+  private compactPendingRoundtripProbes(nowNs: bigint): number {
+    if (this.pendingRoundtripProbes.length > PtySession.MAX_PENDING_ROUNDTRIP_PROBES) {
+      this.pendingRoundtripProbes.splice(
+        0,
+        this.pendingRoundtripProbes.length - PtySession.MAX_PENDING_ROUNDTRIP_PROBES,
+      );
+    }
+    let maxMatchPayloadLength = 1;
+    let idx = 0;
+    while (idx < this.pendingRoundtripProbes.length) {
+      const probe = this.pendingRoundtripProbes[idx];
+      if (probe === undefined) {
+        idx += 1;
+        continue;
+      }
+      if (nowNs - probe.startedAtNs > PtySession.ROUNDTRIP_PROBE_MAX_AGE_NS) {
+        this.pendingRoundtripProbes.splice(idx, 1);
+        continue;
+      }
+      for (const matchPayload of probe.matchPayloads) {
+        maxMatchPayloadLength = Math.max(maxMatchPayloadLength, matchPayload.length);
+      }
+      idx += 1;
+    }
+    return maxMatchPayloadLength;
+  }
+
   private static buildMatchPayloads(payload: Buffer): Buffer[] {
     if (!payload.includes(0x0a)) {
       return [payload];