negotium 0.1.7 → 0.1.8

package/dist/runtime/src/agents/model-catalog.ts

@@ -0,0 +1,151 @@
+import { resolveDefaultModel } from "#platform/config";
+import type { AgentKind } from "#types";
+
+/**
+ * Models/prefixes that belong exclusively to one agent backend. When the
+ * resolved agent differs from a model's owner, the model is cross-agent stale
+ * and must be dropped in favor of the new agent's default — otherwise the value
+ * is passed straight into a provider that can't run it and crashes the turn
+ * (bug B: `/codex` leaves the topic's "sonnet" behind → Codex 400
+ * "The 'sonnet' model is not supported when using Codex").
+ *
+ * Codex's own `validateModel` accepts ANY non-empty string (OpenAI ships new
+ * IDs frequently), so it can't reject "sonnet" on its own — this ownership
+ * owner check is the cross-agent guard the per-registry validator can't provide.
+ * Unknown/new model IDs are intentionally absent here so they still pass
+ * through to whichever agent is active.
+ */
+export const MODEL_OWNER: Record<string, AgentKind> = {
+  // Current aliases plus retired aliases retained only for stale-model detection.
+  sonnet: "claude",
+  opus: "claude",
+  haiku: "claude",
+  fable: "claude",
+  "gpt-5.6-luna": "codex",
+  "gpt-5.6-terra": "codex",
+  "gpt-5.6-sol": "codex",
+  "gpt-5.5": "codex",
+  deepseek: "maestro",
+  "deepseek-pro": "maestro",
+  "deepseek-flash": "maestro",
+};
+
+export interface SelectableModel {
+  /** Canonical token accepted by user-facing `/model` commands. */
+  model: string;
+  /** Runtime owner kept internal so channel UIs only need to show `model`. */
+  agent: AgentKind;
+  /** Short comparison copy shown alongside the model in picker UIs. */
+  description: string;
+}
+
+/**
+ * Canonical model picker shared by every channel. Keep this deliberately
+ * finite even though the Codex backend accepts arbitrary future model ids:
+ * user-facing completion should only promise models we intentionally support.
+ */
+export const SELECTABLE_MODELS: readonly SelectableModel[] = [
+  {
+    model: "gpt-5.6-sol",
+    agent: "codex",
+    description: "Latest frontier agentic coding model.",
+  },
+  {
+    model: "gpt-5.6-terra",
+    agent: "codex",
+    description: "Balanced agentic coding model for everyday work.",
+  },
+  {
+    model: "gpt-5.6-luna",
+    agent: "codex",
+    description: "Fast and affordable agentic coding model.",
+  },
+  {
+    model: "gpt-5.5",
+    agent: "codex",
+    description: "Frontier model for complex coding, research, and real-world work.",
+  },
+  {
+    model: "fable",
+    agent: "claude",
+    description:
+      "Fable 5 · Most capable for your hardest and longest-running tasks · $10/$50 per Mtok",
+  },
+  {
+    model: "opus",
+    agent: "claude",
+    description: "Opus 4.8 with 1M context · Best for everyday, complex tasks · $5/$25 per Mtok",
+  },
+  {
+    model: "sonnet",
+    agent: "claude",
+    description: "Sonnet 5 · Efficient for routine tasks · $2/$10 per Mtok · promo through Aug 31",
+  },
+  {
+    model: "deepseek-pro",
+    agent: "maestro",
+    description: "Sonnet-level performance at lower cost · Best for everyday tasks over coding",
+  },
+  {
+    model: "deepseek-flash",
+    agent: "maestro",
+    description: "DeepSeek V4 Flash · Fast and low-cost for lightweight everyday tasks",
+  },
+];
+
+export function selectableModel(value: string): SelectableModel | undefined {
+  const normalized = value.trim().toLowerCase();
+  return SELECTABLE_MODELS.find((candidate) => candidate.model === normalized);
+}
+
+export function modelOwner(model: string): AgentKind | undefined {
+  if (model.startsWith("claude-")) return "claude";
+  if (model.startsWith("deepseek-")) return "maestro";
+  if (model.startsWith("gpt-")) return "codex";
+  return MODEL_OWNER[model];
+}
+
+/**
+ * Resolve the model to run for `agent`, given the requested value from the
+ * priority chain (per-message slash > topic-config override > topic default).
+ * Drops a model owned by a different agent, then falls back to the agent's
+ * registry default if the value is empty/invalid for this agent.
+ */
+export function resolveModelForAgent(
+  agent: AgentKind,
+  requested: string | undefined,
+  registry: { validateModel(s: string): boolean; defaultModel: string },
+): string {
+  const defaultModel = resolveDefaultModel(agent, registry.defaultModel);
+  if (!requested) return defaultModel;
+  const owner = modelOwner(requested);
+  if (owner && owner !== agent) return defaultModel; // cross-agent stale
+  return registry.validateModel(requested) ? requested : defaultModel;
+}
+
+/**
+ * Circular fallback order per agent. Each entry lists candidates to try in
+ * priority order when the current agent errors out. The actual switch is
+ * guarded by `checkAgentAuth` — only candidates whose backend is reachable
+ * (API key present / auth file exists) will be selected.
+ */
+export const FALLBACK_ORDER: Record<AgentKind, { agent: AgentKind; model: string }[]> = {
+  claude: [
+    { agent: "maestro", model: "deepseek-pro" },
+    { agent: "codex", model: "gpt-5.6-luna" },
+  ],
+  codex: [
+    { agent: "maestro", model: "deepseek-pro" },
+    { agent: "claude", model: "sonnet" },
+  ],
+  maestro: [
+    { agent: "codex", model: "gpt-5.6-luna" },
+    { agent: "claude", model: "sonnet" },
+  ],
+};
+
+export const AGENT_DISPLAY_NAME: Record<AgentKind, string> = {
+  claude: "Claude",
+  codex: "Codex",
+  maestro: "Maestro",
+};

