@visual-z/xeno 0.3.0 → 0.4.0

package/src/core/control-view.ts

@@ -0,0 +1,42 @@
+/** Q24: control surfaces inspect original facts; they never own a second goal or context. */
+import { currentRequestRecords, deriveRequestState, type RequestPart, type RequestState } from "./request-state.ts";
+import { contextDetail } from "./context-detail.ts";
+import { projectContext } from "./project.ts";
+import { assertNever } from "./exhaustive.ts";
+
+export type GoalView = { text: string; state: RequestState; gaps: string[] };
+
+export function goalView(parts: readonly RequestPart[]): GoalView | null {
+  const state = deriveRequestState(parts);
+  const first = currentRequestRecords(parts)[0]?.event;
+  if (!state || first?.t !== "user") return null;
+  const gaps = state.acceptance
+    ? state.acceptance.criteria.filter(item => item.status !== "pass" && item.status !== "accepted").map(item => `${item.description}: ${item.status}`)
+    : ["No acceptance contract; command success does not verify the goal."];
+  gaps.push(...state.reported_blockers.map(item => `Reported blocker: ${item.reason}`));
+  return { text: first.text, state, gaps };
+}
+
+export type ContextLens = ReturnType<typeof contextLens>;
+export type LensFocus = "messages" | "omitted" | "history";
+
+export function contextLens(input: Parameters<typeof contextDetail>[0]) {
+  const detail = contextDetail(input);
+  const projected = projectContext(input);
+  return { ...detail,
+    messages: projected.messages.map((message, index) => ({ index, role: message.role, sources: detail.sources[index] ?? [],
+      reason: detail.sources[index]?.some(id => id.startsWith("handoff:")) ? "boundary handoff with recovery references" : "original events in the current segment" })),
+    omitted: detail.omittedEvents.map(id => ({ id, type: input.events.find(event => event.id === id)?.t ?? "unknown",
+      reason: "not replayed as a model message; original event remains in the log" })),
+  };
+}
+
+/** A lens filters the inspector only; it cannot change the provider projection (D1/D8). */
+export function selectLens(lens: ContextLens, focus: LensFocus): readonly unknown[] {
+  switch (focus) {
+    case "messages": return lens.messages;
+    case "omitted": return lens.omitted;
+    case "history": return lens.sections;
+    default: return assertNever(focus, "context lens");
+  }
+}

package/src/core/event-validation.ts

