@crazyhappyone/dsh-tui 0.1.0-alpha.5 → 0.1.0-alpha.7

package/dist/index.js

@@ -1,4 +1,3 @@
-import * as __nodeModule from 'node:module'; const require = __nodeModule.createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -31876,6 +31875,126 @@ function assertNever(value, context) {
   const rendered = JSON.stringify(value) ?? String(value);
   throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
 }
+function hasIntrinsicConstructor(prototype, name2) {
+  const descriptor = Object.getOwnPropertyDescriptor(prototype, "constructor");
+  const constructor = descriptor?.value;
+  if (typeof constructor !== "function") return false;
+  try {
+    return constructor.name === name2 && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name2}() { [native code] }`;
+  } catch {
+    return false;
+  }
+}
+function isIntrinsicObjectPrototype(value) {
+  return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor(value, "Object");
+}
+function hasPlainArrayPrototype(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, "Array")) return false;
+  const objectPrototype = Object.getPrototypeOf(prototype);
+  return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype(objectPrototype);
+}
+function hasPlainObjectPrototype(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
+}
+function enumerableStringKeys(value) {
+  const keys = Reflect.ownKeys(value);
+  if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
+  return keys;
+}
+function walkJsonValue(value, detach) {
+  const ancestors = /* @__PURE__ */ new Set();
+  let root;
+  const assign = (destination, item) => {
+    if (destination === void 0) return;
+    if (destination.kind === "root") {
+      root = item;
+    } else if (destination.kind === "array") {
+      destination.target[destination.index] = item;
+    } else {
+      Object.defineProperty(destination.target, destination.key, {
+        value: item,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  };
+  const tasks = [{
+    kind: "visit",
+    value,
+    ...detach ? { destination: { kind: "root" } } : {}
+  }];
+  for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
+    if (task.kind === "leave") {
+      ancestors.delete(task.source);
+      continue;
+    }
+    if (task.kind === "array-item") {
+      if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
+      tasks.push({
+        kind: "visit",
+        value: task.source[task.index],
+        ...task.target === void 0 ? {} : { destination: { kind: "array", target: task.target, index: task.index } }
+      });
+      continue;
+    }
+    if (task.kind === "object-property") {
+      tasks.push({
+        kind: "visit",
+        value: task.source[task.key],
+        ...task.target === void 0 ? {} : { destination: { kind: "object", target: task.target, key: task.key } }
+      });
+      continue;
+    }
+    const current = task.value;
+    if (current === null) {
+      assign(task.destination, null);
+      continue;
+    }
+    if (typeof current === "boolean" || typeof current === "string") {
+      assign(task.destination, current);
+      continue;
+    }
+    if (typeof current === "number") {
+      if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
+      assign(task.destination, current);
+      continue;
+    }
+    if (typeof current !== "object") return void 0;
+    if (ancestors.has(current)) return void 0;
+    if (Array.isArray(current)) {
+      if (!hasPlainArrayPrototype(current)) return void 0;
+      const length = current.length;
+      if (Reflect.ownKeys(current).length !== length + 1) return void 0;
+      const target2 = detach ? [] : void 0;
+      if (target2 !== void 0) assign(task.destination, target2);
+      ancestors.add(current);
+      tasks.push({ kind: "leave", source: current });
+      for (let index2 = length - 1; index2 >= 0; index2--) {
+        tasks.push({ kind: "array-item", source: current, index: index2, ...target2 === void 0 ? {} : { target: target2 } });
+      }
+      continue;
+    }
+    if (!hasPlainObjectPrototype(current)) return void 0;
+    const keys = enumerableStringKeys(current);
+    if (keys === void 0) return void 0;
+    const target = detach ? {} : void 0;
+    if (target !== void 0) assign(task.destination, target);
+    ancestors.add(current);
+    tasks.push({ kind: "leave", source: current });
+    for (let index2 = keys.length - 1; index2 >= 0; index2--) {
+      const key = keys[index2];
+      if (key === void 0) return void 0;
+      tasks.push({ kind: "object-property", source: current, key, ...target === void 0 ? {} : { target } });
+    }
+  }
+  return detach ? root : true;
+}
+function snapshotJsonValue(value) {
+  return walkJsonValue(value, true);
+}
 function deepFreeze(value) {
   const seen = /* @__PURE__ */ new WeakSet();
   const pending = [{ kind: "visit", node: value }];
@@ -32970,10 +33089,763 @@ var UserQuestionError = class extends HarnessError {
   }
 };
 
+// ../deepseek-harness/packages/core/session/src/index.ts
+import { isAbsolute } from "node:path";
+
 // ../deepseek-harness/packages/core/session/src/types.ts
 function SessionId(id) {
   return brandString(id);
 }
+var SESSION_FORMAT_VERSION = 0;
+
+// ../deepseek-harness/packages/core/session/src/surface.ts
+var SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "user/message",
+  "assistant/message",
+  "tool/result"
+]);
+function isSurfaceEligibleType(type) {
+  return SURFACE_EVENT_TYPES.has(type);
+}
+function deriveEventMessage(event) {
+  switch (event.type) {
+    // Ordinary prompts and injected context project in user role: the event's
+    // model-facing content stays verbatim. Do NOT re-add per-type framing
+    // (e.g. `<context>`) here: framing is caller-owned — a producer bakes it
+    // into `content`, as agent-instructions does with `<system-reminder>` — or,
+    // if reintroduced, must be driven by the event `meta` map and a dedicated
+    // renderer, keeping this projection a verbatim pass-through. See the
+    // deferred design note in
+    // ../../../../.agents/notes/implemented/simplification/2026-07-20-unwrap-injected-content-envelopes.md
+    case "user/message": {
+      return event.data;
+    }
+    case "assistant/message": {
+      if (event.data.message.content.length === 0) return null;
+      return event.data.message;
+    }
+    case "tool/result": {
+      return event.data.message;
+    }
+    default:
+      return null;
+  }
+}
+function createFoldState() {
+  return { nodes: [], replaceGeneration: 0 };
+}
+function isEventSeq(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isReplaceOp(value) {
+  const op = value;
+  return Object.keys(op).length === 3 && Object.hasOwn(op, "op") && Object.hasOwn(op, "start") && Object.hasOwn(op, "end") && op["op"] === "replace" && isEventSeq(op["start"]) && isEventSeq(op["end"]);
+}
+function surfaceOpOf(event) {
+  const raw = event;
+  if (!isSurfaceEligibleType(event.type)) {
+    if (raw.surfaceOp !== void 0) {
+      throw new Error(`session event "${event.type}" is not surface-eligible and cannot carry surfaceOp`);
+    }
+    if (raw.sourceEventSeqs !== void 0) {
+      throw new Error(`session event "${event.type}" is not surface-eligible and cannot carry sourceEventSeqs`);
+    }
+    return;
+  }
+  const op = raw.surfaceOp;
+  if (op === void 0) {
+    throw new Error(`session event "${event.type}" is surface-eligible and requires a surfaceOp marker`);
+  }
+  if (op === "append") return op;
+  if (op === null || typeof op !== "object" || Array.isArray(op)) {
+    throw new Error(`session event "${event.type}" carries an invalid surfaceOp`);
+  }
+  if (!isReplaceOp(op)) {
+    throw new Error(`session event "${event.type}" carries an invalid replace surfaceOp`);
+  }
+  return op;
+}
+function assertProvenance(event, shadowedSeqs) {
+  const raw = event.sourceEventSeqs;
+  const sources = /* @__PURE__ */ new Set();
+  if (raw !== void 0) {
+    if (!Array.isArray(raw)) {
+      throw new Error(`sourceEventSeqs on event at seq ${event.seq} must be an array when present`);
+    }
+    if (raw.length === 0 && event.type !== "assistant/message") {
+      throw new Error("sourceEventSeqs must not be empty except on assistant/message");
+    }
+    let nonEarlierSource;
+    for (const source of raw) {
+      if (!isEventSeq(source)) {
+        throw new Error(`session event "${event.type}" sourceEventSeqs must densely contain non-negative safe integers`);
+      }
+      sources.add(source);
+      if (nonEarlierSource === void 0 && source >= event.seq) nonEarlierSource = source;
+    }
+    if (sources.size !== raw.length) {
+      throw new Error("sourceEventSeqs must not contain duplicates");
+    }
+    if (nonEarlierSource !== void 0) {
+      throw new Error(`sourceEventSeqs must reference earlier events: ${nonEarlierSource} >= current seq ${event.seq}`);
+    }
+  }
+  const missing = shadowedSeqs.filter((seq) => !sources.has(seq));
+  if (missing.length > 0) {
+    throw new Error(`surface replace: sourceEventSeqs must include every shadowed surface node; missing ${missing.join(", ")}`);
+  }
+}
+function replacementRange(state, op) {
+  const startIdx = state.nodes.indexOf(op.start);
+  if (startIdx === -1) {
+    throw new Error(`surface replace: start seq ${op.start} not found in surface`);
+  }
+  const endIdx = state.nodes.indexOf(op.end);
+  if (endIdx === -1) {
+    throw new Error(`surface replace: end seq ${op.end} not found in surface`);
+  }
+  if (startIdx > endIdx) {
+    throw new Error(`surface replace: start seq ${op.start} (index ${startIdx}) is after end seq ${op.end} (index ${endIdx})`);
+  }
+  return {
+    startIdx,
+    endIdx,
+    shadowedSeqs: state.nodes.slice(startIdx, endIdx + 1)
+  };
+}
+function isDeepEqualJson(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, i) => isDeepEqualJson(item, b[i]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const aKeys = Object.keys(a);
+  const bRecord = b;
+  if (aKeys.length !== Object.keys(b).length) return false;
+  return aKeys.every((key) => Object.hasOwn(b, key) && isDeepEqualJson(a[key], bRecord[key]));
+}
+function assertToolResultRewrite(event, shadowedSeqs, events, baseSeq) {
+  if (event.type !== "tool/result") return;
+  if (shadowedSeqs.length !== 1) {
+    throw new Error("tool/result surface replacement must rewrite exactly one current node");
+  }
+  for (const originalSeq of shadowedSeqs) {
+    const original = events[originalSeq - baseSeq];
+    if (original?.type !== "tool/result") {
+      throw new Error("tool/result surface replacement must target a current tool/result");
+    }
+    const originalRest = { ...original.data };
+    const replacementRest = { ...event.data };
+    const originalResult = original.data.message.content[0];
+    const replacementResult = event.data.message.content[0];
+    originalRest["message"] = {
+      ...original.data.message,
+      content: [{ ...originalResult, content: null }]
+    };
+    replacementRest["message"] = {
+      ...event.data.message,
+      content: [{ ...replacementResult, content: null }]
+    };
+    if (!isDeepEqualJson(originalRest, replacementRest)) {
+      throw new Error("tool/result surface replacement may change only content");
+    }
+  }
+}
+function planSurfaceEvent(state, event, expectedSeq, events, baseSeq) {
+  if (event.seq !== expectedSeq) {
+    throw new Error(`session event seq ${event.seq} is not contiguous; expected ${expectedSeq}`);
+  }
+  const surfaceOp = surfaceOpOf(event);
+  if (surfaceOp === void 0) return;
+  if (surfaceOp === "append") {
+    assertProvenance(event, []);
+    return { kind: "append", seq: event.seq };
+  }
+  const range = replacementRange(state, surfaceOp);
+  assertProvenance(event, range.shadowedSeqs);
+  assertToolResultRewrite(event, range.shadowedSeqs, events, baseSeq);
+  return {
+    kind: "replace",
+    seq: event.seq,
+    start: surfaceOp.start,
+    end: surfaceOp.end,
+    ...range
+  };
+}
+function applySurfaceEvent(state, event, expectedSeq, events, baseSeq) {
+  const plan = planSurfaceEvent(state, event, expectedSeq, events, baseSeq);
+  return applySurfacePlan(state, plan);
+}
+function applySurfacePlan(state, plan) {
+  if (plan?.kind === "append") {
+    state.nodes.push(plan.seq);
+  } else if (plan?.kind === "replace") {
+    state.nodes.splice(plan.startIdx, plan.endIdx - plan.startIdx + 1, plan.seq);
+    state.replaceGeneration += 1;
+  }
+  if (plan?.kind !== "replace") return;
+  return {
+    seq: plan.seq,
+    start: plan.start,
+    end: plan.end,
+    shadowedSeqs: plan.shadowedSeqs
+  };
+}
+var SurfaceManager = class {
+  /**
+   * @param log - Contiguous complete log or loaded event window.
+   * @param baseSeq - Absolute sequence of the window's first event.
+   */
+  constructor(log, baseSeq = 0) {
+    this.log = log;
+    this.baseSeq = baseSeq;
+    this._lastProcessedSeq = baseSeq - 1;
+  }
+  log;
+  baseSeq;
+  /** Shared transition state; replacement history is not retained. */
+  _state = createFoldState();
+  /** Last processed absolute seq. */
+  _lastProcessedSeq;
+  /** Candidate already validated by `validateNext`, pending exact log admission. */
+  _pendingPlan;
+  /**
+   * Validate the next candidate without mutating the committed surface.
+   * @param event - candidate event that has not entered the log yet.
+   */
+  validateNext(event) {
+    if (this._lastProcessedSeq < this.baseSeq + this.log.length - 1) this._processDelta();
+    const expectedSeq = this.baseSeq + this.log.length;
+    this._pendingPlan = {
+      event,
+      expectedSeq,
+      plan: planSurfaceEvent(this._state, event, expectedSeq, this.log, this.baseSeq)
+    };
+  }
+  /** Monotonic count of folded positional replacements. */
+  get replaceGeneration() {
+    if (this._lastProcessedSeq < this.baseSeq + this.log.length - 1) this._processDelta();
+    return this._state.replaceGeneration;
+  }
+  /** Surface event sequences in model-visible order. */
+  get nodes() {
+    if (this._lastProcessedSeq < this.baseSeq + this.log.length - 1) this._processDelta();
+    return this._state.nodes;
+  }
+  /** Fold events appended since the previous access. */
+  _processDelta() {
+    const tailSeq = this.baseSeq + this.log.length - 1;
+    for (let seq = this._lastProcessedSeq + 1; seq <= tailSeq; seq++) {
+      const index2 = seq - this.baseSeq;
+      const event = this.log[index2];
+      const pending = this._pendingPlan;
+      if (pending?.event === event && pending.expectedSeq === seq) {
+        applySurfacePlan(this._state, pending.plan);
+      } else {
+        applySurfaceEvent(this._state, event, seq, this.log, this.baseSeq);
+      }
+      if (pending !== void 0 && pending.expectedSeq <= seq) this._pendingPlan = void 0;
+      this._lastProcessedSeq = seq;
+    }
+  }
+};
+
+// ../deepseek-harness/packages/core/session/src/request-header.ts
+function canonicalHeader(header) {
+  const adapterDefaults = header.adapterDefaults;
+  return {
+    config: header.config,
+    ...adapterDefaults?.reasoningEffort === true || adapterDefaults?.maxTokens === true ? { adapterDefaults } : {},
+    ...header.system !== void 0 && header.system.length > 0 ? { system: header.system } : {},
+    ...header.tools !== void 0 && header.tools.length > 0 ? { tools: header.tools } : {}
+  };
+}
+function foldRequestHeader(events, from2) {
+  let state = from2;
+  for (const event of events) {
+    if (event.type === "request/header") state = canonicalHeader(event.data.header);
+  }
+  return state;
+}
+
+// ../deepseek-harness/packages/core/session/src/index.ts
+function validateSessionHeader(id, input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("session header is not a plain JSON record");
+  }
+  const record2 = input;
+  if (record2.version !== SESSION_FORMAT_VERSION) {
+    throw new Error(`session header version must be ${SESSION_FORMAT_VERSION}, got ${String(record2.version)}`);
+  }
+  if (record2.id !== id) {
+    throw new Error(`session header id "${String(record2.id)}" does not match session id "${id}"`);
+  }
+  if (typeof record2.createdAt !== "number" || !Number.isSafeInteger(record2.createdAt) || record2.createdAt < 0) {
+    throw new Error("session header createdAt must be a non-negative safe integer");
+  }
+  if (record2.cwd !== void 0) {
+    if (typeof record2.cwd !== "string") throw new Error("session header cwd must be a string");
+    if (!isAbsolute(record2.cwd)) {
+      throw new Error(`session header cwd must be an absolute path, got "${record2.cwd}"`);
+    }
+  }
+  if (record2.parentSession !== void 0 && typeof record2.parentSession !== "string") {
+    throw new Error("session header parentSession must be a string");
+  }
+  if (record2.seedLength !== void 0 && (typeof record2.seedLength !== "number" || !Number.isSafeInteger(record2.seedLength) || record2.seedLength < 0)) {
+    throw new Error("session header seedLength must be a non-negative safe integer");
+  }
+  if (record2.origin !== void 0 && record2.origin !== "subagent") {
+    throw new Error('session header origin must be "subagent"');
+  }
+  if (record2.delegationDepth !== void 0 && (typeof record2.delegationDepth !== "number" || !Number.isSafeInteger(record2.delegationDepth) || record2.delegationDepth < 0)) {
+    throw new Error("session header delegationDepth must be a non-negative safe integer");
+  }
+  if (record2.agentPreset !== void 0 && typeof record2.agentPreset !== "string") {
+    throw new Error("session header agentPreset must be a string");
+  }
+  return deepFreeze(record2);
+}
+function validateRestoredSessionHeader(id, input) {
+  if (input !== null && typeof input === "object" && !Array.isArray(input)) {
+    const prototype = Reflect.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new Error("session header is not a plain JSON record");
+    }
+  }
+  return validateSessionHeader(id, input);
+}
+function snapshotSessionHeader(id, source) {
+  const input = source === void 0 ? { version: SESSION_FORMAT_VERSION, id, createdAt: Date.now() } : source;
+  const snapshot = snapshotJsonValue(input);
+  if (snapshot === void 0) throw new Error("session header is not losslessly JSON-serializable");
+  return validateSessionHeader(id, snapshot);
+}
+function freezeRestoredObject(value) {
+  const pending = [value];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    Object.freeze(current);
+    for (const key in current) {
+      const child = current[key];
+      if (child !== null && typeof child === "object") pending.push(child);
+    }
+  }
+  return value;
+}
+function assertSessionEventEnvelope(value, index2) {
+  const event = value;
+  if (event["type"] === "request/header-delta") {
+    throw new Error(`seed event at index ${index2} uses unsupported legacy request/header-delta format`);
+  }
+  for (const key in event) {
+    switch (key) {
+      case "type":
+      case "seq":
+      case "time":
+      case "data":
+      case "surfaceOp":
+      case "sourceEventSeqs":
+      case "ignorable":
+        break;
+      default:
+        throw new Error(`seed event at index ${index2} has an invalid event envelope`);
+    }
+  }
+  const type = event["type"];
+  const seq = event["seq"];
+  const time3 = event["time"];
+  if (typeof type !== "string" || typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 0 || typeof time3 !== "number" || !Number.isSafeInteger(time3) || event["data"] === void 0 || event["ignorable"] !== void 0 && event["ignorable"] !== true) {
+    throw new Error(`seed event at index ${index2} has an invalid event envelope`);
+  }
+  switch (type) {
+    case "request/header":
+    case "user/message":
+    case "assistant/message":
+    case "tool/result":
+      assertCurrentLlmShape(event, index2);
+      break;
+  }
+}
+function assertCurrentLlmShape(event, index2) {
+  const data = event["data"];
+  const record2 = typeof data === "object" && data !== null ? data : void 0;
+  if (event["type"] === "request/header") {
+    const header = record2?.["header"];
+    const headerRecord = typeof header === "object" && header !== null && !Array.isArray(header) ? header : void 0;
+    const config2 = headerRecord?.["config"];
+    if (!hasProviderModel(config2)) throw new Error(`seed request/header at index ${index2} lacks provider/model`);
+    const configRecord = config2;
+    const reasoningEffort = configRecord["reasoningEffort"];
+    if (reasoningEffort !== void 0 && (typeof reasoningEffort !== "string" || reasoningEffort.length === 0)) {
+      throw new Error(`seed request/header at index ${index2} has an invalid reasoningEffort`);
+    }
+    assertAdapterDefaults(headerRecord?.["adapterDefaults"], configRecord, index2);
+  }
+  const type = event["type"];
+  if (type !== "user/message" && type !== "assistant/message" && type !== "tool/result") return;
+  assertMessageEventShape(event, `seed ${type} at index ${index2}`);
+}
+var allowedAdapterKeys = /* @__PURE__ */ new Set(["reasoningEffort", "maxTokens"]);
+function assertAdapterDefaults(value, config2, index2) {
+  if (value === void 0) return;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`seed request/header at index ${index2} has invalid adapterDefaults`);
+  }
+  const defaults = value;
+  if (Object.keys(defaults).some((key) => !allowedAdapterKeys.has(key)) || Object.values(defaults).some((marker) => marker !== true) || defaults["reasoningEffort"] === true && config2["reasoningEffort"] === void 0 || defaults["maxTokens"] === true && config2["maxTokens"] === void 0) {
+    throw new Error(`seed request/header at index ${index2} has invalid adapterDefaults`);
+  }
+}
+function assertMessageEventShape(event, subject) {
+  const type = event["type"];
+  if (type !== "user/message" && type !== "assistant/message" && type !== "tool/result") return;
+  const data = event["data"];
+  const record2 = typeof data === "object" && data !== null ? data : void 0;
+  const message = type === "user/message" ? record2 : record2?.["message"];
+  if (typeof message !== "object" || message === null || typeof message["id"] !== "string" || message["id"] === "") {
+    throw new Error(`${subject} lacks an identified message`);
+  }
+  const messageRecord = message;
+  const expectedRole = type === "assistant/message" ? "assistant" : "user";
+  if (messageRecord["role"] !== expectedRole) {
+    throw new Error(`${subject} message must have role "${expectedRole}"`);
+  }
+  const source = messageRecord["source"];
+  if (typeof source !== "object" || source === null || typeof source["kind"] !== "string" || source["kind"] === "") {
+    throw new Error(`${subject} message has invalid source`);
+  }
+  if (!Array.isArray(messageRecord["content"])) {
+    throw new Error(`${subject} message has invalid content`);
+  }
+  const sourceRecord = source;
+  if (type === "assistant/message") {
+    if (sourceRecord["kind"] !== "model" || !hasProviderModel(sourceRecord)) {
+      throw new Error(`${subject} message must have model source`);
+    }
+    return;
+  }
+  if (type !== "tool/result") return;
+  if (sourceRecord["kind"] !== "tool" || typeof sourceRecord["callId"] !== "string" || sourceRecord["callId"] === "") {
+    throw new Error(`${subject} message must have tool source`);
+  }
+  const content3 = messageRecord["content"];
+  const block = content3[0];
+  if (content3.length !== 1 || typeof block !== "object" || block === null || block["type"] !== "tool-result" || !Array.isArray(block["content"])) {
+    throw new Error(`${subject} message must contain one tool-result block`);
+  }
+  if (block["toolCallId"] !== sourceRecord["callId"]) {
+    throw new Error(`${subject} message has mismatched tool call ids`);
+  }
+}
+function hasProviderModel(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const pair = value;
+  return typeof pair["provider"] === "string" && pair["provider"].length > 0 && typeof pair["model"] === "string" && pair["model"].length > 0;
+}
+function assertSupportedRequestHeader(type, data, location) {
+  if (type === "request/header-delta") {
+    throw new Error(`${location} uses unsupported legacy request/header-delta format`);
+  }
+  if (type === "request/header" && data !== null && typeof data === "object" && !Array.isArray(data) && data["reason"] === "fallback") {
+    throw new Error(`${location} uses unsupported legacy request/header reason "fallback"`);
+  }
+}
+function collectSessionCallbacks(ctx, args) {
+  return [...ctx.events.dispatch("emit", args)];
+}
+function invokeContainedSessionObservers(ctx, name2, id, args, callbacks) {
+  for (const callback of callbacks) {
+    try {
+      const returned = callback(...args);
+      void Promise.resolve(returned).catch((error51) => {
+        ctx.logger.warn(`session "${id}": ${name2} listener rejected: ${String(error51)}`);
+      });
+    } catch (error51) {
+      ctx.logger.warn(`session "${id}": ${name2} listener threw: ${String(error51)}`);
+    }
+  }
+}
+var attachments = /* @__PURE__ */ new WeakMap();
+var Session = class _Session {
+  log = [];
+  /** Single incremental owner of surface acceptance and projection state. */
+  surfaceManager = new SurfaceManager(this.log);
+  /** The ordered surface over this session's event log. */
+  get surface() {
+    return this.surfaceManager;
+  }
+  /**
+   * Detached, deep-frozen creation metadata (format version, cwd, lineage,
+   * seed boundary). Supplied by the store via `ctx.sessions.create()`. When a
+   * `Session` is created without a store-owned header, a minimal header is
+   * synthesized (stamped with the current {@link SESSION_FORMAT_VERSION}) so
+   * `session.header` is always present. Kept out of the event log — it is a
+   * storage concern, not replayable conversation state.
+   */
+  header;
+  /** The session identity, derived from its durable header's single copy. */
+  get id() {
+    return this.header.id;
+  }
+  /**
+   * The first seq appended IN THIS PROCESS: the length of the constructor
+   * seed (0 without one). Events with smaller seq values entered through
+   * construction — replay, fork, or resume — and were never published on the
+   * `session/event` firehose (constructor seeds do not emit), so consumers
+   * that replay the log as a publication substitute (telemetry adoption)
+   * start here. Distinct from `header.seedLength`, the DURABLE fork-lineage
+   * boundary: a resumed session's constructor seed is its full stored log,
+   * while its header keeps the original fork value — this field is the
+   * in-process construction fact.
+   *
+   * Not persisted itself: a seeded session projects it into the log as the
+   * `session/end-seed` event, which is what a consumer reading STORED history
+   * reads. Locate the LAST such event, not necessarily one at this seq — a
+   * seed already ending in one is not re-marked, so reopening an untouched
+   * session leaves that event at a smaller seq than `firstLiveSeq`. Prefer
+   * this field in-process: it is exact before the marker reaches storage.
+   *
+   * When this lifecycle appends the marker, it occupies this seq before the
+   * store attaches and therefore does not publish either. Otherwise this seq
+   * holds an ordinary published write.
+   */
+  firstLiveSeq;
+  /**
+   * Create a detached session by validating and snapshotting borrowed seed
+   * events and storage metadata.
+   * @param id - session identity.
+   * @param seed - optional borrowed replay or fork events.
+   * @param header - optional borrowed storage metadata.
+   * @returns a detached session.
+   */
+  static create(id, seed, header) {
+    return new _Session(id, seed, header);
+  }
+  /**
+   * Restore a detached session by taking ownership of fresh persistence values.
+   * The storage format, event envelopes, sequence continuity, surface transitions,
+   * and header fields are validated before the restored objects are frozen.
+   * @param id - restored session identity.
+   * @param seed - fresh detached events whose ownership is transferred.
+   * @param header - fresh detached metadata whose ownership is transferred.
+   * @returns a restored detached session.
+   */
+  static fromRestore(id, seed, header) {
+    return new _Session(id, seed, header, "restore");
+  }
+  constructor(id, seed, header, mode = "snapshot") {
+    const restoredHeader = mode === "restore" ? validateRestoredSessionHeader(id, header) : void 0;
+    if (seed !== void 0) {
+      for (const [index2, source] of seed.entries()) {
+        const snapshot = mode === "restore" ? source : snapshotJsonValue(source);
+        if (snapshot === void 0) {
+          throw new Error(`seed event at index ${index2} is not losslessly JSON-serializable`);
+        }
+        assertSessionEventEnvelope(snapshot, index2);
+        assertSupportedRequestHeader(snapshot.type, snapshot.data, `seed event at index ${index2}`);
+        if (snapshot.seq !== index2) {
+          throw new Error(`seed event at index ${index2} has seq ${snapshot.seq} (expected ${index2}); seed must be contiguous from 0`);
+        }
+        try {
+          this.surfaceManager.validateNext(snapshot);
+        } catch (error51) {
+          throw new Error(`invalid seed event at index ${index2}: ${error51 instanceof Error ? error51.message : "invalid surface metadata"}`);
+        }
+        this.log.push(mode === "restore" ? freezeRestoredObject(snapshot) : deepFreeze(snapshot));
+      }
+    }
+    this.firstLiveSeq = this.log.length;
+    this.header = restoredHeader ?? snapshotSessionHeader(id, header);
+    if (seed !== void 0 && this.log.at(-1)?.type !== "session/end-seed") {
+      this.append("session/end-seed", {});
+    }
+  }
+  /** Cached immutable public snapshot of the private append-only log. */
+  eventsSnapshot;
+  /**
+   * An immutable snapshot of the append-only event log. The snapshot is reused
+   * until the next append; a previously returned array does not grow later.
+   * Events and their nested data are deep-frozen at acceptance, so neither a
+   * cast nor ordinary JavaScript can rewrite durable history.
+   */
+  get events() {
+    this.eventsSnapshot ??= Object.freeze([...this.log]);
+    return this.eventsSnapshot;
+  }
+  /** The next event's sequence number — always the log length (the `seq = log.length` contiguity contract). */
+  get seq() {
+    return this.log.length;
+  }
+  /**
+   * Append one typed event to the log and synchronously notify observers via
+   * the store-owned, module-private publication hooks. The hot path never blocks
+   * on I/O — persistence plugins buffer asynchronously. Once the event enters
+   * the log, the append is committed: observer failures are logged and
+   * contained per listener, so they do not change the return value or prevent
+   * later listeners from observing the same accepted event.
+   *
+   * @param type - The event type (key of {@link SessionEventMap}).
+   * @param data - The event payload; must be JSON-serializable.
+   * @param opts - Surface metadata: `surfaceOp` controls how the event enters
+   *   the ordered surface; `sourceEventSeqs` lists the seq numbers of earlier
+   *   events this one derives from. REQUIRED for
+   *   {@link SurfaceEventType} events (every message-producing event must
+   *   declare how it joins the surface, the sole source of derived model
+   *   history) and
+   *   rejected by the compiler for non-surface types like `turn/start` or
+   *   `assistant/chunk`.
+   * @returns the logged event — its assigned `seq`/`time` plus the SNAPSHOT of
+   *   `data` that entered the log, so reading `event.data` back sees the logged
+   *   value, never the caller's still-mutable input.
+   * @throws if `data` or surface metadata is not losslessly JSON-serializable
+   *   (BigInt, function, symbol, undefined, negative zero, non-finite number,
+   *   circular reference, sparse array, or an exotic object such as
+   *   Map/Set/Date/class instance), or when the candidate violates the
+   *   canonical surface contract (marker shape and eligibility, unique
+   *   earlier source-event references, positional replacement validity, and complete
+   *   shadowed-node coverage). One iterative pass reads, validates, and
+   *   copies each nested value once, so a stateful getter cannot supply one value
+   *   to validation and another to storage. The event log is the durable source
+   *   of truth, so a bad event fails at the append site rather than later during
+   *   a backend flush. A synchronous internal dispatch validation failure or an
+   *   append reentered while this acceptance/publication boundary is open also
+   *   rejects before the log changes.
+   */
+  append(type, data, ...opts) {
+    const surfaceOpts = opts[0];
+    const surfaceMetadata = {
+      ...surfaceOpts?.sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: surfaceOpts.sourceEventSeqs },
+      ...surfaceOpts?.surfaceOp === void 0 ? {} : { surfaceOp: surfaceOpts.surfaceOp }
+    };
+    const dataSnapshot = snapshotJsonValue(data);
+    if (dataSnapshot === void 0) {
+      throw new Error(`session event "${type}" carries non-JSON-serializable data`);
+    }
+    assertSupportedRequestHeader(type, dataSnapshot, `session event "${type}"`);
+    const surfaceMetadataSnapshot = snapshotJsonValue(surfaceMetadata);
+    if (surfaceMetadataSnapshot === void 0) {
+      throw new Error(`session event "${type}" carries non-JSON-serializable surface metadata`);
+    }
+    const entry = attachments.get(this);
+    if (entry?.appending) {
+      throw new Error("session append cannot reenter while another append is being published");
+    }
+    const event = deepFreeze({
+      type,
+      seq: this.log.length,
+      time: Date.now(),
+      data: dataSnapshot,
+      ...surfaceMetadataSnapshot
+    });
+    this.surfaceManager.validateNext(event);
+    if (entry !== void 0) entry.appending = true;
+    try {
+      let callbacks;
+      const callbackArgs = [this, event];
+      if (entry !== void 0) {
+        callbacks = collectSessionCallbacks(entry.emitCtx, [entry.carrier, "session/event", ...callbackArgs]);
+      }
+      this.log.push(event);
+      this.eventsSnapshot = void 0;
+      if (callbacks !== void 0 && entry !== void 0) {
+        invokeContainedSessionObservers(entry.emitCtx, "session/event", entry.id, callbackArgs, callbacks);
+      }
+      return event;
+    } finally {
+      if (entry !== void 0) {
+        entry.appending = false;
+        if (entry.detachRequested && !entry.announcing) entry.detach();
+      }
+    }
+  }
+  /** Cached fold of the request-header events — see {@link requestHeader}. */
+  headerFold;
+  /** Log position (events consumed) the header fold has reached. */
+  headerFoldSeq = 0;
+  /**
+   * The {@link EpochHeader} in force after the log's last header event — the
+   * header the NEXT request will be compared against — or undefined before
+   * the first `request/header` snapshot. The live, incrementally-maintained
+   * form of `foldRequestHeader(session.events)`: each header event is folded
+   * once, when first seen, so a per-step read costs O(new events).
+   * @returns the folded header, or undefined when no header event exists yet.
+   */
+  requestHeader() {
+    if (this.headerFoldSeq < this.log.length) {
+      this.headerFold = deepFreeze(foldRequestHeader(this.log.slice(this.headerFoldSeq), this.headerFold));
+      this.headerFoldSeq = this.log.length;
+    }
+    return this.headerFold;
+  }
+  /** Cached fold of `request/context` events. */
+  contextFold;
+  contextFoldSeq = 0;
+  /**
+   * Return the latest resolved route metadata, or `undefined` before the first
+   * `request/context` event. Each event is folded once.
+   * @returns the latest immutable route metadata.
+   */
+  requestContext() {
+    if (this.contextFoldSeq < this.log.length) {
+      for (const event of this.log.slice(this.contextFoldSeq)) {
+        if (event.type === "request/context") this.contextFold = deepFreeze({ ...event.data });
+      }
+      this.contextFoldSeq = this.log.length;
+    }
+    return this.contextFold;
+  }
+  /** The derived-message cache: frozen projections, extended per unseen node. */
+  derived = [];
+  /** Surface position (nodes projected) the cache has reached. */
+  derivedNodes = 0;
+  /** {@link SurfaceManager.replaceGeneration} the cache was built under. */
+  derivedGeneration = 0;
+  /**
+   * Derive the LLM message history by walking the ordered sequences of
+   * message-producing events maintained by `surfaceOp` markers. The
+   * surface is the single source of derived history: every message-producing
+   * append records its `surfaceOp`, so a raw event with no marker (a chunk, a
+   * turn boundary) is correctly absent, and a compaction `replace` deletes the
+   * shadowed nodes from the derivation. The projection rules are
+   * {@link deriveEventMessage}, folded per node.
+   *
+   * CACHED: each surface node is projected exactly once, when first seen — a
+   * call costs O(new nodes), and a surface rewrite (a `replace`;
+   * {@link SessionSurface.replaceGeneration}) rebuilds. The returned array is
+   * a fresh snapshot per call (later appends never grow an array a caller
+   * already holds); the `Message` objects in it are SHARED and **deep-frozen**.
+   * Their content reuses the already frozen durable event data, so the cache
+   * needs no second deep clone and consumers still cannot mutate the log.
+   * @returns a fresh array of the shared, frozen derived history.
+   */
+  deriveMessages() {
+    const surface = this.surface;
+    const nodes = surface.nodes;
+    const generation = surface.replaceGeneration;
+    if (generation !== this.derivedGeneration) {
+      this.derived = [];
+      this.derivedNodes = 0;
+      this.derivedGeneration = generation;
+    }
+    for (const seq of nodes.slice(this.derivedNodes)) {
+      const msg = this.deriveEventMessage(this.log[seq]);
+      if (msg) this.derived.push(msg);
+    }
+    this.derivedNodes = nodes.length;
+    return [...this.derived];
+  }
+  /**
+   * Instance face of the pure per-node `deriveEventMessage` export from
+   * `surface.ts`.
+   * @param event - the event to project.
+   * @returns the derived message, or null when the event produces none.
+   */
+  deriveEventMessage(event) {
+    return deriveEventMessage(event);
+  }
+};
 
 // ../deepseek-harness/node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -58245,7 +59117,7 @@ function producedPathsForTurn(cards) {
 
 // ../deepseek-harness/packages/tui/tui-render/src/stream-view.tsx
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { isAbsolute as isAbsolute2 } from "node:path";
+import { isAbsolute as isAbsolute3 } from "node:path";
 
 // ../deepseek-harness/packages/tui/tui-render/src/markdown.tsx
 var import_react34 = __toESM(require_react(), 1);
@@ -69430,7 +70302,7 @@ function toolCardOriginalText(card, options) {
 }
 
 // ../deepseek-harness/packages/tui/tui-render/src/tool-cards.ts
-import { isAbsolute } from "node:path";
+import { isAbsolute as isAbsolute2 } from "node:path";
 import { pathToFileURL } from "node:url";
 function toolCardDisplayStatus(card) {
   const terminal = card.resultView?.card === "terminal" ? card.resultView : void 0;
@@ -69593,7 +70465,7 @@ function fileUrlFromToolArguments(argumentsJson) {
     const record2 = parsed;
     for (const key of FILE_PATH_KEYS) {
       const value = record2[key];
-      if (typeof value !== "string" || !isAbsolute(value)) continue;
+      if (typeof value !== "string" || !isAbsolute2(value)) continue;
       if (/[\u0000-\u001f\u007f]/.test(value)) continue;
       return pathToFileURL(value).href;
     }
@@ -74614,7 +75486,7 @@ function StreamView({
         prefix = "  \xB7 ";
       }
       const segment2 = styled(escapeContent(`${prefix}${path2}`), "fgDim");
-      const href = isAbsolute2(path2) ? pathToFileURL2(path2).href : void 0;
+      const href = isAbsolute3(path2) ? pathToFileURL2(path2).href : void 0;
       const run2 = hyperlinksEnabled() && href !== void 0 && isOsc8Href(href) ? wrapOsc8(segment2, href) : segment2;
       rowRuns.push(run2);
       rowWidth += displayWidth(`${prefix}${path2}`);
@@ -78877,6 +79749,7 @@ function createProjector() {
   return {
     push: push3,
     seed(events) {
+      if (!events || typeof events[Symbol.iterator] !== "function") return;
       for (const event of events) push3(event);
     },
     snapshot() {
@@ -79141,7 +80014,9 @@ async function exportSessionMarkdown(session, dir) {
     throw new Error("session export target must be a direct child of the export directory");
   }
   await mkdir(resolvedDir, { recursive: true });
-  await writeFile(target, renderSessionMarkdown(session.events), "utf8");
+  const legacy = session;
+  const events = typeof legacy.snapshotEvents === "function" ? legacy.snapshotEvents() : session.events;
+  await writeFile(target, renderSessionMarkdown(events), "utf8");
   return target;
 }
 
@@ -79245,6 +80120,51 @@ function settingsRowsFromDescribe(descriptors, read) {
 }
 
 // ../deepseek-harness/packages/tui/tui/src/index.ts
+try {
+  if (typeof Session === "function" && !("events" in Session.prototype)) {
+    Object.defineProperty(Session.prototype, "events", {
+      get() {
+        return typeof this.snapshotEvents === "function" ? this.snapshotEvents() : [];
+      },
+      configurable: true,
+      enumerable: false
+    });
+  }
+} catch {
+}
+function ensureSessionEventsCompat(session) {
+  if (!session || typeof session !== "object") return;
+  try {
+    const proto2 = Object.getPrototypeOf(session);
+    if (proto2 && typeof proto2 === "object" && !("events" in proto2)) {
+      Object.defineProperty(proto2, "events", {
+        get() {
+          return typeof this.snapshotEvents === "function" ? this.snapshotEvents() : [];
+        },
+        configurable: true,
+        enumerable: false
+      });
+    } else if (!("events" in session)) {
+      Object.defineProperty(session, "events", {
+        get() {
+          return typeof this.snapshotEvents === "function" ? this.snapshotEvents() : [];
+        },
+        configurable: true,
+        enumerable: false
+      });
+    }
+  } catch {
+  }
+}
+function getSessionEvents(session) {
+  if (!session || typeof session !== "object") return [];
+  const s = session;
+  if (s.events !== void 0) return s.events;
+  if (typeof s.snapshotEvents === "function") {
+    return s.snapshotEvents();
+  }
+  return [];
+}
 var FEEDBACK_MS = 2e3;
 var FEEDBACK_COPY = {
   // Safe copy: tells the user the action failed and they can retry. The
@@ -79992,7 +80912,7 @@ var RuntimeController = class _RuntimeController {
    */
   getTitle() {
     if (this.session === void 0) return "";
-    return topBarTitle(this.session.events);
+    return topBarTitle(getSessionEvents(this.session));
   }
   /**
    * Return the current session-directory state.
@@ -81754,7 +82674,7 @@ var RuntimeController = class _RuntimeController {
    * in those cases and is not appropriate here.
    */
   notifySessionTitle() {
-    return this.session === void 0 ? void 0 : notifySessionTitle(this.session.events);
+    return this.session === void 0 ? void 0 : notifySessionTitle(getSessionEvents(this.session));
   }
   /** Record local user input for the notification quiet window. */
   noteUserActivity() {
@@ -82180,8 +83100,9 @@ var RuntimeController = class _RuntimeController {
         });
         const allocated = await this.allocateCandidate(request);
         candidate = allocated.handle;
+        ensureSessionEventsCompat(candidate.agent.session);
         const projector = createProjector();
-        projector.seed(candidate.agent.session.events);
+        projector.seed(getSessionEvents(candidate.agent.session));
         this.setTransition({ phase: "binding", intent: request.intent });
         this.commitCandidate({ ...allocated, projector });
       } catch (primaryError) {
@@ -83159,10 +84080,11 @@ var RuntimeController = class _RuntimeController {
   }
   /** Fold the bound live session into a directory row without waiting for persistence. */
   rowForLiveSession(session) {
+    const events = getSessionEvents(session);
     return {
       id: session.id,
-      title: listTitleOf(session.events),
-      updatedAt: session.events.at(-1)?.time ?? session.header.createdAt
+      title: listTitleOf(events),
+      updatedAt: events.at(-1)?.time ?? session.header.createdAt
     };
   }
   /** Fold one listed session into a directory row; corrupt logs degrade to the id. */
@@ -83646,6 +84568,7 @@ var RuntimeController = class _RuntimeController {
   }
 };
 function topBarTitle(events) {
+  if (!Array.isArray(events)) return "";
   const folded = foldSessionTitle(events);
   if (folded === void 0) return "";
   if (folded.source.kind === "fallback" && events.some(isHumanUserMessage)) {
@@ -83654,9 +84577,11 @@ function topBarTitle(events) {
   return folded.title;
 }
 function notifySessionTitle(events) {
+  if (!Array.isArray(events)) return void 0;
   return foldTitle(events);
 }
 function foldTitle(events) {
+  if (!Array.isArray(events)) return void 0;
   const folded = foldSessionTitle(events);
   if (folded !== void 0) return folded.title;
   const firstUser = events.find(isHumanUserMessage);
@@ -83672,6 +84597,7 @@ function foldTitle(events) {
   return void 0;
 }
 function listTitleOf(events) {
+  if (!Array.isArray(events)) return "\u672A\u547D\u540D\u4F1A\u8BDD";
   return foldTitle(events) ?? "\u672A\u547D\u540D\u4F1A\u8BDD";
 }
 function firstLine2(text4) {
@@ -83977,6 +84903,18 @@ async function run(ctx, config2, io) {
   }
 }
 function apply(ctx, config2) {
+  try {
+    if (typeof Session === "function" && !("events" in Session.prototype)) {
+      Object.defineProperty(Session.prototype, "events", {
+        get() {
+          return typeof this.snapshotEvents === "function" ? this.snapshotEvents() : [];
+        },
+        configurable: true,
+        enumerable: false
+      });
+    }
+  } catch {
+  }
   const exit3 = ctx.get("appExit");
   if (exit3 === void 0) {
     throw new Error(
@@ -84023,6 +84961,8 @@ export {
   RuntimeController,
   SEARCH_DEBOUNCE_MS,
   apply,
+  ensureSessionEventsCompat,
+  getSessionEvents,
   inject,
   internals,
   name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crazyhappyone/dsh-tui",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.7",
   "description": "Source-runtime launcher for the DeepSeek Harness terminal interface",
   "type": "module",
   "license": "MIT",

package/tui/cordis.patch.yml

@@ -35,12 +35,40 @@
     openAt: first-search
 
 - insert:
+    # Code Mode is a core execution capability, not a Web component.
+    - id: code-runtime
+      name: "@deepseek-ai/dsh-code-runtime-worker-thread"
+
+    # Per-round token/duration stats for the terminal status line.
+    - id: session-stats
+      name: "@deepseek-ai/dsh-session-stats"
+
+    # Base owns the shared storage/domain/projection-cache stack. This layer
+    # contributes only the TUI-facing feedback consumer over that stack.
+    - id: message-feedback
+      name: "@deepseek-ai/dsh-message-feedback"
+      config:
+        maxNoteBytes: 8192
+
+    - id: tool-ask-user
+      name: "@deepseek-ai/dsh-tool-ask-user"
+
     - id: tui-startup
-      name: "./dist/startup.js"
+      name: "@deepseek-ai/dsh-tui/startup"
+
+    # Zero-config official OpenAI/Anthropic routes. They register
+    # openai-official / anthropic-official so they do not collide with the
+    # dormant llm-pi-ai catalog keys openai / anthropic that the Web Models
+    # page already owns.
+    - id: llm-openai
+      name: "@deepseek-ai/dsh-llm-openai"
+
+    - id: llm-anthropic
+      name: "@deepseek-ai/dsh-llm-anthropic"
 
     # Reads its task from the ordinary tuiStartup provider.
     - id: tui-runtime
-      name: "./dist/index.js"
+      name: "@deepseek-ai/dsh-tui"
       inject: [tuiStartup]
       config:
         task: !!js ctx.tuiStartup.task