orizu 0.5.30 → 0.5.32

package/src/help.ts

@@ -307,13 +307,13 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
     options: [
       { name: '--team <slug>', help: 'Choose an existing accessible team.' },
       { name: '--create-team <name>', help: 'Create and select a new team; mutually exclusive with --team.' },
-      { name: '--project <slug>', help: 'Choose the project to use as coding-agent handoff context. The workspace still materializes all team projects.' },
-      { name: '--create-project <name>', help: 'Create and select a project in the chosen team; mutually exclusive with --project.' },
+      { name: '--project <slug>', help: 'Choose the project to work in. Only that project is set up in the workspace, and the team-project checklist is skipped, interactive or not.' },
+      { name: '--create-project <name>', help: 'Create and select a project in the chosen team, and set up only that project (no checklist); mutually exclusive with --project.' },
       { name: '--workspace [path]', help: 'Initialize or validate a workspace path, or the current directory when no path is provided. If provided, the value must be a filesystem path.' },
       { name: '--service-origin <url>', help: 'Service origin written to setup metadata. Defaults to the active CLI server.' },
       { name: '--attach-workspace <id>', help: 'Record an existing Orizu workspace id for future attachment.' },
       { name: '--validate', help: 'Inspect the workspace contract without writing files.' },
-      { name: '--fix', help: 'Apply safe idempotent repairs only.' },
+      { name: '--fix', help: 'Apply safe idempotent repairs only, restoring every team project.' },
       { name: '--no-symlinks', help: 'Write CLAUDE.md as a pointer file instead of a symlink to AGENTS.md.' },
       { name: '--verbose', help: 'Show per-file setup actions. Default setup output is summary-oriented.' },
       { name: '--agent <agent>', help: 'Non-interactive opt-in to install the shared global Orizu skill plus any applicable native target. Repeat for multiple agents.', repeatable: true, choices: ['claude', 'codex', 'pi', 'devin', 'droid', 'grok', 'windsurf', 'opencode'] },
@@ -682,8 +682,8 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
   },
   {
     path: ['optimizations', 'run-gepa'],
-    usage: 'orizu optimizations run-gepa [--hosted [--launch-intent-id <uuid>]] --project <team/project> --optimizer-version-id <id> (--candidate-version-id <id> | --instruction-set <name> --model-config <identity> [--component-selector round-robin|all]) --runner-version-id <id> [--candidate-runner-dir <dir>] --scorer-version-id <id> --scorer-runner-version-id <id> [--scorer-runner-dir <dir>] [--engine official|legacy] [--candidate-proposer skilled-proposer [--candidate-proposer-config <@file|path>] [--proposal-max-calls <n>] [--proposal-max-tokens <n>]] [--scorer-input-contract gepa|flat_row] [--scorer-candidate-field <row-field>] [--allow-degenerate-seed] [--seed <n>] --dataset-version-id <id> --split-set-id <id> [--train-split train] [--val-split validation] [--minibatch-size <n>] [--candidate-selection-strategy pareto|current_best|epsilon_greedy] [--epsilon <n>] [--objective <text>] [--budget auto|light|medium|heavy | --max-metric-calls <n> | --max-full-evals <n> | --max-iterations <n> | --max-candidate-proposals <n>] [--num-threads auto|N] [--reflection-model <provider/model>] [--reflection-temperature <n>] [--reflection-prompt-template <text|@file>] [--reflection-max-tokens N] [--reflection-provider-settings <json|@file>] [--reflection-retry-attempts N] [--reflection-http-timeout-seconds N] [--skip-perfect-parent-reflection|--no-skip-perfect-parent-reflection] [--disable-evaluation-cache] [--auto-promote] [--promotion-label <label>] [--log-row-snapshots] [--metadata <json>] [--python <command>] [--log-dir logs] [--no-local-log] [--json]',
-    summary: 'Run official GEPA locally and stream events, or use --hosted for a queued Orizu-managed sandbox launch. Hosted eligibility requires a staff-enabled team, capacity below its concurrent-run cap, a launch-project optimizer version whose validated manifest.optimizer_family is gepa, registered candidate/scorer runners, a reflection model from a registered provider, and a named --budget preset within the team ceiling. Hosted eligibility catalog refusals use stable code/remediation JSON with optional bounded detail, and capacity refusals include monitor URLs for running runs. A successful launch prints a durable monitor URL; queued means accepted, not completed. Hosted mode does not require --candidate-runner-dir or --scorer-runner-dir; when supplied, those directories must byte-match their registered versions. Retry response loss with the same --launch-intent-id. Local runner version ids materialize registered bytes, while optional runner dirs are additionally byte-verified before execution. Pass --engine legacy only for the frozen safety hatch. Skilled-proposer is official-only, its config requires that selection, and the selection cannot be combined with --reflection-prompt-template. --instruction-set requires --model-config and cannot be combined with --candidate-version-id; round-robin updates one component-map entry per round and all updates every component. --max-candidate-proposals is official-engine-only. Validates the scorer contract on the seed before iterating; judge runners built for flat-row score runs need --scorer-input-contract flat_row (ALI-1158).',
+    usage: 'orizu optimizations run-gepa [--hosted [--launch-intent-id <uuid>]] --project <team/project> --optimizer-version-id <id> (--candidate-version-id <id> | --instruction-set <set[/profile[@vN]]> [--model-config <identity>] [--profile-version <N>] [--component-selector round-robin|all]) --runner-version-id <id> [--candidate-runner-dir <dir>] --scorer-version-id <id> --scorer-runner-version-id <id> [--scorer-runner-dir <dir>] [--engine official|legacy] [--candidate-proposer skilled-proposer [--candidate-proposer-config <@file|path>] [--proposal-max-calls <n>] [--proposal-max-tokens <n>]] [--scorer-input-contract gepa|flat_row] [--scorer-candidate-field <row-field>] [--allow-degenerate-seed] [--seed <n>] --dataset-version-id <id> --split-set-id <id> [--train-split train] [--val-split validation] [--minibatch-size <n>] [--candidate-selection-strategy pareto|current_best|epsilon_greedy] [--epsilon <n>] [--objective <text>] [--budget auto|light|medium|heavy | --max-metric-calls <n> | --max-full-evals <n> | --max-iterations <n> | --max-candidate-proposals <n>] [--num-threads auto|N] [--reflection-model <provider/model>] [--reflection-temperature <n>] [--reflection-prompt-template <text|@file>] [--reflection-max-tokens N] [--reflection-provider-settings <json|@file>] [--reflection-retry-attempts N] [--reflection-http-timeout-seconds N] [--skip-perfect-parent-reflection|--no-skip-perfect-parent-reflection] [--disable-evaluation-cache] [--auto-promote] [--promotion-label <label>] [--log-row-snapshots] [--metadata <json>] [--python <command>] [--log-dir logs] [--no-local-log] [--json]',
+    summary: 'Run official GEPA locally and stream events, or use --hosted for a queued Orizu-managed sandbox launch. Hosted eligibility requires a staff-enabled team, capacity below its concurrent-run cap, a launch-project optimizer version whose validated manifest.optimizer_family is gepa, registered candidate/scorer runners, a reflection model from a registered provider, and a named --budget preset within the team ceiling. Hosted eligibility catalog refusals use stable code/remediation JSON with optional bounded detail, and capacity refusals include monitor URLs for running runs. A successful launch prints a durable monitor URL; queued means accepted, not completed. Hosted mode does not require --candidate-runner-dir or --scorer-runner-dir; when supplied, those directories must byte-match their registered versions. Retry response loss with the same --launch-intent-id. Local runner version ids materialize registered bytes, while optional runner dirs are additionally byte-verified before execution. Pass --engine legacy only for the frozen safety hatch. Skilled-proposer is official-only, its config requires that selection, and the selection cannot be combined with --reflection-prompt-template. --instruction-set needs a profile, named by --model-config or a set/profile specifier, and cannot be combined with --candidate-version-id. The run starts from the production version of that profile unless @vN or --profile-version <N> names another version (the seed, promoted or not); a specifier and flags that name different values are refused; round-robin updates one component-map entry per round and all updates every component. --max-candidate-proposals is official-engine-only. Validates the scorer contract on the seed before iterating; judge runners built for flat-row score runs need --scorer-input-contract flat_row (ALI-1158).',
     group: 'Optimizations',
   },
   {
@@ -775,8 +775,8 @@ export const COMMAND_DOCS: CliCommandDoc[] = [
   },
   {
     path: ['apps', 'export'],
-    usage: 'orizu apps export [--app <appId>] [--project <team/project>] [--version <n>] [--out <path>]',
-    summary: 'Export app source for the selected app version.',
+    usage: 'orizu apps export [--app <appId>] [--project <team/project>] [--version <n>] [--out <file-or-directory>]',
+    summary: 'Export app source for the selected app version. --out is a file path, or a directory (the file is named <app>.v<version>.tsx inside it).',
     group: 'Apps',
   },
   {

package/src/hosted-agent-prompt.ts

@@ -0,0 +1,18 @@
+/**
+ * The system prompt for the hosted agent (ORI-2207).
+ *
+ * OpenCode (the program that runs the agent in a hosted session) ships its own
+ * built-in prompt that starts "You are opencode, an interactive CLI tool…", so
+ * the agent used to introduce itself as OpenCode. We register our own "primary
+ * agent" in the OpenCode config with this text, and every prompt request picks
+ * it by name. That replaces OpenCode's built-in prompt entirely, so this text
+ * carries the working rules we still want: use the tools, keep answers short.
+ * AGENTS.md is still added after it, as before.
+ */
+export const HOSTED_AGENT_NAME = 'orizu'
+
+export const HOSTED_AGENT_PROMPT = `You are the Orizu agent. You work in the person's repository inside an Orizu workbench, helping them with software engineering tasks. If asked who or what you are, say you are the Orizu agent. Never call yourself OpenCode.
+
+- Do the work with your tools: read files, search, edit, and run commands. Do not guess at what a file contains when you can look.
+- Keep answers short and plain. Say what you did and what the person needs to know next.
+- Follow the repository's own conventions and any instructions in its AGENTS.md.`

package/src/hosted-gepa-cli.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto'
 
 import { dispatchGepaEngine } from './gepa-engine-dispatch.js'
+import { resolveGepaSeedFromEnvironment } from './instruction-set-gepa-launch.js'
 import { parseHostedGepaNumericValue } from './hosted-gepa-numeric-values.js'
 import { authedFetch } from './http.js'
 import { hostedProviderFromModel, hostedProviderSettingsError, unsupportedHostedProviderMessage } from './hosted-provider-settings.js'
@@ -216,11 +217,16 @@ export async function runHostedGepaOptimization(options: HostedGepaOptions): Pro
       : kind === 'json' ? JSON.parse(env[name]!) : kind === 'boolean' ? env[name] === '1' : env[name]
   }
   const launchIntentId = explicitLaunchIntent || randomUUID()
+  // ORI-2128: a named Seed version is resolved here exactly as a local run
+  // resolves it, and pinned in the body; without one the server keeps its
+  // one-call production lookup.
+  const seedProfileVersionId = await resolveGepaSeedFromEnvironment(env, options.project, 'server')
   const body = {
     hosted: true, launchIntentId, optimizerVersionId: env.ORIZU_OPTIMIZER_VERSION_ID,
     promptVersionIds: env.ORIZU_PROMPT_VERSION_ID ? [env.ORIZU_PROMPT_VERSION_ID] : [],
     ...(env.ORIZU_INSTRUCTION_SET_NAME ? { instructionSetName: env.ORIZU_INSTRUCTION_SET_NAME,
-      modelConfigIdentity: env.ORIZU_MODEL_CONFIG_IDENTITY, componentSelector: env.ORIZU_COMPONENT_SELECTOR } : {}),
+      modelConfigIdentity: env.ORIZU_MODEL_CONFIG_IDENTITY, componentSelector: env.ORIZU_COMPONENT_SELECTOR,
+      ...(seedProfileVersionId ? { instructionSetProfileVersionId: seedProfileVersionId } : {}) } : {}),
     runnerVersionId: env.ORIZU_RUNNER_VERSION_ID,
     scorers: [{ scorerVersionId: env.ORIZU_SCORER_VERSION_ID,
       scorerRunnerVersionId: env.ORIZU_SCORER_RUNNER_VERSION_ID, role: 'selection', scorerConfig: {} }],

