@volter/supercode-interchange 0.1.3 → 0.1.5

package/README.md

@@ -42,8 +42,8 @@ attaches native subagent transcripts and verifies the main and child file
 identities. Its scoped index retains graph references and ordering/count
 skeletons while materializing only requested assistant groups and summary
 messages. The file handle closes before the result leaves the scope. The
-public read/follow handoff has source and syntax checks only, with no runtime
-qualification claimed yet.
+public read/follow handoff has [scoped private Mac/Windows observations](../../docs/evidence/session-read-port-2026-10-08.md);
+these do not qualify a large corpus, native children or remote admission.
 Codex has separate model-context and bounded display-history readers. The
 model reader retains compaction replacement, turn grouping, reasoning and
 native typed-input pairing; the display reader projects durable TurnItems or
@@ -57,15 +57,16 @@ dialect follows recorded leaf redirects, excludes side appends from default
 leaf selection and keeps vendor references inert. Unknown Pi image shapes
 remain raw-only, following the existing reader's refusal to synthesize image
 data it cannot establish. These are read-library additions, with no new
-OpenClaw write tier or runtime qualification.
+OpenClaw write tier. The observation above covers a small recorded leaf branch,
+not every native compaction or side-append shape.
 OpenCode's envelope and export-document readers share creation/id ordering,
 compaction boundaries, portable message extensions and task-child provenance.
 Completed tool parts split into calls/results, retaining masked original output
 and attachment content. Its SQLite reader reconstructs native columns, reads
 the external revert sidecar and verifies both identities; malformed JSON columns
 remain diagnostic. Legacy JSON-tree directories retain their native
-unsupported-source refusal. No runtime qualification is claimed for this
-checkpoint.
+unsupported-source refusal. The small envelope observation does not qualify
+concurrent SQLite/revert changes or all compaction/tool shapes.
 The path layer selects formats structurally, pins native store selectors and
 reads compressed transcripts through Node's zstd support. Native sidecars
 validate framing and retain malformed appended turns as raw parse loss.
@@ -95,6 +96,33 @@ The SDK checks the read capability before moved requests; an older service
 refuses explicitly instead of supplying a native read. Its catalog and other
 retained operations remain independently available on the same client.
 
+`./session-claude-runtime` folds the complete recorded Claude runtime manifest:
+posture, cron/wakeup results, queue references, async child outcomes and
+verbatim runtime residue. It validates forward references before exposing
+posture and neither fires schedules nor launches children. The public
+`sessions.recorded_config` door uses that full fold, leaving permission mode
+unknown if unrelated runtime records are malformed. Codex policies come only
+from recorded headers, with opaque values and numeric tokens retained. The
+capability's `recorded_config` marker distinguishes this moved method from
+older read services; retained methods and startup remain available after a
+refusal. [Private Mac/Windows observations](../../docs/evidence/session-recorded-config-2026-10-08.md)
+cover recorded posture/policies through npm and operator streams, including
+unknown posture for malformed records. The manifest's other branches,
+corpus/scale, concurrent reads and independent source review remain open.
+
+`sessions.launch_agent` reads `<harness home>/supercode/launches/<session id>.json`
+in the same caller-owned load lane. Claude `projects` and Codex `sessions`
+ancestors select the transcript's recorded home, independent of current vendor
+defaults; no transcript must exist. Unsupported locators, unsafe ids, absent,
+invalid UTF-8 or malformed records, and nonobject environments return null.
+The environment is recorded metadata, never caller authority. The new
+`launch_agent` capability marker refuses older read services explicitly.
+Native runtime launch-record writers remain for their separate replacement.
+[Private Mac/Windows conversations](../../docs/evidence/session-launch-metadata-2026-10-08.md)
+record selected-home answers and null malformed metadata through npm and
+operator streams; concurrent path/record replacement and runtime writing remain
+unqualified.
+
 `resolveHarnessHomes` follows native HOME-first defaults and preserves explicitly empty harness-specific
 home values. `projectMetadata` applies workspace scope, native lineage, repository-family, profile, time and
 metadata-search filters with stable newest-first ordering. It clones raw rows before descendant roll-up.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-interchange",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Read-only harness metadata, transcript codecs and session projections for Supercode",
   "license": "MIT OR Apache-2.0",