package/dist/runtime/src/agents/registry.ts

@@ -0,0 +1,24 @@
+import { claudeRegistry } from "#agents/claude-registry";
+import { codexRegistry } from "#agents/codex-registry";
+import type { AgentRegistry } from "#agents/contracts";
+import { maestroRegistry } from "#agents/maestro-registry";
+import type { AgentKind } from "#types";
+
+export type {
+  AgentRegistry,
+  CleanupRolloutsOptions,
+  ForkRegistryOptions,
+  ForkRegistryResult,
+  WriteRolloutOptions,
+  WriteRolloutResult,
+} from "#agents/contracts";
+
+const REGISTRIES: Record<AgentKind, AgentRegistry> = {
+  claude: claudeRegistry,
+  codex: codexRegistry,
+  maestro: maestroRegistry,
+};
+
+export function getRegistry(agent: AgentKind): AgentRegistry {
+  return REGISTRIES[agent];
+}

package/dist/runtime/src/agents/rollout/claude.ts

@@ -0,0 +1,331 @@
+/**
+ * Claude rollout encoder.
+ *
+ * Materializes a synthetic JSONL at `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`
+ * so a subsequent `claude.query({ resume: sessionId })` continues the
+ * cross-agent conversation as if it had always been native. Verified by
+ * sandbox PoCs (test-7c/test-7d): the SDK accepts these without checksum
+ * gating, requiring only `user`/`assistant` messages and a small per-turn
+ * attachment chain captured into `agents/fixtures/claude-attachments.jsonl`.
+ *
+ * Tool history is folded into assistant text as `[Tool: ...]` annotations
+ * (see shared.ts:extractChatPairs) — synthetic tool_use IDs across SDKs are
+ * too fragile to reconstruct structurally.
+ */
+
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  assertUuidLike,
+  type ChatPair,
+  clone,
+  ensureCwdExists,
+  extractChatPairs,
+  FIXTURES_DIR,
+} from "#agents/rollout/shared";
+import { parseJsonlText, writeJsonlFile } from "#platform/jsonl";
+import { logger } from "#platform/logger";
+import type { ConversationEntry } from "#storage/conversations";
+
+interface ClaudeAttachments {
+  deferredToolsDelta: Record<string, unknown>;
+  skillListing: Record<string, unknown>;
+}
+
+let _attachmentsCache: ClaudeAttachments | null = null;
+function loadClaudeAttachments(): ClaudeAttachments {
+  if (_attachmentsCache) return _attachmentsCache;
+  const raw = readFileSync(join(FIXTURES_DIR, "claude-attachments.jsonl"), "utf8");
+  const lines = parseJsonlText<Record<string, unknown>>(raw);
+  if (lines.length < 2) {
+    throw new Error(
+      `loadClaudeAttachments: expected >=2 entries in claude-attachments.jsonl, got ${lines.length}`,
+    );
+  }
+  _attachmentsCache = {
+    deferredToolsDelta: lines[0],
+    skillListing: lines[1],
+  };
+  return _attachmentsCache;
+}
+
+/**
+ * Version strings stamped onto synthetic rollouts so they look indistinguishable
+ * from a live SDK session. These do not affect resume behavior — the SDKs do
+ * not gate on them — but keeping them current avoids confusion in observability
+ * tooling that scans rollout files.
+ */
+const CLAUDE_SDK_VERSION = "2.1.126";
+const CLAUDE_DEFAULT_MODEL = "claude-sonnet-5";
+const CLAUDE_DEFAULT_GIT_BRANCH = "HEAD";
+
+/**
+ * Encode a directory path the way Claude SDK expects in
+ * `~/.claude/projects/<encoded-cwd>/`. macOS resolves `/tmp` to
+ * `/private/tmp`, mirroring what the SDK records.
+ *
+ * The SDK normalizes ANY non-alphanumeric character to `-` (verified
+ * empirically on disk: `/Users/maestrobot/.../user_6407801418` →
+ * `-Users-...-user-6407801418`, i.e. both `/` AND `_` collapse to `-`).
+ * A previous implementation only replaced `/` and left `_` intact, so
+ * synthetic rollouts landed at `…-user_6407801418/` while the SDK looked
+ * at `…-user-6407801418/` — every `set_agent` switch surfaced as "No
+ * conversation found with session ID" on the next message.
+ */
+export function encodeClaudeCwd(cwd: string): string {
+  const realCwd = cwd.startsWith("/tmp/") ? cwd.replace(/^\/tmp\//, "/private/tmp/") : cwd;
+  return `-${realCwd.replaceAll(/[^a-zA-Z0-9]/g, "-").replace(/^-/, "")}`;
+}
+
+export interface ClaudeRolloutOptions {
+  /** Working directory the resumed Claude session will report. */
+  cwd: string;
+  /** Optional override; default = freshly generated UUIDv4. */
+  sessionId?: string;
+  /**
+   * Pairs to encode. If omitted, derived from `entries` via extractChatPairs.
+   * Pass explicit pairs when the caller has already shaped the dialogue.
+   */
+  pairs?: ChatPair[];
+  /** When `pairs` is omitted, the source UnifiedEvent log to digest. */
+  entries?: ConversationEntry[];
+  /** Full provider model id stamped on synthesized assistant history. */
+  model?: string;
+}
+
+export interface ClaudeRolloutResult {
+  sessionId: string;
+  rolloutPath: string;
+}
+
+/**
+ * Materialize a Claude rollout JSONL with the provided dialogue and place it
+ * at `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl` so a subsequent
+ * `claude.query({ resume: sessionId })` will continue the conversation.
+ */
+export function writeClaudeRollout(opts: ClaudeRolloutOptions): ClaudeRolloutResult {
+  const sessionId = opts.sessionId ?? randomUUID();
+  assertUuidLike("sessionId", sessionId);
+  ensureCwdExists(opts.cwd);
+  const pairs = opts.pairs ?? extractChatPairs(opts.entries ?? []);
+  const cwdReal = opts.cwd.startsWith("/tmp/")
+    ? opts.cwd.replace(/^\/tmp\//, "/private/tmp/")
+    : opts.cwd;
+
+  const lines: unknown[] = [];
+  const ts = () => new Date().toISOString();
+  let lastUuid: string | null = null;
+
+  // Queue-operation noise that the live SDK records around each turn. Not
+  // strictly required for resume but mirrors what the SDK itself writes,
+  // keeping the synthetic file indistinguishable.
+  lines.push({ type: "queue-operation", operation: "enqueue", timestamp: ts(), sessionId });
+  lines.push({ type: "queue-operation", operation: "dequeue", timestamp: ts(), sessionId });
+
+  // Per-turn attachment chain captured from a real Claude rollout. claude SDK
+  // emits `deferred_tools_delta` followed by `skill_listing` immediately after
+  // every user message, building a parentUuid chain user → att1 → att2 →
+  // assistant. PoC-7d preserved this shape; replaying it keeps the resumed
+  // session indistinguishable from a native one.
+  const attachments = loadClaudeAttachments();
+
+  for (const pair of pairs) {
+    const userUuid = randomUUID();
+    lines.push({
+      parentUuid: lastUuid,
+      isSidechain: false,
+      promptId: randomUUID(),
+      type: "user",
+      message: { role: "user", content: [{ type: "text", text: pair.userText }] },
+      uuid: userUuid,
+      timestamp: ts(),
+      permissionMode: "bypassPermissions",
+      userType: "external",
+      entrypoint: "sdk-ts",
+      cwd: cwdReal,
+      sessionId,
+      version: CLAUDE_SDK_VERSION,
+      gitBranch: CLAUDE_DEFAULT_GIT_BRANCH,
+    });
+
+    // Attachment 1: deferred_tools_delta — chain from user.
+    const att1Uuid = randomUUID();
+    const att1 = clone(attachments.deferredToolsDelta);
+    (att1 as Record<string, unknown>).parentUuid = userUuid;
+    (att1 as Record<string, unknown>).uuid = att1Uuid;
+    (att1 as Record<string, unknown>).timestamp = ts();
+    (att1 as Record<string, unknown>).sessionId = sessionId;
+    (att1 as Record<string, unknown>).cwd = cwdReal;
+    lines.push(att1);
+
+    // Attachment 2: skill_listing — chain from att1.
+    const att2Uuid = randomUUID();
+    const att2 = clone(attachments.skillListing);
+    (att2 as Record<string, unknown>).parentUuid = att1Uuid;
+    (att2 as Record<string, unknown>).uuid = att2Uuid;
+    (att2 as Record<string, unknown>).timestamp = ts();
+    (att2 as Record<string, unknown>).sessionId = sessionId;
+    (att2 as Record<string, unknown>).cwd = cwdReal;
+    lines.push(att2);
+
+    const assistantUuid = randomUUID();
+    lines.push({
+      parentUuid: att2Uuid,
+      isSidechain: false,
+      message: {
+        model: opts.model ?? CLAUDE_DEFAULT_MODEL,
+        id: `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`,
+        type: "message",
+        role: "assistant",
+        content: [{ type: "text", text: pair.assistantText }],
+        stop_reason: "end_turn",
+        stop_sequence: null,
+        stop_details: null,
+        usage: {
+          input_tokens: 0,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+          output_tokens: 0,
+          server_tool_use: { web_search_requests: 0, web_fetch_requests: 0 },
+          service_tier: "standard",
+          cache_creation: { ephemeral_1h_input_tokens: 0, ephemeral_5m_input_tokens: 0 },
+          inference_geo: "",
+          iterations: [],
+          speed: "standard",
+        },
+        diagnostics: null,
+      },
+      requestId: `req_${randomUUID().replace(/-/g, "").slice(0, 22)}`,
+      type: "assistant",
+      uuid: assistantUuid,
+      timestamp: ts(),
+      userType: "external",
+      entrypoint: "sdk-ts",
+      cwd: cwdReal,
+      sessionId,
+      version: CLAUDE_SDK_VERSION,
+      gitBranch: CLAUDE_DEFAULT_GIT_BRANCH,
+    });
+    lastUuid = assistantUuid;
+  }
+
+  const projectsDir = join(homedir(), ".claude", "projects", encodeClaudeCwd(opts.cwd));
+  const path = join(projectsDir, `${sessionId}.jsonl`);
+  writeJsonlFile(path, lines);
+  logger.info(
+    { sessionId, path, pairs: pairs.length },
+    "writeClaudeRollout: synthetic rollout placed",
+  );
+  return { sessionId, rolloutPath: path };
+}
+
+/**
+ * Remove the latest poisoned thinking turn and everything after it from the
+ * session JSONL.
+ *
+ * When a turn ends with stop_reason="max_tokens" while extended thinking is
+ * active, the Claude CLI writes the truncated thinking block verbatim to the
+ * rollout file. The Anthropic API rejects any subsequent resume that replays
+ * this incomplete block with 400 "thinking/redacted_thinking blocks cannot be
+ * modified". Dropping the entire poisoned turn (user entry + attachments +
+ * truncated assistant) leaves the JSONL in a clean state so the next
+ * claude.query({ resume }) can proceed without a 400.
+ *
+ * Returns true when the JSONL was found and repaired, false otherwise
+ * (file missing, no poisoned assistant turn found, I/O error). Error-path
+ * callers fall back to clearing the session ID when false is returned.
+ */
+export function repairPoisonedRollout(sessionId: string, cwd: string): boolean {
+  try {
+    const path = join(homedir(), ".claude", "projects", encodeClaudeCwd(cwd), `${sessionId}.jsonl`);
+    if (!existsSync(path)) return false;
+
+    const lines = readFileSync(path, "utf8")
+      .split("\n")
+      .filter((l) => l.trim());
+
+    // Walk backwards to find the latest assistant turn that actually contains
+    // the poisoned shape: max_tokens plus a thinking/redacted_thinking block.
+    // A resume failure can append a fresh user entry after the poisoned turn;
+    // trimming the last user would remove only the retry and leave the bad
+    // assistant in place.
+    let poisonedAssistantIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const entry = parseClaudeRolloutLine(lines[i]);
+      if (entry && isPoisonedAssistantEntry(entry)) {
+        poisonedAssistantIdx = i;
+        break;
+      }
+    }
+
+    if (poisonedAssistantIdx < 0) {
+      logger.warn({ sessionId, path }, "repairPoisonedRollout: no poisoned assistant entry found");
+      return false;
+    }
+
+    let turnStartIdx = -1;
+    for (let i = poisonedAssistantIdx - 1; i >= 0; i--) {
+      const entry = parseClaudeRolloutLine(lines[i]);
+      if (entry?.type === "user") {
+        turnStartIdx = i;
+        break;
+      }
+    }
+
+    if (turnStartIdx < 0) {
+      logger.warn(
+        { sessionId, path, poisonedAssistantIdx },
+        "repairPoisonedRollout: poisoned assistant has no preceding user entry",
+      );
+      return false;
+    }
+
+    const kept = lines.slice(0, turnStartIdx);
+    writeFileSync(path, kept.length ? `${kept.join("\n")}\n` : "");
+    logger.warn(
+      {
+        sessionId,
+        path,
+        poisonedAssistantIdx,
+        turnStartIdx,
+        droppedEntries: lines.length - turnStartIdx,
+        keptEntries: kept.length,
+      },
+      "repairPoisonedRollout: truncated turn removed from rollout JSONL",
+    );
+    return true;
+  } catch (err) {
+    logger.warn({ err, sessionId, cwd }, "repairPoisonedRollout: I/O error");
+    return false;
+  }
+}
+
+type ClaudeRolloutEntry = {
+  type?: string;
+  message?: {
+    stop_reason?: string | null;
+    content?: unknown;
+  };
+};
+
+function parseClaudeRolloutLine(line: string): ClaudeRolloutEntry | null {
+  try {
+    return JSON.parse(line) as ClaudeRolloutEntry;
+  } catch {
+    return null;
+  }
+}
+
+function isPoisonedAssistantEntry(entry: ClaudeRolloutEntry): boolean {
+  if (entry.type !== "assistant") return false;
+  if (entry.message?.stop_reason !== "max_tokens") return false;
+  const content = entry.message.content;
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => {
+    if (!block || typeof block !== "object") return false;
+    const type = (block as { type?: unknown }).type;
+    return type === "thinking" || type === "redacted_thinking";
+  });
+}