@@ -68,7 +68,7 @@ export function isLogEvent(value: unknown): value is LogEvent {
       (value["target_binding"] === undefined ? value["target_observation"] === undefined : has("target_binding", "target_observation"));
     case "target_observation": return isRuntimeTargetReceipt(value["observation"]);
     case "extension": return has("customType", "content") && typeof value["display"] === "boolean" && typeof value["inContext"] === "boolean" && (value["data"] === undefined || isJsonValue(value["data"]));
-    case "user": return has("text");
+    case "user": return has("text") && (value["request"] === undefined || typeof value["request"] === "string" && value["request"] !== "");
     case "outcome": return has("reason") && isExecutionOutcome(value["outcome"]);
     case "user_bash": {
       const ref = value["content_ref"];

package/src/core/events.ts

@@ -84,6 +84,8 @@ export interface UserEvent {
   id: EventId;
   at: IsoTime;
   text: string;
+  /** Q23: in-flight steering belongs to this original user event; legacy events open a request. */
+  request?: EventId;
   images?: readonly ImageRef[];
 }
 

package/src/core/harness-diagnostics.ts

@@ -0,0 +1,206 @@
+/** D11 / O.3: classify durable execution facts, never error words in tool output. */
+import type { LogEvent, ToolResultEvent } from "./events.ts";
+import type { BenchmarkUsage } from "./benchmark.ts";
+import { canonicalValue } from "./continuation.ts";
+
+export type ResultClass = "success" | "invalid_input" | "cancelled" | "timeout" | "command_nonzero" |
+  "execution_failed" | "rejected" | "unclassified_failure";
+
+export function classifyToolResult(event: ToolResultEvent): ResultClass {
+  const code = event.diagnostic?.code;
+  if (code === "invalid_input") return "invalid_input";
+  if (code === "cancelled" || event.outcome?.reason === "cancelled") return "cancelled";
+  if (code === "timeout" || event.outcome?.reason === "timeout") return "timeout";
+  if (event.effect?.kind === "command" && event.effect.exit !== 0) return "command_nonzero";
+  if (event.ok) return "success";
+  if (event.diagnostic?.execution === "not_started" ||
+    ["version_mismatch", "not_found", "ambiguous_edit", "permission_denied", "environment_missing"].includes(code ?? "")) return "rejected";
+  if (code === "execution_failed" || code === "unknown_effect" || event.outcome?.reason === "execution_error") return "execution_failed";
+  return "unclassified_failure";
+}
+
+export interface DiagnosticRequest {
+  request: number;
+  node: number | null;
+  usage: BenchmarkUsage | null;
+  responseModel: string | null;
+  failure: string | null;
+  firstDeltaMs: number | null;
+  wallMs: number | null;
+  prefixUnchanged: boolean | null;
+  sharedInputBytes: number | null;
+  frozenSha256: string | null;
+  /** Raw terminal counts can remain known when a cache breakdown is absent. */
+  reportedPromptTokens?: number | null;
+  reportedOutputTokens?: number | null;
+}
+export interface ToolCounters {
+  calls: number; providerCalls: number; invocations: number; nestedInvocations: number;
+  results: number; pairedCalls: number; orphanCalls: number; orphanResults: number;
+  duplicateProviderCalls: number; duplicateInvocations: number; duplicateResults: number;
+  repeatedProviderInputs: number; repeatedInvocationInputs: number;
+  classes: Record<ResultClass, number>;
+  diagnosticCodes: Record<string, number>;
+  commandExits: Record<string, number>;
+  expectedNonzeroCommands: number;
+  undeclaredNonzeroCommands: number;
+}
+const classes = (): Record<ResultClass, number> => ({ success: 0, invalid_input: 0, cancelled: 0, timeout: 0,
+  command_nonzero: 0, execution_failed: 0, rejected: 0, unclassified_failure: 0 });
+const counters = (): ToolCounters => ({ calls: 0, providerCalls: 0, invocations: 0, nestedInvocations: 0,
+  results: 0, pairedCalls: 0, orphanCalls: 0, orphanResults: 0, duplicateProviderCalls: 0,
+  duplicateInvocations: 0, duplicateResults: 0, repeatedProviderInputs: 0, repeatedInvocationInputs: 0,
+  classes: classes(), diagnosticCodes: {}, commandExits: {}, expectedNonzeroCommands: 0, undeclaredNonzeroCommands: 0 });
+function add(record: Record<string, number>, key: string): void { record[key] = (record[key] ?? 0) + 1; }
+const validCount = (value: number): boolean => Number.isSafeInteger(value) && value >= 0;
+const reportedCount = (value: number | null | undefined): number | null => typeof value === "number" && validCount(value) ? value : null;
+const validTime = (value: number | null): number | null => value !== null && Number.isFinite(value) && value >= 0 ? value : null;
+function observedUsage(usage: BenchmarkUsage | null): BenchmarkUsage | null {
+  return usage && [usage.input_tokens, usage.output_tokens, usage.cache_read_input_tokens,
+    usage.cache_creation_input_tokens].every(validCount) ? usage : null;
+}
+function quantile(values: readonly number[], q: number): number | null {
+  return values.length ? values.toSorted((a, b) => a - b)[Math.max(0, Math.ceil(values.length * q) - 1)]! : null;
+}
+interface Call {
+  name: string; provider: boolean; invocation: boolean; nested: boolean;
+  providerInput: string | null; invocationInput: string | null;
+}
+
+/**
+ * Inputs and outputs remain private. Equal-input counts use canonical original
+ * model arguments and immutable admitted-input hashes separately (O.3 / Pi A).
+ * Expected nonzero exits need an evaluator declaration; an exit alone cannot
+ * prove a command was accidental, and model prose cannot establish intent.
+ */
+export function summarizeHarnessDiagnostics(input: {
+  events: readonly LogEvent[]; requests: readonly DiagnosticRequest[];
+  expectedNonzeroCallIds?: readonly string[];
+}) {
+  const tools: Record<string, ToolCounters> = {};
+  const tool = (name: string): ToolCounters => tools[name] ??= counters();
+  const calls = new Map<string, Call>(), results = new Map<string, ToolResultEvent[]>(), seenEvents = new Set<string>();
+  const guidance: Record<string, number> = {}, cuts: Record<string, number> = {}, cleanupProcessExits: Record<string, number> = {};
+  let duplicateEvents = 0, interruptions = 0;
+  for (const event of input.events) {
+    if (seenEvents.has(event.id)) { duplicateEvents++; continue; }
+    seenEvents.add(event.id);
+    if (event.t === "guidance") add(guidance, event.reason);
+    if (event.t === "cut") add(cuts, event.reason);
+    if (event.t === "interrupt") interruptions++;
+    if (event.t === "process_exit") add(cleanupProcessExits, String(event.exit));
+    if (event.t === "assistant") for (const block of event.blocks) {
+      if (block.type !== "tool_use") continue;
+      const existing = calls.get(block.call_id), stats = tool(block.name);
+      if (existing?.provider) stats.duplicateProviderCalls++;
+      calls.set(block.call_id, { name: existing?.name ?? block.name, provider: true,
+        invocation: existing?.invocation ?? false, nested: existing?.nested ?? false,
+        providerInput: canonicalValue(block.input), invocationInput: existing?.invocationInput ?? null });
+    }
+    if (event.t === "tool_invocation") {
+      const existing = calls.get(event.call_id), stats = tool(event.name);
+      if (existing?.invocation) stats.duplicateInvocations++;
+      calls.set(event.call_id, { name: existing?.name ?? event.name, provider: existing?.provider ?? false,
+        invocation: true, nested: event.parent_call_id !== undefined,
+        providerInput: existing?.providerInput ?? null, invocationInput: event.input_ref.sha256 });
+    }
+    if (event.t === "tool_result") {
+      const found = results.get(event.call_id) ?? [];
+      found.push(event); results.set(event.call_id, found);
+    }
+  }
+  const providerInputs = new Map<string, Set<string>>(), invocationInputs = new Map<string, Set<string>>();
+  const repeat = (groups: Map<string, Set<string>>, name: string, key: string | null): boolean => {
+    if (key === null) return false;
+    const seen = groups.get(name) ?? new Set<string>(), repeated = seen.has(key);
+    seen.add(key); groups.set(name, seen); return repeated;
+  };
+  for (const [id, call] of calls) {
+    const stats = tool(call.name); stats.calls++;
+    if (call.provider) stats.providerCalls++;
+    if (call.invocation) stats.invocations++;
+    if (call.nested) stats.nestedInvocations++;
+    if (repeat(providerInputs, call.name, call.providerInput)) stats.repeatedProviderInputs++;
+    if (repeat(invocationInputs, call.name, call.invocationInput)) stats.repeatedInvocationInputs++;
+    if (results.has(id)) stats.pairedCalls++; else stats.orphanCalls++;
+  }
+  const expected = new Set(input.expectedNonzeroCallIds ?? []);
+  for (const [id, found] of results) {
+    const call = calls.get(id), stats = tool(call?.name ?? "<orphan>");
+    stats.duplicateResults += Math.max(0, found.length - 1);
+    for (const event of found) {
+      stats.results++;
+      if (!call) stats.orphanResults++;
+      stats.classes[classifyToolResult(event)]++;
+      if (event.diagnostic) add(stats.diagnosticCodes, event.diagnostic.code);
+      if (event.effect?.kind === "command") {
+        add(stats.commandExits, String(event.effect.exit));
+        if (event.effect.exit !== 0) {
+          if (expected.has(id)) stats.expectedNonzeroCommands++; else stats.undeclaredNonzeroCommands++;
+        }
+      }
+    }
+  }
+  const requestIds = new Set<number>(), requests: {
+    request: number; node: number | null; usageKnown: boolean; promptTokens: number | null;
+    cachedTokens: number | null; cacheWriteTokens: number | null; outputTokens: number | null;
+    cacheHitRate: number | null; responseModel: string | null; failure: string | null;
+    firstDeltaMs: number | null; wallMs: number | null; prefixUnchanged: boolean | null; sharedInputBytes: number | null;
+  }[] = [];
+  const models: Record<string, number> = {};
+  const usage = { knownRequests: 0, unknownRequests: 0, requestsWithCacheReads: 0, promptTokens: 0, cachedTokens: 0,
+    cacheWriteTokens: 0, outputTokens: 0, promptKnownRequests: 0, promptUnknownRequests: 0,
+    cacheCoveredPromptTokens: 0, cacheCoverageRate: null as number | null,
+    observedCacheHitRate: null as number | null, cacheHitRate: null as number | null };
+  const prefix = { sameNodeComparisons: 0, sameNodeMutations: 0, boundaryComparisons: 0, boundaryMutations: 0,
+    unknownComparisons: 0, sameNodeFrozenMutations: 0, boundaryFrozenMutations: 0 };
+  let previous: DiagnosticRequest | undefined, duplicateRequests = 0;
+  for (const request of input.requests.toSorted((a, b) => a.request - b.request)) {
+    if (requestIds.has(request.request)) { duplicateRequests++; continue; }
+    requestIds.add(request.request);
+    const observed = observedUsage(request.usage);
+    const prompt = reportedCount(request.reportedPromptTokens) ?? (observed ?
+      observed.input_tokens + observed.cache_read_input_tokens + observed.cache_creation_input_tokens : null);
+    const output = reportedCount(request.reportedOutputTokens) ?? observed?.output_tokens ?? null;
+    if (prompt !== null) { usage.promptKnownRequests++; usage.promptTokens += prompt; } else usage.promptUnknownRequests++;
+    if (output !== null) usage.outputTokens += output;
+    if (observed) {
+      usage.knownRequests++; usage.cacheCoveredPromptTokens += prompt!; usage.cachedTokens += observed.cache_read_input_tokens;
+      usage.cacheWriteTokens += observed.cache_creation_input_tokens;
+      if (observed.cache_read_input_tokens > 0) usage.requestsWithCacheReads++;
+    } else usage.unknownRequests++;
+    if (request.responseModel !== null) add(models, request.responseModel);
+    if (previous) {
+      if (previous.node === null || request.node === null || request.prefixUnchanged === null) prefix.unknownComparisons++;
+      else if (previous.node === request.node) { prefix.sameNodeComparisons++; if (!request.prefixUnchanged) prefix.sameNodeMutations++; }
+      else { prefix.boundaryComparisons++; if (!request.prefixUnchanged) prefix.boundaryMutations++; }
+      if (previous.frozenSha256 !== null && request.frozenSha256 !== null && previous.frozenSha256 !== request.frozenSha256) {
+        if (previous.node === request.node && request.node !== null) prefix.sameNodeFrozenMutations++;
+        else if (previous.node !== null && request.node !== null) prefix.boundaryFrozenMutations++;
+      }
+    }
+    previous = request;
+    requests.push({ request: request.request, node: request.node, usageKnown: observed !== null, promptTokens: prompt,
+      cachedTokens: observed?.cache_read_input_tokens ?? null, cacheWriteTokens: observed?.cache_creation_input_tokens ?? null,
+      outputTokens: output, cacheHitRate: observed && prompt ? observed.cache_read_input_tokens / prompt : null,
+      responseModel: request.responseModel, failure: request.failure, firstDeltaMs: validTime(request.firstDeltaMs),
+      wallMs: validTime(request.wallMs), prefixUnchanged: request.prefixUnchanged, sharedInputBytes: request.sharedInputBytes });
+  }
+  usage.observedCacheHitRate = usage.cacheCoveredPromptTokens > 0 ? usage.cachedTokens / usage.cacheCoveredPromptTokens : null;
+  usage.cacheCoverageRate = usage.promptUnknownRequests === 0 && usage.promptTokens > 0 ? usage.cacheCoveredPromptTokens / usage.promptTokens : null;
+  usage.cacheHitRate = usage.unknownRequests === 0 && usage.promptTokens > 0 ? usage.cachedTokens / usage.promptTokens : null;
+  const delta = requests.flatMap(r => r.firstDeltaMs === null ? [] : [r.firstDeltaMs]);
+  const totals = counters();
+  for (const stats of Object.values(tools)) {
+    for (const key of Object.keys(totals) as (keyof ToolCounters)[]) {
+      const value = stats[key];
+      if (typeof value === "number") (totals[key] as number) += value;
+    }
+    for (const key of Object.keys(stats.classes) as ResultClass[]) totals.classes[key] += stats.classes[key];
+    for (const key of Object.keys(stats.commandExits)) totals.commandExits[key] = (totals.commandExits[key] ?? 0) + stats.commandExits[key]!;
+    for (const key of Object.keys(stats.diagnosticCodes)) totals.diagnosticCodes[key] = (totals.diagnosticCodes[key] ?? 0) + stats.diagnosticCodes[key]!;
+  }
+  return { eventCount: seenEvents.size, duplicateEvents, tools, totals, guidance, cuts, interruptions, cleanupProcessExits,
+    requestCount: requests.length, duplicateRequests, models, usage, prefix, requests,
+    firstDeltaMs: { samples: delta.length, missing: requests.length - delta.length, p50: quantile(delta, 0.5), p95: quantile(delta, 0.95) } };
+}

package/src/core/oauth-fields.ts

@@ -0,0 +1,44 @@
+/** Validated wire data only; the runtime owns HTTP, time, polling and persistence. */
+export interface OAuthTokens { access: string; refresh: string; expiresIn: number }
+export interface DeviceAuthorization {
+  deviceCode: string;
+  userCode: string;
+  verificationUri: string;
+  verificationUriComplete?: string;
+  expiresIn: number;
+  interval?: number;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+function positive(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value > 0; }
+function token(value: unknown): value is string { return typeof value === "string" && value.length > 0 && !/[\s\x00-\x1f\x7f]/.test(value); }
+
+/** Refresh rotation is optional; omission preserves the existing refresh capability. */
+export function parseOAuthTokens(value: unknown, previousRefresh?: string): OAuthTokens | undefined {
+  const data = record(value);
+  const access = data?.["access_token"], refresh = data?.["refresh_token"] ?? previousRefresh, expiresIn = data?.["expires_in"];
+  if (!token(access) || !token(refresh) || !positive(expiresIn)) return undefined;
+  return { access, refresh, expiresIn };
+}
+
+export function trustedOAuthUrl(value: unknown, origins: readonly string[]): value is string {
+  if (typeof value !== "string" || /[\x00-\x20\x7f]/.test(value)) return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password && origins.includes(url.origin);
+  } catch { return false; }
+}
+
+/** Never open an issuer-supplied arbitrary origin or print its control characters. */
+export function parseDeviceAuthorization(value: unknown, origins: readonly string[]): DeviceAuthorization | undefined {
+  const data = record(value);
+  const deviceCode = data?.["device_code"], userCode = data?.["user_code"], verificationUri = data?.["verification_uri"];
+  const complete = data?.["verification_uri_complete"], expiresIn = data?.["expires_in"], interval = data?.["interval"];
+  if (!token(deviceCode) || typeof userCode !== "string" || !/^[A-Za-z0-9-]+$/.test(userCode)
+    || !trustedOAuthUrl(verificationUri, origins) || !positive(expiresIn)
+    || (complete !== undefined && !trustedOAuthUrl(complete, origins)) || (interval !== undefined && !positive(interval))) return undefined;
+  return { deviceCode, userCode, verificationUri, expiresIn,
+    ...(typeof complete === "string" ? { verificationUriComplete: complete } : {}), ...(typeof interval === "number" ? { interval } : {}) };
+}

package/src/core/program-status.ts

@@ -0,0 +1,31 @@
+/** OSC 7501 revision 0.2: program state, never a model's claim of goal completion (Q24/D11). */
+import type { ExecutionOutcome } from "./outcome.ts";
+
+export type ProgramStatus = { state: "idle" | "working" | "done" | "blocked" | "error" | "clear";
+  kind?: "permission" | "question" | "auth"; msg?: string };
+export function programStatus(input: { running: boolean; waiting?: "permission" | "question" | "auth" | null;
+  outcome?: ExecutionOutcome; goal?: string }): ProgramStatus {
+  if (input.waiting) return { state: "blocked", kind: input.waiting, msg: input.waiting === "auth" ? "Sign in to continue" : input.waiting === "permission" ? "Tool approval required" : "User input required" };
+  if (input.running) return { state: "working", msg: "Agent is working" };
+  if (input.outcome?.status === "cancelled") return { state: "idle", msg: "Turn cancelled" };
+  if (input.outcome?.status === "failed") return { state: "error", msg: "Turn failed; inspect the session" };
+  if (input.outcome?.status === "stopped") return { state: "blocked", kind: "question", msg: "Turn stopped; review evidence before continuing" };
+  if (input.goal === "awaiting_human" || input.goal === "blocked") return { state: "blocked", kind: "question", msg: "Goal awaits user review" };
+  if (input.outcome?.reason === "model_end") return { state: "done", msg: input.goal === "verified" ? "Goal verified against its contract" : "Turn finished; goal verification incomplete" };
+  return { state: "idle", msg: "Ready for a request" };
+}
+export const PROGRAM_STATUS_QUERY = "\x1b]7501;?\x1b\\";
+export function programStatusReply(sequence: string): boolean { return /^\x1b\]7501;\?[^\x00-\x1f\x7f]*(?:\x07|\x1b\\)$/.test(sequence); }
+
+export function encodeProgramStatus(status: ProgramStatus, id: string): string {
+  if (id.length > 128 || id.split("/").length > 8 || !id.split("/").every(part => /^[A-Za-z0-9_.+-]{1,32}$/.test(part))) throw Error("invalid program status id");
+  let message = "", size = 0;
+  // Protocol's decoded UTF-8 cap. Remove controls before encoding; never split a code point.
+  for (const point of (status.msg ?? "").replace(/[\x00-\x1f\x7f-\x9f\p{Cf}]/gu, " ")) {
+    const bytes = new TextEncoder().encode(point); if (size + bytes.length > 2048) break;
+    message += point; size += bytes.length;
+  }
+  const encoded = btoa(Array.from(new TextEncoder().encode(message), byte => String.fromCharCode(byte)).join(""));
+  return `\x1b]7501;state=${status.state}:app=xeno:id=${id}` +
+    (status.state === "blocked" && status.kind ? `:kind=${status.kind}` : "") + (message ? `:msg=${encoded}` : "") + "\x1b\\";
+}

package/src/core/project.ts

@@ -89,10 +89,31 @@ export interface ProjectResult {
 }
 
 export interface ProjectViolation {
-  code: "UNPAIRED_TOOL_USE" | "ORPHAN_TOOL_RESULT" | "EMPTY_PROJECTION";
+  code: "UNPAIRED_TOOL_USE" | "ORPHAN_TOOL_RESULT" | "EMPTY_PROJECTION" | "DUPLICATE_TOOL_USE" | "EMPTY_TOOL_USE_ID";
   detail: string;
 }
 
+/**
+ * D5: a receipt identifies exactly one call in its assistant batch. Validate
+ * before either the projection's Set or the runtime's scheduling Map can erase
+ * a collision; repairing IDs would invent provider protocol history.
+ */
+export function toolCallIdentityViolations(blocks: readonly AssistantBlock[]): ProjectViolation[] {
+  const violations: ProjectViolation[] = [], seen = new Map<string, number>();
+  for (const [index, block] of blocks.entries()) {
+    if (block.type !== "tool_use") continue;
+    if (block.call_id.trim().length === 0) {
+      violations.push({ code: "EMPTY_TOOL_USE_ID", detail: `tool_use block ${index} has an empty call_id` });
+      continue;
+    }
+    const previous = seen.get(block.call_id);
+    if (previous !== undefined) {
+      violations.push({ code: "DUPLICATE_TOOL_USE", detail: `tool_use block ${index} repeats the call_id of block ${previous}` });
+    } else seen.set(block.call_id, index);
+  }
+  return violations;
+}
+
 /**
  * The only event types that replay as messages.
  *
@@ -346,6 +367,9 @@ export function projectContext(input: ProjectInput): ProjectResult {
 
     if (e.t === "assistant") {
       flushPending();
+      violations.push(...toolCallIdentityViolations(e.blocks).map(violation => ({
+        ...violation, detail: `assistant turn ${e.id}: ${violation.detail}`,
+      })));
       if (awaiting.size > 0) {
         violations.push({
           code: "UNPAIRED_TOOL_USE",

package/src/core/request-progress.ts

@@ -0,0 +1,87 @@
+/** Q23 / D9: diagnostic observations, never a new anti-stall or success policy. */
+import type { LogEvent, ToolResultEvent } from "./events.ts";
+import { deriveAcceptance, type AcceptanceState } from "./acceptance.ts";
+import { advanceRecovery, emptyRecoveryState, failureIdentity } from "./failure-recovery.ts";
+import { canonicalValue } from "./continuation.ts";
+import { changedPaths } from "./checkpoints.ts";
+
+export type RequestSource = { node: number; event: string };
+export type RequestRecord = { node: number; event: LogEvent };
+export type RequestProgress = Record<"observations" | "artifact_changes" | "acceptance_advances" |
+  "new_diagnostics" | "unchanged_retries" | "unknown_diagnostics", RequestSource[]>;
+const object = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
+
+function observationDigest(event: ToolResultEvent): string | undefined {
+  if (event.observation_sha256 !== undefined) return event.observation_sha256;
+  // Command receipts archive stdout/stderr before the timing/session header is
+  // rendered. Only that explicit matching output reference is a safe fallback.
+  const data = event.data;
+  if (event.effect?.kind !== "command" || !event.content_ref || !object(data) || data["capture"] === "partial") return undefined;
+  const output = data["output"];
+  return object(output) &&
+    output["sha256"] === event.content_ref.sha256 && output["bytes"] === event.content_ref.bytes ? event.content_ref.sha256 : undefined;
+}
+
+export function deriveRequestProgress(records: readonly RequestRecord[]): RequestProgress {
+  const result: RequestProgress = { observations: [], artifact_changes: [], acceptance_advances: [],
+    new_diagnostics: [], unchanged_retries: [], unknown_diagnostics: [] };
+  const observations = new Set<string>(), versions = new Set<string>(), failures = new Set<string>();
+  let acceptance: AcceptanceState | undefined;
+  let recovery = emptyRecoveryState();
+  const version = (path: string, before: string | null, after: string | null, source: RequestSource) => {
+    const key = (sha: string | null) => canonicalValue([path, sha]);
+    versions.add(key(before));
+    if (!versions.has(key(after))) result.artifact_changes.push(source);
+    versions.add(key(after));
+  };
+  for (const { node, event } of records) {
+    const source = { node, event: event.id };
+    const before = acceptance;
+    acceptance = deriveAcceptance(acceptance, [event]);
+    if (acceptance && before?.contract_event === acceptance.contract_event && acceptance.criteria.some(item =>
+      (item.status === "pass" || item.status === "accepted") &&
+      before.criteria.find(old => old.id === item.id)?.status !== item.status)) result.acceptance_advances.push(source);
+    if (event.t === "tool_result") {
+      const effect = event.effect;
+      const call = recovery.calls.get(event.call_id);
+      if (effect?.kind === "edit") version(effect.path, effect.sha256_before, effect.sha256_after, source);
+      if (effect?.kind === "read") versions.add(canonicalValue([effect.path, effect.sha256]));
+      // Semantic digests exclude command timing/preview metadata. Legacy raw
+      // output hashes cannot prove a new diagnostic and stay explicitly unknown.
+      const digest = observationDigest(event);
+      if (!event.ok) {
+        const identity = call ? failureIdentity(call, event, recovery, path => path) : null;
+        if (digest === undefined || identity === null) result.unknown_diagnostics.push(source);
+        else {
+          const key = canonicalValue([identity, digest]);
+          (failures.has(key) ? result.unchanged_retries : result.new_diagnostics).push(source);
+          failures.add(key);
+        }
+      } else if ((effect?.kind === "read" || effect?.kind === "command" ||
+          ["grep", "find", "ls", "query", "history", "environment"].includes(call?.name ?? "")) &&
+          digest !== undefined && (event.content_ref?.bytes ?? event.content.length) > 0 && !observations.has(digest)) {
+        result.observations.push(source); observations.add(digest);
+      }
+      if (effect?.kind === "command") for (const output of effect.artifacts?.outputs ?? []) {
+        if (output.after.state === "observed") version(output.path,
+          output.before.state === "observed" ? output.before.sha256 : null, output.after.sha256, source);
+      }
+    } else if (event.t === "checkpoint" && event.phase === "applied") {
+      for (const path of changedPaths(event.changes)) {
+        const change = event.changes[path]!;
+        version(path, change.before?.sha256 ?? null, change.after?.sha256 ?? null, source);
+      }
+    }
+    recovery = advanceRecovery(recovery, [event], path => path);
+  }
+  // One receipt may change several artifacts or satisfy several criteria.
+  for (const key of Object.keys(result) as (keyof RequestProgress)[]) {
+    const seen = new Set<string>();
+    result[key] = result[key].filter(source => {
+      const id = canonicalValue(source);
+      if (seen.has(id)) return false;
+      seen.add(id); return true;
+    });
+  }
+  return result;
+}

package/src/core/request-state.ts

@@ -0,0 +1,114 @@
+/** Q23 / D8 / D11: disposable request evidence, derived only from the selected log ancestry. */
+import type { LogEvent } from "./events.ts";
+import { deriveAcceptance, type AcceptanceState } from "./acceptance.ts";
+import { changedPaths } from "./checkpoints.ts";
+import { evidenceStale, isCommandResult, resolveEvidence } from "./evidence.ts";
+import { executionOutcome, modelOutcome, type ExecutionOutcome } from "./outcome.ts";
+import { deriveWorkItems, type WorkItem } from "./work-state.ts";
+import { deriveRequestProgress, type RequestProgress, type RequestRecord, type RequestSource } from "./request-progress.ts";
+
+export type RequestPart = { node: number; events: readonly LogEvent[] };
+export type RequestCommand = {
+  source: RequestSource; command: string; exit: number; status: "pass" | "fail" | "stale" | "superseded";
+  gate?: string; workspace_sha256?: string; workspace_scope?: "source-v1"; criteria: string[];
+};
+export type RequestArtifact = { source: RequestSource; path: string; sha256: string | null;
+  kind: "read" | "edit" | "checkpoint" | "command_output" };
+export type RequestState = {
+  request: RequestSource; inputs: RequestSource[];
+  status: "verified" | "awaiting_human" | "needs_work" | "blocked" | "unverified" | "not_applicable";
+  execution?: ExecutionOutcome; acceptance?: AcceptanceState;
+  commands: RequestCommand[]; artifacts: RequestArtifact[]; work: WorkItem[];
+  reported_blockers: { source: RequestSource; reason: string }[];
+  progress: RequestProgress;
+  changed: boolean; used_tools: boolean; reviewed: boolean;
+  final?: { source: RequestSource; text: string; has_tools: boolean };
+};
+
+/** New steering events refer to their original user event. Legacy users remain separate requests. */
+export function currentRequestRecords(parts: readonly RequestPart[]): RequestRecord[] {
+  const records = parts.flatMap(part => part.events.map(event => ({ node: part.node, event })));
+  const last = records.findLastIndex(({ event }) => event.t === "user");
+  if (last < 0) return [];
+  const user = records[last]!.event;
+  if (user.t !== "user") return [];
+  const start = user.request === undefined ? last : records.findIndex(({ event }) => event.t === "user" && event.id === user.request);
+  // Never reach through an unrelated user request because of an invalid reference.
+  if (start < 0 || records.slice(start + 1, last + 1).some(({ event }) => event.t === "user" && event.request !== user.request)) return records.slice(last);
+  return records.slice(start);
+}
+
+export function deriveRequestState(parts: readonly RequestPart[]): RequestState | undefined {
+  const records = currentRequestRecords(parts);
+  const first = records[0];
+  if (!first) return undefined;
+  const events = records.map(record => record.event);
+  const source = ({ node, event }: RequestRecord): RequestSource => ({ node, event: event.id });
+  const request = source(first);
+  const acceptance = deriveAcceptance(undefined, events.filter(event => event.t !== "acceptance_contract" || event.request === request.event));
+  const commands: RequestCommand[] = [], artifacts: RequestArtifact[] = [];
+  const lastCommands = new Map<string, string>();
+  for (const event of events) if (isCommandResult(event)) lastCommands.set(event.effect.cmd, event.id);
+  let work: WorkItem[] = [];
+  const ids = new Set(events.map(event => event.id)), completed = new Set<string>();
+  // Keep the existing work-item same-segment evidence contract (D11/O.2).
+  for (const part of parts) {
+    work = deriveWorkItems(work, part.events);
+    for (let index = 0; index < part.events.length; index++) {
+      const event = part.events[index]!;
+      // Legacy completed claims supersede a same-named blocker only when the
+      // original same-segment evidence resolves, just as in deriveHandoff.
+      if (event.t === "claim" && event.work_id === undefined && ids.has(event.id) &&
+          resolveEvidence(part.events.slice(0, index), event.evidence).ok) completed.add(event.what);
+    }
+  }
+  work = work.filter(item => ids.has(item.opened_at) || ids.has(item.updated_at));
+  const reported_blockers: RequestState["reported_blockers"] = [];
+  let execution: ExecutionOutcome | undefined, final: RequestState["final"], changed = false;
+  for (const record of records) {
+    const event = record.event, ref = source(record);
+    if (event.t === "user") { execution = undefined; final = undefined; }
+    else if (event.t === "assistant") {
+      final = { source: ref, text: event.blocks.flatMap(block => block.type === "text" ? [block.text] : []).join("\n").trim(),
+        has_tools: event.blocks.some(block => block.type === "tool_use") };
+      execution = final.has_tools ? undefined : modelOutcome(event.stop_reason ?? null);
+    } else if (event.t === "outcome") execution = { ...event.outcome };
+    else if (event.t === "interrupt") execution = executionOutcome("cancelled");
+    else if (event.t === "guidance" && (event.reason === "completion_review" || event.reason === "output_recovery")) execution = undefined;
+    if (event.t === "blocked" && (event.work_id ? work.some(item => item.id === event.work_id && item.status === "blocked") : !completed.has(event.what))) {
+      reported_blockers.push({ source: ref, reason: event.reason });
+    }
+    if (isCommandResult(event)) {
+      const effect = event.effect;
+      const evidence = { command: effect.cmd, exit: effect.exit, event_id: event.id, at: event.at,
+        ...(effect.workspace_sha256 === undefined ? {} : { workspace_sha256: effect.workspace_sha256 }),
+        ...(effect.workspace_scope === undefined ? {} : { workspace_scope: effect.workspace_scope }) };
+      commands.push({ source: ref, command: effect.cmd, exit: effect.exit,
+        status: !event.ok || effect.exit !== 0 ? "fail" : effect.workspace_observed === false || evidenceStale(events, evidence) ? "stale"
+          : lastCommands.get(effect.cmd) !== event.id ? "superseded" : "pass",
+        ...(effect.gate === undefined ? {} : { gate: effect.gate }),
+        ...(effect.workspace_sha256 === undefined ? {} : { workspace_sha256: effect.workspace_sha256 }),
+        ...(effect.workspace_scope === undefined ? {} : { workspace_scope: effect.workspace_scope }),
+        criteria: acceptance?.criteria.filter(item => item.kind === "command" && item.command === effect.cmd).map(item => item.id) ?? [] });
+      for (const output of effect.artifacts?.outputs ?? []) if (output.after.state === "observed") artifacts.push({
+        source: ref, path: output.path, sha256: output.after.sha256, kind: "command_output" });
+    } else if (event.t === "tool_result" && (event.effect?.kind === "read" || event.effect?.kind === "edit")) {
+      const effect = event.effect;
+      artifacts.push({ source: ref, path: effect.path, sha256: effect.kind === "read" ? effect.sha256 : effect.sha256_after, kind: effect.kind });
+      if (effect.kind === "edit" && effect.sha256_before !== effect.sha256_after) changed = true;
+    } else if (event.t === "checkpoint" && event.phase === "applied") {
+      for (const path of changedPaths(event.changes)) artifacts.push({ source: ref, path, sha256: event.changes[path]!.after?.sha256 ?? null, kind: "checkpoint" });
+      changed ||= changedPaths(event.changes).length > 0;
+    } else if (event.t === "workspace_observation") changed ||= event.changed;
+    else if (event.t === "snapshot") changed ||= Object.keys(event.added).length + Object.keys(event.changed).length + event.removed.length > 0;
+  }
+  return { request, inputs: records.filter(record => record.event.t === "user").map(source),
+    // Work notes can describe a later phase the user explicitly asked to defer.
+    // Only the declared request contract defines what must finish in this request.
+    status: reported_blockers.length ? "blocked" : acceptance?.status ?? "unverified",
+    ...(execution ? { execution } : {}), ...(acceptance ? { acceptance } : {}),
+    commands, artifacts, work, reported_blockers, progress: deriveRequestProgress(records), changed,
+    used_tools: events.some(event => event.t === "tool_result"),
+    reviewed: events.some(event => event.t === "guidance" && event.reason === "completion_review"),
+    ...(final ? { final } : {}) };
+}

package/src/core/settings.ts

@@ -113,6 +113,13 @@ export const DISPLAY_SETTINGS = [
   { id: "terminal.clearOnShrink", label: "Clear on shrink", fallback: "off" },
   { id: "terminal.showTerminalProgress", label: "Terminal progress", fallback: "on" },
 ] as const;
+/** Only fields with a real picker may be suggested without a value. Raw config keys remain writable explicitly. */
+export function interactiveSettingKeys(): string[] {
+  const pickers = ["theme", "thinking", "defaultModel", "modelThinkingLevels"];
+  return [...new Set([...pickers, ...SETTINGS_KEYS, ...DISPLAY_SETTINGS.map(item => item.id)])]
+    .filter(key => pickers.includes(key) || settingValues(key).length > 0);
+}
+
 export function defaultSettings(): Settings { return { theme: "dark", thinking: "high", statusBar: true }; }
 export function mergeSettings(layers: SettingsLayers): Settings {
   const { defaultProjectTrust: _projectCannotGrantTrust, ...project } = layers.project ?? {};

package/src/core/tool-input.ts

@@ -12,6 +12,12 @@
  */
 type Input = Record<string, unknown>;
 
+/** O.3: incomplete wire JSON remains the original input so admission can refuse it without effects. */
+export function completedToolInput(raw: string): unknown {
+  try { return JSON.parse(raw) as unknown; }
+  catch { return raw; }
+}
+
 function parsedJson(value: unknown): unknown {
   if (typeof value !== "string") return value;
   const trimmed = value.trim();