package/src/hosted-harness-claude.ts

@@ -95,6 +95,7 @@
 
 import { parseModelIdentity } from './provider-registry.js'
 
+import { HARNESS_NAMES } from './hosted-harness.js'
 import type {
   AgentHarness,
   HarnessEvent,
@@ -323,7 +324,7 @@ export function createClaudeAgentHarness(
   }
 
   return {
-    name: 'claude-agent-sdk',
+    name: HARNESS_NAMES.claudeAgentSdk,
 
     async start(opts: HarnessStartOptions): Promise<{ agentSessionId: string }> {
       startModel = opts.model
@@ -471,6 +472,7 @@ export function createClaudeAgentHarness(
                   args: asRecord(block.input),
                   callId,
                   status: 'running',
+                  harness: HARNESS_NAMES.claudeAgentSdk,
                 },
               }
             }
@@ -495,6 +497,7 @@ export function createClaudeAgentHarness(
                   callId,
                   status: block.is_error === true ? 'error' : 'completed',
                   output: toolResultOutput(block.content),
+                  harness: HARNESS_NAMES.claudeAgentSdk,
                 },
               }
             }

package/src/hosted-harness-opencode.ts

@@ -51,13 +51,16 @@
 
 import { readFileSync } from 'fs'
 
+import { HOSTED_AGENT_NAME, HOSTED_AGENT_PROMPT } from './hosted-agent-prompt.js'
 import { findProvider, parseModelIdentity } from './provider-registry.js'
 