@@ -20,6 +20,10 @@
     "./session-read": {
       "types": "./session-read.d.ts",
       "import": "./session-read.mjs"
+    },
+    "./session-claude-runtime": {
+      "types": "./session-claude-runtime.d.ts",
+      "import": "./session-claude-runtime.mjs"
     }
   },
   "files": [

package/session-claude-runtime.d.ts

@@ -0,0 +1,35 @@
+import type { Session } from './session-model.js';
+export const CLAUDE_RUNTIME_MANIFEST_VERSION: 1;
+export interface ClaudeRuntimePosture {
+  permission_mode: string | null; last_prompt_leaf_uuid: string | null;
+  last_prompt: string | null; timestamp: string | null; entrypoint: string | null;
+  user_type: string | null; version: string | null; cwd: string | null;
+}
+export interface ClaudeCronJob {
+  id: string; tool_use_id: string; schedule: string; recurring: boolean;
+  durable_requested: boolean; prompt: string; created_at: string | null;
+  expires_after_seconds: number | null; creation_result: string;
+}
+export interface ClaudeWakeup {
+  tool_use_id: string; delay_seconds: number; reason: string | null;
+  prompt: string | null; created_at: string | null; scheduled_for: string | null;
+  creation_result: string;
+}
+export interface ClaudeQueueState { enqueued: number; dequeued: number; removed: number; pending: string[] }
+export type ClaudeBackgroundState = 'launch_pending' | 'running' | 'completed' | 'failed' | 'killed' | 'unknown_terminal';
+export interface ClaudeBackgroundChild {
+  tool_use_id: string; origin_observed: boolean; agent_id: string | null;
+  agent_type: string | null; description: string | null; requested_model: string | null;
+  resolved_model: string | null; prompt: string | null; output_file: string | null;
+  state: ClaudeBackgroundState; started_at: string | null; finished_at: string | null;
+  summary: string | null;
+}
+export interface ClaudeRuntimeResidue { line: number; kind: string; raw: string }
+export interface ClaudeRuntimeManifest {
+  schema_version: 1; posture: ClaudeRuntimePosture; active_crons: ClaudeCronJob[];
+  pending_wakeups: ClaudeWakeup[]; queue: ClaudeQueueState;
+  background_children: ClaudeBackgroundChild[];
+  reported_pending_background_children: number | null; residue: ClaudeRuntimeResidue[];
+}
+/** A pure strict fold. It never executes scheduled work or launches a child. */
+export function claudeRuntimeManifest(session: Session): ClaudeRuntimeManifest;

package/session-claude-runtime.mjs

@@ -0,0 +1,213 @@
+// Pure reconstruction of recorded Claude runtime facts. Jobs, wakeups and
+// child states in this manifest are evidence; this module never executes them.
+import { parseNativeJson, nativeInteger, setNativeInteger } from './native-json.mjs';
+import { field, stringField } from './session-codec-utils.mjs';
+import { nativeTrim } from './text.mjs';
+
+export const CLAUDE_RUNTIME_MANIFEST_VERSION = 1;
+const fail = message => { throw new Error(message); };
+const order = (left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right));
+const sorted = map => [...map.keys()].sort(order).map(key => map.get(key));
+const bool = (value, key) => field(value, key) === true;
+const required = (value, key, line, kind) => stringField(value, key)
+  ?? fail(`malformed Claude ${kind} at line ${line}: missing string ${key}`);
+const residue = (state, line, kind, raw) => state.residue.push({ line, kind, raw });
+const runtimeResult = text => ['Scheduled recurring job ', 'Scheduled job ', 'Scheduled one-shot task ', 'Cancelled job ', 'Next wakeup scheduled for '].some(prefix => text.startsWith(prefix));
+const runtimeType = kind => ['queue', 'permission', 'schedule', 'cron', 'background'].some(word => kind.includes(word));
+function between(text, start, end) {
+  const from = text.indexOf(start); if (from < 0) return null;
+  const rest = text.slice(from + start.length), until = rest.indexOf(end);
+  return until < 0 ? null : rest.slice(0, until);
+}
+function taskNotification(text) {
+  if (!text.includes('<task-notification>')) return null;
+  const tag = name => between(text, `<${name}>`, `</${name}>`);
+  return { task_id: tag('task-id'), tool_use_id: tag('tool-use-id'), status: tag('status'), summary: tag('summary') };
+}
+function resultText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return null;
+  const joined = content.filter(block => stringField(block, 'type') === 'text').map(block => stringField(block, 'text')).filter(text => text != null).join('\n');
+  return joined === '' ? null : joined;
+}
+function cronId(text) {
+  const prefix = ['Scheduled recurring job ', 'Scheduled job ', 'Scheduled one-shot task '].find(prefix => text.startsWith(prefix));
+  if (prefix == null) return null;
+  const rest = nativeTrim(text.slice(prefix.length));
+  return rest === '' ? null : rest.split(/[\u0009-\u000d\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+/u)[0];
+}
+function emptyChild(id, timestamp) {
+  return { tool_use_id: id, origin_observed: true, agent_id: null, agent_type: null, description: null,
+    requested_model: null, resolved_model: null, prompt: null, output_file: null,
+    state: 'launch_pending', started_at: timestamp, finished_at: null, summary: null };
+}
+function assistantCalls(value, line, raw, state) {
+  const content = field(field(value, 'message'), 'content'); if (!Array.isArray(content)) return;
+  const timestamp = stringField(value, 'timestamp');
+  for (const block of content) {
+    if (stringField(block, 'type') !== 'tool_use') continue;
+    const name = stringField(block, 'name'); if (name == null) continue;
+    const id = stringField(block, 'id');
+    if (id == null) {
+      if (['CronCreate', 'CronDelete', 'ScheduleWakeup', 'Agent'].includes(name)) fail(`malformed Claude runtime tool call at line ${line}: ${name} has no id`);
+      continue;
+    }
+    const input = field(block, 'input'); let call = null;
+    if (name === 'CronCreate') call = { kind: name, tool_use_id: id, schedule: required(input, 'cron', line, name),
+      recurring: bool(input, 'recurring'), durable_requested: bool(input, 'durable'), prompt: required(input, 'prompt', line, name), created_at: timestamp };
+    else if (name === 'CronDelete') {
+      const target = stringField(input, 'id'); call = target == null ? { kind: 'Invalid', name } : { kind: name, id: target };
+    } else if (name === 'ScheduleWakeup') {
+      const delay = nativeInteger(input, 'delaySeconds');
+      if (delay == null) fail(`malformed ScheduleWakeup at line ${line}: missing integer delaySeconds`);
+      call = { kind: name, tool_use_id: id, delay_seconds: delay, reason: stringField(input, 'reason'), prompt: stringField(input, 'prompt'), created_at: timestamp };
+    } else if (name === 'CronList') call = { kind: name };
+    else if (name === 'Agent') {
+      const child = emptyChild(id, timestamp);
+      for (const [key, target] of [['subagent_type', 'agent_type'], ['description', 'description'], ['model', 'requested_model'], ['prompt', 'prompt']]) child[target] = stringField(input, key);
+      if (state.children.has(id)) fail(`malformed Claude Agent reference at line ${line}: duplicate tool-use id ${id}`);
+      state.children.set(id, child); residue(state, line, 'agent-call', raw);
+    } else if (name.startsWith('Cron') || name.includes('Wakeup')) residue(state, line, 'unknown-runtime-tool-call', raw);
+    if (call != null) {
+      if (state.pending.has(id)) fail(`malformed Claude runtime reference at line ${line}: duplicate tool-use id ${id}`);
+      state.pending.set(id, call); residue(state, line, 'runtime-tool-call', raw);
+    }
+  }
+}
+function toolResults(value, line, raw, state) {
+  const content = field(field(value, 'message'), 'content'); if (!Array.isArray(content)) return;
+  const timestamp = stringField(value, 'timestamp'), nativeResult = field(value, 'toolUseResult');
+  for (const block of content) {
+    if (stringField(block, 'type') !== 'tool_result') continue;
+    const id = stringField(block, 'tool_use_id'); if (id == null) continue;
+    const text = resultText(field(block, 'content')), isError = bool(block, 'is_error'), child = state.children.get(id);
+    if (child != null) {
+      if (isError) Object.assign(child, { state: 'failed', finished_at: timestamp, summary: text });
+      else if (bool(nativeResult, 'isAsync')) Object.assign(child, { state: 'running', agent_id: stringField(nativeResult, 'agentId'),
+        resolved_model: stringField(nativeResult, 'resolvedModel'), output_file: stringField(nativeResult, 'outputFile') });
+      else Object.assign(child, { state: 'completed', finished_at: timestamp, summary: text });
+      residue(state, line, 'agent-result', raw); continue;
+    }
+    const notification = text == null ? null : taskNotification(text);
+    if (notification != null) {
+      state.notifications.push({ notification, timestamp, line }); residue(state, line, 'agent-notification', raw); continue;
+    }
+    const call = state.pending.get(id); state.pending.delete(id);
+    if (call == null) {
+      if (text != null && runtimeResult(text)) fail(`malformed Claude runtime result at line ${line}: unknown tool-use id ${id}`);
+      continue;
+    }
+    residue(state, line, 'runtime-tool-result', raw); if (isError) continue;
+    if (text == null) fail(`malformed Claude runtime result at line ${line}: non-text result for ${id}`);
+    if (call.kind === 'Invalid') fail(`malformed ${call.name} result at line ${line}: invalid input unexpectedly succeeded`);
+    if (call.kind === 'CronCreate') {
+      const assigned = cronId(text); if (assigned == null) fail(`malformed CronCreate result at line ${line}: no assigned job id`);
+      const job = { id: assigned, tool_use_id: call.tool_use_id, schedule: call.schedule,
+        recurring: text.startsWith('Scheduled recurring job ') ? true : text.startsWith('Scheduled one-shot task ') ? false : call.recurring,
+        durable_requested: call.durable_requested, prompt: call.prompt, created_at: call.created_at,
+        expires_after_seconds: text.includes('Auto-expires after 7 days') ? 604800 : null, creation_result: text };
+      if (state.crons.has(assigned)) fail(`malformed CronCreate result at line ${line}: duplicate active job id ${assigned}`);
+      state.crons.set(assigned, job);
+    } else if (call.kind === 'CronDelete') {
+      if (!text.startsWith('Cancelled job ')) fail(`malformed CronDelete result at line ${line}: unexpected success text`);
+      if (!state.crons.delete(call.id)) fail(`malformed CronDelete reference at line ${line}: unknown active job id ${call.id}`);
+    } else if (call.kind === 'ScheduleWakeup') {
+      const scheduled = between(text, 'Next wakeup scheduled for ', ' (in ');
+      if (scheduled == null) fail(`malformed ScheduleWakeup result at line ${line}: no scheduled time`);
+      state.wakeups.clear();
+      const wakeup = { tool_use_id: call.tool_use_id, delay_seconds: 0, reason: call.reason, prompt: call.prompt,
+        created_at: call.created_at, scheduled_for: scheduled, creation_result: text };
+      setNativeInteger(wakeup, 'delay_seconds', call.delay_seconds); state.wakeups.set(call.tool_use_id, wakeup);
+    } else if (call.kind === 'CronList') {
+      let parsed; try { parsed = parseNativeJson(text); } catch { /* absent intrinsic result */ }
+      // A present record-level null is authoritative too; only absence falls back.
+      const result = nativeResult === undefined ? parsed : nativeResult, jobs = field(result, 'jobs');
+      if (!Array.isArray(jobs)) fail(`malformed CronList result at line ${line}: missing jobs array`);
+      const listed = new Map();
+      for (const job of jobs) {
+        const jobId = required(job, 'id', line, 'CronList job'), schedule = required(job, 'cron', line, 'CronList job'), previous = state.crons.get(jobId);
+        listed.set(jobId, { id: jobId, tool_use_id: previous?.tool_use_id ?? id, schedule,
+          recurring: bool(job, 'recurring'), durable_requested: previous?.durable_requested ?? bool(job, 'durable'),
+          prompt: required(job, 'prompt', line, 'CronList job'), created_at: previous?.created_at ?? null,
+          expires_after_seconds: previous?.expires_after_seconds ?? null, creation_result: previous?.creation_result ?? text });
+      }
+      state.crons = listed;
+    }
+  }
+}
+function applyNotification({ notification: note, timestamp, line }, children) {
+  const byTask = note.task_id == null ? null : [...children.keys()].sort(order).find(id => children.get(id).agent_id === note.task_id);
+  const reference = note.tool_use_id ?? byTask ?? (note.task_id == null ? null : `task:${note.task_id}`);
+  if (reference == null) fail(`malformed Claude task notification at line ${line}: missing tool-use-id and task-id`);
+  let child = children.get(reference);
+  if (child == null) {
+    child = emptyChild(reference, null); Object.assign(child, { origin_observed: false, agent_id: note.task_id,
+      agent_type: note.summary?.startsWith('Background command ') ? 'background-command' : 'unresolved-task', description: note.summary });
+    children.set(reference, child);
+  }
+  child.agent_id ??= note.task_id;
+  child.state = note.status === 'completed' ? 'completed' : ['failed', 'error'].includes(note.status) ? 'failed'
+    : note.status === 'killed' ? 'killed' : 'unknown_terminal';
+  child.finished_at = timestamp; child.summary = note.summary;
+}
+
+/** Reconstruct all runtime-affecting records before exposing any posture.
+ * Invalid unrelated queue/tool/notification references refuse the manifest. */
+export function claudeRuntimeManifest(session) {
+  if (session.meta.source !== 'claude_code') fail('Claude runtime state can only be extracted from a Claude Code session');
+  if (session.parse_error_lines !== 0) fail(`cannot reconstruct Claude runtime state: ${session.parse_error_lines} malformed JSONL line(s)`);
+  const state = { crons: new Map(), pending: new Map(), children: new Map(), wakeups: new Map(), notifications: [], residue: [] };
+  const posture = { permission_mode: null, last_prompt_leaf_uuid: null, last_prompt: null, timestamp: null, entrypoint: null, user_type: null, version: null, cwd: null };
+  const queue = { enqueued: 0, dequeued: 0, removed: 0, pending: [] };
+  let incoming = [], outgoing = [];
+  let reported = null;
+  const decode = (raw, line) => {
+    if (nativeTrim(raw) === '') return null;
+    try { return { value: parseNativeJson(raw) }; }
+    catch (error) { fail(`cannot reconstruct Claude runtime state: malformed JSON at line ${line}: ${error.message}`); }
+  };
+  // Calls precede the ordered fold so physically earlier async results can
+  // resolve their origins. Each pass releases one parsed record at a time.
+  for (let offset = 0; offset < session.raw.length; offset++) {
+    const raw = session.raw[offset], line = offset + 1, decoded = decode(raw, line); if (decoded == null) continue;
+    if (stringField(decoded.value, 'type') === 'assistant') assistantCalls(decoded.value, line, raw, state);
+  }
+  for (let offset = 0; offset < session.raw.length; offset++) {
+    const raw = session.raw[offset], line = offset + 1, decoded = decode(raw, line); if (decoded == null) continue;
+    const { value } = decoded;
+    for (const [key, target] of [['timestamp', 'timestamp'], ['entrypoint', 'entrypoint'], ['userType', 'user_type'], ['version', 'version'], ['cwd', 'cwd']]) {
+      const text = stringField(value, key); if (text != null) posture[target] = text;
+    }
+    const kind = stringField(value, 'type') ?? '';
+    if (kind === 'permission-mode') { posture.permission_mode = required(value, 'permissionMode', line, 'permission-mode'); residue(state, line, kind, raw); }
+    else if (kind === 'last-prompt') {
+      posture.last_prompt_leaf_uuid = stringField(value, 'leafUuid'); posture.last_prompt = stringField(value, 'lastPrompt'); residue(state, line, kind, raw);
+    } else if (kind === 'queue-operation') {
+      const operation = required(value, 'operation', line, kind);
+      if (operation === 'enqueue') {
+        const content = required(value, 'content', line, 'queue enqueue'); queue.enqueued++; incoming.push(content);
+        const fired = [...state.wakeups.keys()].sort(order).find(id => { const held = state.wakeups.get(id); return (held.prompt ?? held.reason) === content; });
+        if (fired !== undefined) state.wakeups.delete(fired);
+        const notification = taskNotification(content); if (notification != null) state.notifications.push({ notification, timestamp: stringField(value, 'timestamp'), line });
+      } else if (operation === 'dequeue' || operation === 'remove') {
+        queue[operation === 'dequeue' ? 'dequeued' : 'removed']++;
+        if (!outgoing.length) { outgoing = incoming.reverse(); incoming = []; }
+        if (!outgoing.length) fail(`malformed Claude queue reference at line ${line}: ${operation} with an empty queue`);
+        outgoing.pop();
+      } else { residue(state, line, `unknown-queue-operation:${operation}`, raw); continue; }
+      residue(state, line, kind, raw);
+    } else if (kind === 'user') toolResults(value, line, raw, state);
+    else if (kind === 'system') {
+      const count = nativeInteger(value, 'pendingBackgroundAgentCount');
+      if (count != null) { reported = count; residue(state, line, 'background-count', raw); }
+      else if (stringField(value, 'subtype') === 'scheduled_task_fire') residue(state, line, 'scheduled-task-fire', raw);
+    } else if (kind !== 'assistant' && runtimeType(kind)) residue(state, line, 'unknown-runtime-record', raw);
+  }
+  for (const notification of state.notifications) applyNotification(notification, state.children);
+  queue.pending = outgoing.reverse().concat(incoming);
+  state.residue.sort((left, right) => left.line - right.line);
+  const manifest = { schema_version: CLAUDE_RUNTIME_MANIFEST_VERSION, posture, active_crons: sorted(state.crons), pending_wakeups: sorted(state.wakeups), queue,
+    background_children: sorted(state.children), reported_pending_background_children: null, residue: state.residue };
+  if (reported != null) setNativeInteger(manifest, 'reported_pending_background_children', reported);
+  return manifest;
+}

package/session-launch-agent.mjs

@@ -0,0 +1,30 @@
+// Recorded launch metadata is a reading, never caller authority. The native
+// runtime writer remains until its own replacement boundary.
+import { readFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, sep } from 'node:path';
+import { parseNativeJson } from './native-json.mjs';
+
+export function recordedLaunchAgent(locator, { cwd = process.cwd() } = {}) {
+  if (locator.storage.kind !== 'file' || !locator.session_id.length
+    || /[^A-Za-z0-9_-]/.test(locator.session_id)) return null;
+  const store = locator.harness === 'codex' ? 'sessions' : locator.harness === 'claude-code' ? 'projects' : null;
+  if (store == null) return null;
+  // Walk the lexical path, starting with the path itself as Path::ancestors
+  // does. Resolving '..' first could choose a different recorded harness home.
+  let at = locator.storage.path, home = null;
+  for (;;) {
+    if (basename(at) === store) { home = dirname(at); break; }
+    const parent = dirname(at);
+    if (parent === at || at === '.') break;
+    at = parent;
+  }
+  if (home == null) return null;
+  // Leave '..' for the filesystem, including its symlink semantics.
+  const path = `${isAbsolute(home) ? '' : `${cwd}${sep}`}${home}${sep}supercode${sep}launches${sep}${locator.session_id}.json`;
+  try {
+    const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(readFileSync(path));
+    const record = parseNativeJson(text);
+    const environment = record && !Array.isArray(record) && typeof record === 'object' ? record.environment : null;
+    return environment && !Array.isArray(environment) && typeof environment === 'object' ? environment : null;
+  } catch { return null; }
+}

package/session-read.d.ts

@@ -3,10 +3,14 @@ import { SessionFollower } from './session-codecs.js';
 import type { ProjectedSessionResult, NormalizedSession, RecordedSessionProfile, RecordedSessionProfileChange } from './session-model.js';
 export const SESSION_READ_METHODS: readonly string[];
 export const SESSION_READ_EVENT: 'harness.v1.sessions.event';
-export const SESSION_READ_CAPABILITY: Readonly<{ version: 1; owner: 'caller'; language: 'typescript'; native_parser: false }>;
+export const SESSION_READ_CAPABILITY: Readonly<{ version: 1; owner: 'caller'; language: 'typescript'; native_parser: false; recorded_config: true; launch_agent: true }>;
 export interface SessionReadContext { cwd?: string; env?: Record<string, string | undefined> }
 export function parseSessionWire(text: string): unknown;
 export function stringifySessionWire(value: unknown): string;
 export function parseSessionReadParams(params: unknown, context?: SessionReadContext): { locator: ReadLocator; fidelity: string; view: (SessionFollowOptions & { fromByte: number | null }) | null; options: import('./session-model.js').SessionLoadOptions | null };
 export function loadSessionRead(params: unknown, context?: SessionReadContext): Promise<ProjectedSessionResult | { session: NormalizedSession & { resolved_profile: RecordedSessionProfile; resolved_profile_history: RecordedSessionProfileChange[] } }>;
 export function openSessionReadFollower(params: unknown, context?: SessionReadContext): Promise<SessionFollower>;
+/** Recorded values only; malformed complete Claude runtime state leaves mode unknown. */
+export function loadRecordedSessionConfiguration(params: unknown, context?: SessionReadContext): Promise<{ harness: string; session_id: string | null; cwd: unknown; model: unknown; approval_policy: unknown; sandbox_policy: unknown; permission_mode: string | null }>;
+/** Best-effort recorded environment only, independent of transcript existence or caller authority. */
+export function loadSessionLaunchAgent(params: unknown, context?: SessionReadContext): Promise<{ environment: Record<string, unknown> | null }>;

package/session-read.mjs

@@ -8,10 +8,12 @@ import { withClaudeReadIndex, supportsClaudeReadIndex } from './session-claude-i
 import { SessionFollower } from './session-follower.mjs';
 import { normalizedSessionJson } from './session-model.mjs';
 import { boundSessionView, projectedMessageWindow, projectedSessionJson, projectedSessionResult, projectedSessionSummary, recordedSessionProfile, recordedSessionProfileHistory } from './session-views.mjs';
+import { recordedSessionConfiguration } from './session-recorded-config.mjs';
+import { recordedLaunchAgent } from './session-launch-agent.mjs';
 
-export const SESSION_READ_METHODS = Object.freeze(['harness.v1.sessions.load', 'harness.v1.sessions.follow', 'harness.v1.sessions.unfollow']);
+export const SESSION_READ_METHODS = Object.freeze(['harness.v1.sessions.load', 'harness.v1.sessions.follow', 'harness.v1.sessions.unfollow', 'harness.v1.sessions.recorded_config', 'harness.v1.sessions.launch_agent']);
 export const SESSION_READ_EVENT = 'harness.v1.sessions.event';
-export const SESSION_READ_CAPABILITY = Object.freeze({ version: 1, owner: 'caller', language: 'typescript', native_parser: false });
+export const SESSION_READ_CAPABILITY = Object.freeze({ version: 1, owner: 'caller', language: 'typescript', native_parser: false, recorded_config: true, launch_agent: true });
 export { parseNativeJson as parseSessionWire, stringifyNativeJson as stringifySessionWire };
 const invalid = (message) => { throw Object.assign(new Error(message), { rpcCode: -32602 }); };
 const object = (value, name) => {
@@ -102,3 +104,20 @@ export async function openSessionReadFollower(params, context = {}) {
   return SessionFollower.openLocator(locator, { ...context, fidelity, includeSubagents: view?.includeSubagents ?? true,
     displayHistory: view?.displayHistory ?? false, messageLimit: view?.messageLimit, maxMessageChars: view?.maxMessageChars });
 }
+
+export async function loadRecordedSessionConfiguration(params, context = {}) {
+  object(params, 'recorded configuration params');
+  // LocatorParams ignores unrelated fields. This door always reads the full
+  // lossless source, independent of any supplied display/load-view knobs.
+  const { locator } = parseSessionReadParams({ locator: params.locator }, context);
+  return recordedSessionConfiguration(await loadSessionLocator(locator, { ...context, fidelity: 'byte_lossless', includeSubagents: true }), locator.harness);
+}
+
+export async function loadSessionLaunchAgent(params, context = {}) {
+  object(params, 'launch metadata params');
+  const { locator } = parseSessionReadParams({ locator: params.locator }, context);
+  // This door needs no transcript or parser. Preserve the original lexical
+  // path for the harness-home lookup, rather than the normalized load path.
+  locator.storage.path = params.locator.storage.path;
+  return { environment: recordedLaunchAgent(locator, context) };
+}

package/session-recorded-config.mjs

@@ -0,0 +1,24 @@
+// The permission reading is exposed only after the complete recorded runtime
+// fold succeeds. Current defaults and a standalone permission line prove none.
+import { parseNativeJson, stringifyNativeJson, stringifyNativeJsonMember } from './native-json.mjs';
+import { field } from './session-codec-utils.mjs';
+import { claudeRuntimeManifest } from './session-claude-runtime.mjs';
+
+export function recordedSessionConfiguration(session, harness) {
+  const values = new Map([
+    ['harness', stringifyNativeJson(harness)], ['session_id', stringifyNativeJson(session.meta.session_id)],
+    ['cwd', stringifyNativeJson(session.meta.cwd)], ['model', stringifyNativeJson(session.meta.model)],
+    ['approval_policy', 'null'], ['sandbox_policy', 'null'], ['permission_mode', 'null'],
+  ]);
+  for (const header of session.meta.codex_headers) {
+    const payload = field(header, 'payload') === undefined ? header : header.payload;
+    for (const key of ['cwd', 'model', 'approval_policy', 'sandbox_policy']) {
+      if (field(payload, key) !== undefined) values.set(key, stringifyNativeJsonMember(payload, key));
+    }
+  }
+  try { values.set('permission_mode', stringifyNativeJson(claudeRuntimeManifest(session).posture.permission_mode)); }
+  catch { /* unsupported or malformed complete manifest leaves posture unknown */ }
+  // Member serialization preserves integer-versus-float facts and opaque
+  // policy values, including records whose values have unexpected JSON types.
+  return parseNativeJson(`{${[...values].map(([key, value]) => `${JSON.stringify(key)}:${value}`).join(',')}}`);
+}