+import { HARNESS_NAMES } from './hosted-harness.js'
 import type {
   AgentHarness,
   HarnessEvent,
   HarnessPrompt,
   HarnessStartOptions,
+  HarnessToolPayload,
 } from './hosted-harness.js'
 
 // OpenCode is HARD-PINNED to this version everywhere it is installed/launched.
@@ -121,7 +124,9 @@ class PromptAbortedError extends Error {
 // -- OpenCode ascending id generator (port of OpenCode's id.ts) --------------
 // Monotonic so our user-message id always sorts AFTER any prior assistant
 // message id — this is what prevents OpenCode's prompt loop from early-exiting
-// on `lastUser.id < lastAssistant.id`.
+// on `lastUser.id < lastAssistant.id`. Shape (opencode-ai@1.14.41): prefix, `_`,
+// 12 hex digits holding the low 48 bits of `ms * 4096 + counter`, then 14
+// base62 characters. `nowMs` is a parameter only so tests can pin the clock.
 const BASE62 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
 let idLastTimestamp = 0
 let idCounter = 0
@@ -134,14 +139,15 @@ function randomBase62(length: number): string {
   return out
 }
 
-function ascendingId(prefix: 'ses' | 'msg' | 'prt'): string {
-  const nowMs = Date.now()
+export function ascendingId(prefix: 'ses' | 'msg' | 'prt', nowMs: number = Date.now()): string {
   if (nowMs !== idLastTimestamp) {
     idLastTimestamp = nowMs
     idCounter = 0
   }
   idCounter += 1
-  const encoded = (nowMs * 0x1000 + idCounter) & 0xffffffffffff
+  // BigInt, as OpenCode does: the JS `&` operator works on 32 bits, which made
+  // short, sometimes negative ids that sorted before OpenCode's own (ORI-2116).
+  const encoded = (BigInt(nowMs) * BigInt(0x1000) + BigInt(idCounter)) & BigInt(0xffffffffffff)
   const hex = encoded.toString(16).padStart(12, '0')
   return `${prefix}_${hex}${randomBase62(14)}`
 }
@@ -188,6 +194,7 @@ export function buildPromptRequestBody(
   const body: Record<string, unknown> = {
     parts: [{ type: 'text', text: content }],
     messageID: opencodeMessageId,
+    agent: HOSTED_AGENT_NAME,
   }
   if (!model) return body
 
@@ -495,7 +502,7 @@ export function createOpenCodeHarness(options: OpenCodeHarnessOptions): AgentHar
   }
 
   return {
-    name: 'opencode',
+    name: HARNESS_NAMES.opencode,
 
     async start(opts: HarnessStartOptions): Promise<{ agentSessionId: string }> {
       startModel = opts.model
@@ -598,13 +605,25 @@ export function createOpenCodeHarness(options: OpenCodeHarnessOptions): AgentHar
           if (emittedToolStates.has(toolKey)) return events
           emittedToolStates.add(toolKey)
           const terminal = status === 'completed' || status === 'error'
-          const payload: Record<string, unknown> = {
+          const payload: HarnessToolPayload = {
             tool: typeof part.tool === 'string' ? part.tool : '',
             args: input,
             callId,
             status,
+            harness: HARNESS_NAMES.opencode,
+          }
+          // A failed call keeps its message in `state.error`, not `state.output`
+          // (opencode-ai@1.14.41 ToolStateError); it is that call's output.
+          if (terminal) {
+            payload.output = typeof state.output === 'string' ? state.output
+              : typeof state.error === 'string' ? state.error : ''
+          }
+          // OpenCode's own one-line title and structured extras (ORI-2160),
+          // passed through as given; absent when the state has none.
+          if (typeof state.title === 'string' && state.title.length > 0) payload.title = state.title
+          if (state.metadata && typeof state.metadata === 'object' && !Array.isArray(state.metadata)) {
+            payload.metadata = state.metadata as Record<string, unknown>
           }
-          if (terminal) payload.output = typeof state.output === 'string' ? state.output : ''
           events.push({ kind: terminal ? 'tool_result' : 'tool_call', messageId: msgId, payload })
         } else if (partType === 'step-start') {
           events.push({ kind: 'step_start', messageId: msgId, payload: {} })
@@ -1116,6 +1135,8 @@ export function buildOpenCodeConfigContent(opts: OpenCodeConfigOptions): string
   return JSON.stringify({
     model: opts.model,
     permission: opts.permission ?? defaultHeadlessPermission(),
+    // Replaces OpenCode's built-in "You are opencode…" prompt (ORI-2207).
+    agent: { [HOSTED_AGENT_NAME]: { mode: 'primary', prompt: HOSTED_AGENT_PROMPT } },
   })
 }
 

package/src/hosted-harness.ts

@@ -117,8 +117,39 @@ export interface HarnessEvent {
   critical?: boolean
 }
 
+/** The drivers' stable names. A tool event's `harness` field is one of these. */
+export const HARNESS_NAMES = {
+  opencode: 'opencode',
+  claudeAgentSdk: 'claude-agent-sdk',
+} as const
+
+type HarnessName = (typeof HARNESS_NAMES)[keyof typeof HARNESS_NAMES]
+
+/**
+ * Payload of a `tool_call` / `tool_result` event (ORI-2160). One chat renderer
+ * shows every tool call whatever harness produced it, so the payload carries:
+ *   • `title`    — the harness's one-line summary of the call (OpenCode's
+ *                  `state.title`). Absent when the harness has none.
+ *   • `metadata` — structured extras such as a diff, an exit code or match
+ *                  counts (OpenCode's `state.metadata`). Absent when none.
+ *   • `harness`  — which driver produced the event.
+ * All three are optional: an event without them is still a valid tool event.
+ * The sink and the digest pass them through unchanged.
+ */
+export interface HarnessToolPayload {
+  [key: string]: unknown
+  tool?: string
+  args?: Record<string, unknown>
+  callId: string
+  status: string
+  output?: string
+  title?: string
+  metadata?: Record<string, unknown>
+  harness?: HarnessName
+}
+
 export interface AgentHarness {
-  /** Stable driver name — "opencode" | "claude-agent-sdk". */
+  /** Stable driver name — one of HARNESS_NAMES. */
   readonly name: string
   /** Boot the agent process/session; returns the resumable agent session id. */
   start(opts: HarnessStartOptions): Promise<{ agentSessionId: string }>

package/src/hosted-optimization-prebaked-marker.ts

@@ -0,0 +1,20 @@
+/**
+ * The check the session coordinator makes on `/opt/orizu/prebaked.json`, the
+ * first bootstrap command of a hosted optimization run. It lives here so the
+ * release bake's start check (hosted-runtime-image/check-snapshot-starts.mjs)
+ * rejects a snapshot on exactly the rules the coordinator would refuse it on.
+ * Worker code imports this module, so it must not use Node APIs.
+ */
+export function isHostedOptimizationPrebakedMarker(raw: string): boolean {
+  try {
+    const marker: unknown = JSON.parse(raw)
+    if (!marker || typeof marker !== 'object' || Array.isArray(marker)) return false
+    const value = marker as Record<string, unknown>
+    return value.builtFor === 'vercel-sandbox' &&
+      typeof value.cliVersion === 'string' && value.cliVersion.length > 0 &&
+      typeof value.opencodeVersion === 'string' && value.opencodeVersion.length > 0 &&
+      typeof value.claudeSdkVersion === 'string' && value.claudeSdkVersion.length > 0
+  } catch {
+    return false
+  }
+}

package/src/hosted-tool-hints.ts

@@ -0,0 +1,153 @@
+/**
+ * Tool display hints (ORI-2160, moved here for ORI-2167).
+ *
+ * Each harness driver has its own built-in tools. This module holds, per
+ * driver, what the chat needs to show a call without switching on its name:
+ * a category (icon), a label (the verb on the row), the input key that
+ * summarizes the call, how to show the output, and input keys to hide.
+ *
+ * It has no imports with side effects, so both the CLI and the web app
+ * (the chat renderer, and the activity projection that picks which input
+ * key reaches the browser) import it directly.
+ */
+// Type-only, so the web build never has to load the harness module itself.
+import type { HARNESS_NAMES } from './hosted-harness.js'
+
+type HarnessNames = typeof HARNESS_NAMES
+const OPENCODE: HarnessNames['opencode'] = 'opencode'
+const CLAUDE_AGENT_SDK: HarnessNames['claudeAgentSdk'] = 'claude-agent-sdk'
+
+/** What kind of thing a tool does — the renderer picks an icon/layout from
+ *  this, never from the tool name. */
+export const TOOL_CATEGORIES = {
+  file: 'file',
+  command: 'command',
+  search: 'search',
+  network: 'network',
+  question: 'question',
+  subAgent: 'sub-agent',
+  list: 'list',
+  plug: 'plug',
+  other: 'other',
+} as const
+
+export type ToolCategory = (typeof TOOL_CATEGORIES)[keyof typeof TOOL_CATEGORIES]
+
+/** How the tool's output text should be shown. */
+export const TOOL_OUTPUT_KINDS = {
+  text: 'text',
+  diff: 'diff',
+  markdown: 'markdown',
+  json: 'json',
+  list: 'list',
+} as const
+
+type ToolOutputKind = (typeof TOOL_OUTPUT_KINDS)[keyof typeof TOOL_OUTPUT_KINDS]
+
+/** Per-tool display hint. Each driver owns a table of these for its built-in
+ *  tools, so tool-name knowledge lives behind the seam. */
+export interface ToolHint {
+  category: ToolCategory
+  /** The verb the chat row shows ("Read", "Ran"). A tool without a hint shows
+   *  its own name instead. */
+  label?: string
+  /** The input key whose value summarizes the call (e.g. `command`), or null
+   *  when the tool takes no input worth summarizing. */
+  summaryKey: string | null
+  outputKind: ToolOutputKind
+  /** Input keys whose values must not be shown as-is (large bodies such as a
+   *  file's full new content, or likely secrets). */
+  redactKeys: readonly string[]
+}
+
+export type ToolHintTable = Readonly<Record<string, ToolHint>>
+
+// Argument names that look like they hold a credential. Redacted for every
+// tool, and never used as the fallback summary.
+const SECRET_LOOKING_KEY = /token|secret|password|passwd|api[_-]?key|authorization|credential/i
+
+/**
+ * Look a tool up in a driver's hint table. A tool the table does not know (an
+ * MCP tool, a plug-in) falls back to the `plug` category, summarized by its
+ * first non-empty string argument that does not look like a secret.
+ */
+export function resolveToolHint(
+  table: ToolHintTable,
+  tool: string,
+  args: Record<string, unknown> = {}
+): ToolHint {
+  const known = Object.hasOwn(table, tool) ? table[tool] : undefined
+  const secretKeys = Object.keys(args).filter(key => SECRET_LOOKING_KEY.test(key))
+  const redactKeys = [...new Set([...(known?.redactKeys ?? []), ...secretKeys])]
+  if (known) return { ...known, redactKeys }
+  const summaryKey =
+    Object.keys(args).find(key => {
+      const value = args[key]
+      return typeof value === 'string' && value.length > 0 && !redactKeys.includes(key)
+    }) ?? null
+  return { category: TOOL_CATEGORIES.plug, summaryKey, outputKind: TOOL_OUTPUT_KINDS.text, redactKeys }
+}
+
+// OpenCode's built-in tools, as the pinned opencode-ai@1.14.41 tool registry
+// lists them, with the input key that summarizes each call. Tools not listed
+// here (MCP tools, plug-ins) resolve to `plug` through resolveToolHint.
+export const OPENCODE_TOOL_HINTS: ToolHintTable = {
+  read: { category: 'file', label: 'Read', summaryKey: 'filePath', outputKind: 'text', redactKeys: [] },
+  edit: { category: 'file', label: 'Edited', summaryKey: 'filePath', outputKind: 'diff', redactKeys: ['oldString', 'newString'] },
+  write: { category: 'file', label: 'Wrote', summaryKey: 'filePath', outputKind: 'text', redactKeys: ['content'] },
+  apply_patch: { category: 'file', label: 'Edited', summaryKey: 'patchText', outputKind: 'diff', redactKeys: [] },
+  lsp: { category: 'file', label: 'Checked', summaryKey: 'filePath', outputKind: 'json', redactKeys: [] },
+  bash: { category: 'command', label: 'Ran', summaryKey: 'command', outputKind: 'text', redactKeys: [] },
+  glob: { category: 'search', label: 'Listed', summaryKey: 'pattern', outputKind: 'list', redactKeys: [] },
+  grep: { category: 'search', label: 'Searched', summaryKey: 'pattern', outputKind: 'text', redactKeys: [] },
+  webfetch: { category: 'network', label: 'Fetched', summaryKey: 'url', outputKind: 'markdown', redactKeys: [] },
+  websearch: { category: 'network', label: 'Searched', summaryKey: 'query', outputKind: 'text', redactKeys: [] },
+  question: { category: 'question', label: 'Asked', summaryKey: 'questions', outputKind: 'text', redactKeys: [] },
+  plan_exit: { category: 'question', label: 'Asked', summaryKey: null, outputKind: 'text', redactKeys: [] },
+  task: { category: 'sub-agent', label: 'Sub-agent', summaryKey: 'description', outputKind: 'markdown', redactKeys: [] },
+  todowrite: { category: 'list', label: 'Planned', summaryKey: 'todos', outputKind: 'json', redactKeys: [] },
+  skill: { category: 'other', label: 'Loaded', summaryKey: 'name', outputKind: 'markdown', redactKeys: [] },
+  invalid: { category: 'other', label: 'Invalid', summaryKey: 'tool', outputKind: 'text', redactKeys: [] },
+}
+
+// The Claude Agent SDK's built-in tools (SDK 0.3.201: input types in
+// sdk-tools.d.ts, names from the SDK; `Task` is the older name of `Agent`),
+// with the input key that summarizes each call. MCP tools
+// (`mcp__<server>__<tool>`) are not listed and resolve to `plug` through
+// resolveToolHint. This driver sends no `title` or `metadata`: the SDK has no
+// equivalent of OpenCode's.
+export const CLAUDE_TOOL_HINTS: ToolHintTable = {
+  Read: { category: 'file', label: 'Read', summaryKey: 'file_path', outputKind: 'text', redactKeys: [] },
+  Edit: { category: 'file', label: 'Edited', summaryKey: 'file_path', outputKind: 'text', redactKeys: ['old_string', 'new_string'] },
+  Write: { category: 'file', label: 'Wrote', summaryKey: 'file_path', outputKind: 'text', redactKeys: ['content'] },
+  NotebookEdit: { category: 'file', label: 'Edited', summaryKey: 'notebook_path', outputKind: 'text', redactKeys: ['new_source'] },
+  Bash: { category: 'command', label: 'Ran', summaryKey: 'command', outputKind: 'text', redactKeys: [] },
+  TaskOutput: { category: 'command', label: 'Checked', summaryKey: 'task_id', outputKind: 'text', redactKeys: [] },
+  TaskStop: { category: 'command', label: 'Stopped', summaryKey: 'task_id', outputKind: 'text', redactKeys: [] },
+  Glob: { category: 'search', label: 'Listed', summaryKey: 'pattern', outputKind: 'list', redactKeys: [] },
+  Grep: { category: 'search', label: 'Searched', summaryKey: 'pattern', outputKind: 'text', redactKeys: [] },
+  WebFetch: { category: 'network', label: 'Fetched', summaryKey: 'url', outputKind: 'markdown', redactKeys: [] },
+  WebSearch: { category: 'network', label: 'Searched', summaryKey: 'query', outputKind: 'text', redactKeys: [] },
+  AskUserQuestion: { category: 'question', label: 'Asked', summaryKey: 'questions', outputKind: 'text', redactKeys: [] },
+  ExitPlanMode: { category: 'question', label: 'Asked', summaryKey: null, outputKind: 'markdown', redactKeys: [] },
+  Agent: { category: 'sub-agent', label: 'Sub-agent', summaryKey: 'description', outputKind: 'markdown', redactKeys: [] },
+  Task: { category: 'sub-agent', label: 'Sub-agent', summaryKey: 'description', outputKind: 'markdown', redactKeys: [] },
+  TodoWrite: { category: 'list', label: 'Planned', summaryKey: 'todos', outputKind: 'text', redactKeys: [] },
+  ListMcpResourcesTool: { category: 'plug', label: 'Listed', summaryKey: 'server', outputKind: 'json', redactKeys: [] },
+  ReadMcpResourceTool: { category: 'plug', label: 'Read', summaryKey: 'uri', outputKind: 'text', redactKeys: [] },
+  Skill: { category: 'other', label: 'Loaded', summaryKey: 'skill', outputKind: 'markdown', redactKeys: [] },
+}
+
+const NO_HINTS: ToolHintTable = {}
+
+/**
+ * The hint table for the harness that produced an event. Events recorded
+ * before the seam named its harness came from OpenCode, the default driver.
+ * A harness with no table here (a future pi driver, say) gets none, so every
+ * tool falls back to its own name and first string argument.
+ */
+export function toolHintsFor(harness: string | undefined): ToolHintTable {
+  if (harness === undefined || harness === OPENCODE) return OPENCODE_TOOL_HINTS
+  if (harness === CLAUDE_AGENT_SDK) return CLAUDE_TOOL_HINTS
+  return NO_HINTS
+}

package/src/index.ts

@@ -112,7 +112,7 @@ import { resolveAuthTokenForBaseUrl } from './credentials.js'
 import { applyHostedInstructionSetProfileOverride, dispatchHostedCommands } from './hosted-commands.js'
 import { dispatchGepaEngine } from './gepa-engine-dispatch.js'
 import { getGepaPythonPathEntries } from './gepa-python-paths.js'
-import { resolveGepaInstructionSetProfileVersion } from './instruction-set-gepa-launch.js'
+import { resolveGepaSeedFromEnvironment } from './instruction-set-gepa-launch.js'
 import { prepareSkilledProposerLaunch, spawnSkilledProposerChild } from './skilled-proposer-launch.js'
 import { reportCommentsCommand, throwDeprecatedPromptCommentsCommand } from './report-comments-cli.js'
 import { getCapabilities, renderHelpForArgs } from './help.js'
@@ -1365,10 +1365,7 @@ async function runGepaOptimization() {
       PYTHONPATH: getGepaPythonPathEntries(process.env.PYTHONPATH).join(delimiter),
       PYTHONUNBUFFERED: process.env.PYTHONUNBUFFERED || '1',
     }))
-    const instructionSetName = dispatch.environment.ORIZU_INSTRUCTION_SET_NAME
-    const modelConfigIdentity = dispatch.environment.ORIZU_MODEL_CONFIG_IDENTITY
-    const instructionSetProfileVersionId = instructionSetName && modelConfigIdentity
-      ? await resolveGepaInstructionSetProfileVersion(instructionSetName, modelConfigIdentity, project) : undefined
+    const instructionSetProfileVersionId = await resolveGepaSeedFromEnvironment(dispatch.environment, project, 'production')
     if (instructionSetProfileVersionId) dispatch.environment.ORIZU_INSTRUCTION_SET_PROFILE_VERSION_ID = instructionSetProfileVersionId
     selectedEngine = dispatch.engine
     const launch = prepareSkilledProposerLaunch(python, dispatch.engine, dispatch.environment)