@taewooopark/agent-blackbox 0.42.0

package/dist/agent-blackbox.plugin.mjs

@@ -0,0 +1,1162 @@
+// packages/core/src/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/core/src/events.ts
+var traceHosts = [
+  "opencode",
+  "pi",
+  "codex",
+  "claude-code",
+  "hermes",
+  "custom"
+];
+var traceEventKinds = [
+  "session_created",
+  "session_updated",
+  "session_idle",
+  "session_error",
+  "agent_start",
+  "agent_end",
+  "turn_start",
+  "turn_end",
+  "message",
+  "tool_call",
+  "tool_result",
+  "file_read",
+  "file_edit",
+  "file_created",
+  "file_deleted",
+  "search",
+  "bash",
+  "permission_asked",
+  "permission_replied",
+  "todo_updated",
+  "subagent_spawned",
+  "decision_extracted",
+  "blocker_detected",
+  "handoff_generated",
+  "git_status",
+  "git_commit",
+  "git_push",
+  "context_compacted",
+  "command_run",
+  "agent_switched",
+  "model_switched",
+  "host_event"
+];
+var dataSensitivities = [
+  "public",
+  "internal",
+  "private",
+  "secret",
+  "student_sensitive"
+];
+var observedKinds = /* @__PURE__ */ new Set([
+  "tool_call",
+  "tool_result",
+  "file_read",
+  "file_edit",
+  "file_created",
+  "file_deleted",
+  "search",
+  "bash",
+  "permission_asked",
+  "permission_replied",
+  "todo_updated",
+  "git_status",
+  "git_commit",
+  "git_push"
+]);
+var claimKinds = /* @__PURE__ */ new Set(["message", "decision_extracted", "handoff_generated"]);
+function createTraceEvent(seq, input) {
+  const id = makeTraceEventId(input.runId, seq);
+  const evidence = inferEvidence(input.kind, input.evidence);
+  return {
+    id,
+    ts: input.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    seq,
+    host: input.host,
+    runId: input.runId,
+    sessionId: input.sessionId,
+    ...input.parentSessionId ? { parentSessionId: input.parentSessionId } : {},
+    ...input.agentId ? { agentId: input.agentId } : {},
+    ...input.agentRole ? { agentRole: input.agentRole } : {},
+    ...input.turnId ? { turnId: input.turnId } : {},
+    kind: input.kind,
+    ...input.summary ? { summary: input.summary } : {},
+    payload: input.payload ?? {},
+    sensitivity: input.sensitivity ?? "private",
+    redaction: {
+      rawStored: input.redaction?.rawStored ?? false,
+      rulesApplied: input.redaction?.rulesApplied ?? [],
+      truncated: input.redaction?.truncated ?? false
+    },
+    evidence
+  };
+}
+function makeTraceEventId(runId, seq) {
+  const safeRunId = runId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `evt_${safeRunId}_${String(seq).padStart(6, "0")}`;
+}
+function validateTraceEvent(event) {
+  const errors = [];
+  if (!isRecord(event)) {
+    return { ok: false, errors: ["event must be an object"] };
+  }
+  requireString(event, "id", errors);
+  requireString(event, "ts", errors);
+  requireNumber(event, "seq", errors);
+  requireEnum(event, "host", traceHosts, errors);
+  requireString(event, "runId", errors);
+  requireString(event, "sessionId", errors);
+  requireEnum(event, "kind", traceEventKinds, errors);
+  requireEnum(event, "sensitivity", dataSensitivities, errors);
+  if (!isRecord(event.payload)) {
+    errors.push("payload must be an object");
+  }
+  if (!isRecord(event.redaction)) {
+    errors.push("redaction must be an object");
+  }
+  if (!isRecord(event.evidence)) {
+    errors.push("evidence must be an object");
+  }
+  if (typeof event.ts === "string" && Number.isNaN(Date.parse(event.ts))) {
+    errors.push("ts must be an ISO-compatible timestamp");
+  }
+  if (typeof event.seq === "number" && (!Number.isInteger(event.seq) || event.seq < 1)) {
+    errors.push("seq must be a positive integer");
+  }
+  return { ok: errors.length === 0, errors };
+}
+function assertTraceEvent(event) {
+  const result = validateTraceEvent(event);
+  if (!result.ok) {
+    throw new Error(`Invalid trace event: ${result.errors.join("; ")}`);
+  }
+}
+function inferEvidence(kind, override) {
+  return {
+    observed: override?.observed ?? observedKinds.has(kind),
+    claimedByModel: override?.claimedByModel ?? claimKinds.has(kind)
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(value, key, errors) {
+  if (typeof value[key] !== "string" || value[key] === "") {
+    errors.push(`${key} must be a non-empty string`);
+  }
+}
+function requireNumber(value, key, errors) {
+  if (typeof value[key] !== "number") {
+    errors.push(`${key} must be a number`);
+  }
+}
+function requireEnum(value, key, allowed, errors) {
+  if (typeof value[key] !== "string" || !allowed.includes(value[key])) {
+    errors.push(`${key} must be one of ${allowed.join(", ")}`);
+  }
+}
+
+// packages/core/src/redaction.ts
+var defaultRedactionRules = [
+  {
+    name: "github-token",
+    pattern: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/g,
+    replacement: "[REDACTED_GITHUB_TOKEN]"
+  },
+  {
+    name: "openai-key",
+    pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+    replacement: "[REDACTED_OPENAI_KEY]"
+  },
+  {
+    name: "anthropic-key",
+    pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g,
+    replacement: "[REDACTED_ANTHROPIC_KEY]"
+  },
+  {
+    name: "private-key",
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    replacement: "[REDACTED_PRIVATE_KEY]"
+  }
+];
+function redactJsonObject(payload, options = {}) {
+  return redactJsonValue(payload, options);
+}
+function redactJsonValue(value, options = {}) {
+  const rules = [...defaultRedactionRules, ...options.extraRules ?? []];
+  const applied = /* @__PURE__ */ new Set();
+  let truncated = false;
+  const maxStringLength = options.maxStringLength ?? 4e3;
+  const visit = (current) => {
+    if (typeof current === "string") {
+      let next = current;
+      if (options.homeDir) {
+        next = replaceLiteral(next, options.homeDir, "~", "home-dir", applied);
+      }
+      if (options.projectDir) {
+        next = replaceLiteral(next, options.projectDir, "$PROJECT", "project-dir", applied);
+      }
+      for (const rule of rules) {
+        if (rule.pattern.test(next)) {
+          applied.add(rule.name);
+          next = next.replace(rule.pattern, rule.replacement);
+        }
+        rule.pattern.lastIndex = 0;
+      }
+      if (next.length > maxStringLength) {
+        truncated = true;
+        applied.add("truncate-string");
+        return `${next.slice(0, maxStringLength)}...[TRUNCATED ${next.length - maxStringLength} chars]`;
+      }
+      return next;
+    }
+    if (Array.isArray(current)) {
+      return current.map((item) => visit(item));
+    }
+    if (isJsonObject(current)) {
+      const next = {};
+      for (const [key, nested] of Object.entries(current)) {
+        next[key] = visit(nested);
+      }
+      return next;
+    }
+    return current;
+  };
+  return {
+    value: visit(value),
+    rulesApplied: [...applied].sort(),
+    truncated
+  };
+}
+function replaceLiteral(value, search, replacement, ruleName, applied) {
+  if (!search || !value.includes(search)) {
+    return value;
+  }
+  applied.add(ruleName);
+  return value.split(search).join(replacement);
+}
+
+// packages/opencode-adapter/dist/normalize.js
+var eventKindMap = {
+  "session.created": "session_created",
+  "session.updated": "session_updated",
+  "session.status": "session_updated",
+  "session.idle": "session_idle",
+  "session.error": "session_error",
+  "message.updated": "message",
+  "message.removed": "message",
+  "message.part.updated": "message",
+  "message.part.removed": "message",
+  "file.edited": "file_edit",
+  // `command.executed` is a SLASH/template command (/init, /review, custom, MCP) —
+  // not the bash tool (that arrives via tool.execute.*). Give it its own node.
+  "command.executed": "command_run",
+  // Context compaction is published as `session.compacted` at the end of a compact.
+  "session.compacted": "context_compacted",
+  "session.next.compaction.ended": "context_compacted",
+  // experimental engine equivalent
+  "permission.asked": "permission_asked",
+  "permission.updated": "permission_asked",
+  // SDK union name for a permission request
+  "permission.replied": "permission_replied",
+  "todo.updated": "todo_updated",
+  // The active agent / model changed mid-run (multi-model harnesses route per task).
+  "session.next.agent.switched": "agent_switched",
+  "session.next.model.switched": "model_switched"
+};
+var ignoredEventTypes = /* @__PURE__ */ new Set([
+  "message.part.delta",
+  "catalog.updated",
+  "plugin.added",
+  "plugin.removed",
+  "integration.updated",
+  "reference.updated",
+  "models-dev.refreshed",
+  "global.disposed",
+  // High-volume or no-signal session chatter: `session.diff` is the cumulative
+  // running diff (actual edits are captured as file_edit), `session.deleted` is
+  // teardown, and the experimental compaction start/delta are superseded by the
+  // `*.ended` node.
+  "session.diff",
+  "session.deleted",
+  "session.next.compaction.started",
+  "session.next.compaction.delta"
+]);
+var ignoredEventPrefixes = [
+  "tui.",
+  "lsp.",
+  "pty.",
+  "mcp.",
+  "vcs.",
+  "file.watcher.",
+  "workspace.",
+  "worktree.",
+  "project.",
+  "server.",
+  "installation."
+];
+function shouldRecordOpenCodeEvent(rawEvent) {
+  const type = readString(asRecord(rawEvent), ["type"]);
+  if (!type)
+    return true;
+  if (ignoredEventTypes.has(type))
+    return false;
+  return !ignoredEventPrefixes.some((prefix) => type.startsWith(prefix));
+}
+function subagentSessionFromEvent(rawEvent) {
+  const raw = asRecord(rawEvent);
+  if (readString(raw, ["type"]) !== "session.created")
+    return null;
+  const properties = asRecord(raw.properties);
+  const info = asRecord(properties.info);
+  const parentId = readString(info, ["parentID", "parentId"]);
+  const sessionId = readString(info, ["id"]) ?? readString(properties, ["sessionID", "sessionId"]);
+  if (!parentId || !sessionId)
+    return null;
+  const agent = readString(info, ["agent"]) ?? agentFromSubagentTitle(readString(info, ["title"])) ?? "subagent";
+  return { agent, parentId, sessionId };
+}
+function agentFromSubagentTitle(title) {
+  if (!title)
+    return void 0;
+  const match = title.match(/@([A-Za-z0-9][\w-]*)/);
+  return match ? match[1] : void 0;
+}
+function normalizeOpenCodeEvent(rawEvent, context) {
+  const raw = asRecord(rawEvent);
+  const type = readString(raw, ["type"]) ?? "unknown";
+  const kind = eventKindMap[type] ?? "host_event";
+  const payload = normalizePayload(minimizeOpenCodeEventPayload(raw, type), context);
+  const sessionId = extractSessionId(raw, context.defaultSessionId);
+  const agentId = extractAgentId(raw);
+  const agentRole = extractAgentRole(raw);
+  return createTraceEvent(context.seq, {
+    host: "opencode",
+    runId: context.runId,
+    sessionId,
+    ...agentId ? { agentId } : {},
+    ...agentId ? { agentRole } : {},
+    kind,
+    summary: type,
+    payload: payload.value,
+    redaction: {
+      rawStored: context.rawStored ?? false,
+      rulesApplied: payload.rulesApplied,
+      truncated: payload.truncated
+    }
+  });
+}
+function normalizeSyntheticUserPrompt(prompt, sourceEvent, context) {
+  const payload = normalizePayload({
+    type: "opencode.run.prompt",
+    properties: {
+      sessionID: sourceEvent.sessionId,
+      role: "user",
+      text: stripWrappingQuotes(prompt)
+    }
+  }, context);
+  return createTraceEvent(context.seq, {
+    host: "opencode",
+    runId: context.runId,
+    sessionId: sourceEvent.sessionId,
+    kind: "message",
+    summary: "opencode.run.prompt",
+    payload: payload.value,
+    redaction: {
+      rawStored: context.rawStored ?? false,
+      rulesApplied: payload.rulesApplied,
+      truncated: payload.truncated
+    }
+  });
+}
+function minimizeOpenCodeEventPayload(raw, type) {
+  if (!type.startsWith("message.")) {
+    return toJsonObject(raw);
+  }
+  const properties = asRecord(raw.properties);
+  const info = asRecord(properties.info);
+  const part = asRecord(properties.part);
+  const state = asRecord(part.state);
+  const role = readString(info, ["role"]) ?? readString(properties, ["role"]);
+  const userText = role === "user" ? shortenOptional(readMessageText(properties, info, part), 2e3) : void 0;
+  return compactJsonObject({
+    id: readString(raw, ["id"]),
+    type,
+    properties: compactJsonObject({
+      sessionID: readString(properties, ["sessionID"]) ?? readString(info, ["sessionID"]) ?? readString(part, ["sessionID"]),
+      messageID: readString(properties, ["messageID"]) ?? readString(info, ["id"]) ?? readString(part, ["messageID"]),
+      role,
+      agent: readString(info, ["agent"]),
+      modelID: readString(info, ["modelID", "model.modelID"]),
+      text: userText,
+      field: readString(properties, ["field"]),
+      deltaLength: readString(properties, ["delta"])?.length,
+      part: compactJsonObject({
+        id: readString(part, ["id"]),
+        type: readString(part, ["type"]),
+        tool: readString(part, ["tool"]),
+        callID: readString(part, ["callID"]),
+        stateStatus: readString(state, ["status"])
+      })
+    })
+  });
+}
+function normalizeToolBefore(input, output, context) {
+  const payload = normalizePayload({
+    phase: "before",
+    tool: readString(input, ["tool", "name"]) ?? readString(output, ["tool", "name"]) ?? "unknown-tool",
+    input,
+    output
+  }, context);
+  const traceInput = {
+    host: "opencode",
+    runId: context.runId,
+    sessionId: extractSessionId(input, context.defaultSessionId),
+    kind: "tool_call",
+    summary: `tool.before:${payload.value.tool ?? "unknown-tool"}`,
+    payload: payload.value,
+    redaction: {
+      rawStored: context.rawStored ?? false,
+      rulesApplied: payload.rulesApplied,
+      truncated: payload.truncated
+    }
+  };
+  const agentId = extractAgentId(input);
+  if (agentId) {
+    traceInput.agentId = agentId;
+  }
+  return createTraceEvent(context.seq, traceInput);
+}
+function normalizeToolAfter(input, output, context) {
+  const tool = readString(input, ["tool", "name"]) ?? readString(output, ["tool", "name"]) ?? "unknown-tool";
+  const payload = normalizePayload({
+    phase: "after",
+    tool,
+    input,
+    output
+  }, context);
+  const observed = deriveObservedToolResult(tool, payload.value);
+  const traceInput = {
+    host: "opencode",
+    runId: context.runId,
+    sessionId: extractSessionId(input, context.defaultSessionId),
+    kind: observed?.kind ?? "tool_result",
+    summary: observed?.summary ?? `tool.after:${payload.value.tool ?? "unknown-tool"}`,
+    payload: observed?.payload ?? payload.value,
+    redaction: {
+      rawStored: context.rawStored ?? false,
+      rulesApplied: payload.rulesApplied,
+      truncated: payload.truncated
+    }
+  };
+  if (observed?.kind === "subagent_spawned") {
+    const subagentId = readString(observed.payload, ["agent"]);
+    traceInput.agentId = subagentId ?? extractAgentId(input) ?? "subagent";
+    traceInput.agentRole = "subagent";
+  } else {
+    const agentId = extractAgentId(input);
+    if (agentId) {
+      traceInput.agentId = agentId;
+    }
+  }
+  return createTraceEvent(context.seq, traceInput);
+}
+function deriveObservedToolResult(tool, payload) {
+  if (tool === "read") {
+    const path = readString(payload, ["input.args.filePath", "output.metadata.display.path"]) ?? readString(payload, ["output.title"]);
+    const size2 = measureContent(payload, ["output.output", "output.content", "output.metadata.preview"]);
+    const observedPayload = compactJsonObject({
+      tool,
+      source: "tool.after",
+      path,
+      callID: readString(payload, ["input.callID"]),
+      preview: readString(payload, ["output.metadata.preview"]),
+      truncated: readBoolean(payload, ["output.metadata.truncated"]),
+      chars: size2?.chars,
+      lines: size2?.lines
+    });
+    return {
+      kind: "file_read",
+      summary: path ? `Read ${path}` : "Read file",
+      payload: observedPayload
+    };
+  }
+  if (tool === "bash") {
+    const command = readString(payload, ["input.args.command", "output.metadata.command"]);
+    const exitCode = readNumber(payload, ["output.metadata.exit", "output.metadata.exitCode"]);
+    const outputPreview = shortenOptional(readString(payload, ["output.metadata.output", "output.output"]), 1200);
+    const size2 = measureContent(payload, ["output.metadata.output", "output.output"]);
+    const observedPayload = compactJsonObject({
+      tool,
+      source: "tool.after",
+      command,
+      exitCode,
+      description: readString(payload, ["input.args.description", "output.metadata.description"]),
+      outputPreview,
+      truncated: readBoolean(payload, ["output.metadata.truncated"]),
+      outputChars: size2?.chars,
+      outputLines: size2?.lines
+    });
+    return {
+      kind: "bash",
+      summary: command ? `Ran ${command}` : "Ran shell command",
+      payload: observedPayload
+    };
+  }
+  if (tool === "edit" || tool === "write" || tool === "patch") {
+    const path = readString(payload, ["input.args.filePath", "input.args.path", "output.metadata.path"]);
+    const size2 = measureContent(payload, [
+      "input.args.content",
+      "input.args.newString",
+      "input.args.replacement",
+      "input.args.patch"
+    ]);
+    const observedPayload = compactJsonObject({
+      tool,
+      source: "tool.after",
+      path,
+      callID: readString(payload, ["input.callID"]),
+      chars: size2?.chars,
+      lines: size2?.lines
+    });
+    return {
+      kind: tool === "write" ? "file_created" : "file_edit",
+      summary: path ? `Edited ${path}` : "Edited file",
+      payload: observedPayload
+    };
+  }
+  if (tool === "task") {
+    const subagentType = readString(payload, ["input.args.subagent_type", "output.args.subagent_type"]);
+    const description = readString(payload, ["input.args.description", "output.args.description"]);
+    const observedPayload = compactJsonObject({
+      tool,
+      source: "tool.after",
+      agent: subagentType,
+      description,
+      prompt: shortenOptional(readString(payload, ["input.args.prompt", "output.args.prompt"]), 600),
+      callID: readString(payload, ["input.callID"])
+    });
+    return {
+      kind: "subagent_spawned",
+      summary: subagentType ? `Delegated to ${subagentType} subagent` : "Delegated to a subagent",
+      payload: observedPayload
+    };
+  }
+  if (tool === "skill") {
+    const name = readString(payload, ["input.args.name", "output.args.name"]);
+    const size2 = measureContent(payload, ["output.output", "output.content"]);
+    return {
+      kind: "tool_result",
+      summary: name ? `Used the ${name} skill` : "Used a skill",
+      payload: compactJsonObject({
+        tool: "skill",
+        source: "tool.after",
+        skill: name,
+        title: readString(payload, ["output.title"]),
+        callID: readString(payload, ["input.callID"]),
+        outputChars: size2?.chars,
+        outputLines: size2?.lines
+      })
+    };
+  }
+  const size = measureContent(payload, ["output.output", "output.content", "output.metadata.output"]);
+  return {
+    kind: "tool_result",
+    summary: `Used ${tool}`,
+    payload: compactJsonObject({
+      tool,
+      source: "tool.after",
+      title: readString(payload, ["output.title"]),
+      description: readString(payload, ["input.args.description", "output.metadata.description"]),
+      callID: readString(payload, ["input.callID"]),
+      outputChars: size?.chars,
+      outputLines: size?.lines
+    })
+  };
+}
+function readMessageText(...records) {
+  for (const record of records) {
+    const direct = readString(record, ["text", "content", "prompt", "message"]);
+    if (direct) {
+      return direct;
+    }
+    const parts = readPath(record, "parts");
+    if (Array.isArray(parts)) {
+      const text = parts.map((part) => {
+        if (!isRecord2(part))
+          return void 0;
+        return readString(part, ["text", "content"]);
+      }).filter((part) => Boolean(part)).join("\n").trim();
+      if (text.length > 0) {
+        return text;
+      }
+    }
+  }
+  return void 0;
+}
+function normalizePayload(value, context) {
+  return redactJsonObject(toJsonObject(value), {
+    ...context.homeDir ? { homeDir: context.homeDir } : {},
+    ...context.projectDir ? { projectDir: context.projectDir } : {},
+    maxStringLength: 4e3
+  });
+}
+function toJsonObject(value) {
+  return sanitizeJson(value, /* @__PURE__ */ new WeakSet());
+}
+function sanitizeJson(value, seen) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    return value.map((item) => sanitizeJson(item, seen));
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const output = {};
+    for (const [key, nested] of Object.entries(value)) {
+      if (typeof nested === "undefined" || typeof nested === "function" || typeof nested === "symbol") {
+        continue;
+      }
+      output[key] = sanitizeJson(nested, seen);
+    }
+    return output;
+  }
+  return String(value);
+}
+function extractSessionId(raw, fallback) {
+  const properties = asRecord(raw.properties);
+  return readString(raw, ["sessionID", "sessionId", "session.id"]) ?? readString(properties, ["sessionID", "sessionId", "session.id"]) ?? readString(asRecord(properties.info), ["sessionID", "sessionId"]) ?? readString(asRecord(properties.part), ["sessionID", "sessionId"]) ?? readString(asRecord(raw.event), ["sessionID", "sessionId", "session.id"]) ?? fallback;
+}
+function extractAgentId(raw) {
+  const properties = asRecord(raw.properties);
+  const info = asRecord(properties.info);
+  return readString(raw, ["agentID", "agentId", "agent.id", "agent.name"]) ?? readString(properties, ["agentID", "agentId", "agent.id", "agent.name", "agent"]) ?? readString(info, ["agentID", "agentId", "agent.id", "agent.name", "agent"]) ?? readString(asRecord(raw.event), ["agentID", "agentId", "agent.id", "agent.name", "agent"]);
+}
+function extractAgentRole(raw) {
+  const role = readString(raw, ["agentRole", "agent.role"]) ?? readString(asRecord(raw.properties), ["agentRole", "agent.role"]) ?? readString(asRecord(asRecord(raw.properties).info), ["agentRole", "agent.role"]);
+  if (role === "subagent" || role === "system" || role === "unknown")
+    return role;
+  return "primary";
+}
+function stripWrappingQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= 2) {
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if (first === `"` && last === `"` || first === "'" && last === "'") {
+      return trimmed.slice(1, -1).trim();
+    }
+  }
+  return trimmed;
+}
+function readString(record, keys) {
+  for (const key of keys) {
+    const value = readPath(record, key);
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readNumber(record, keys) {
+  for (const key of keys) {
+    const value = readPath(record, key);
+    if (typeof value === "number") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readBoolean(record, keys) {
+  for (const key of keys) {
+    const value = readPath(record, key);
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readPath(record, path) {
+  const parts = path.split(".");
+  let current = record;
+  for (const part of parts) {
+    if (!isRecord2(current)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function compactJsonObject(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "undefined") {
+      continue;
+    }
+    output[key] = sanitizeJson(value, /* @__PURE__ */ new WeakSet());
+  }
+  return output;
+}
+function shortenOptional(value, maxLength) {
+  if (value === void 0 || value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength)}...`;
+}
+function measureContent(record, paths) {
+  let longest;
+  for (const path of paths) {
+    const value = readPath(record, path);
+    if (typeof value === "string" && (longest === void 0 || value.length > longest.length)) {
+      longest = value;
+    }
+  }
+  if (longest === void 0) {
+    return void 0;
+  }
+  return { chars: longest.length, lines: longest.split("\n").length };
+}
+function asRecord(value) {
+  return isRecord2(value) ? value : {};
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/opencode-adapter/dist/optimize.js
+import { createHash } from "node:crypto";
+var hashContent = (content) => createHash("sha1").update(content).digest("hex").slice(0, 12);
+var READ_TOOLS = /* @__PURE__ */ new Set(["read", "view", "cat", "readfile", "read_file"]);
+var isReadTool = (tool) => typeof tool === "string" && READ_TOOLS.has(tool.toLowerCase());
+function readArgPath(args) {
+  if (!args || typeof args !== "object")
+    return void 0;
+  const a = args;
+  for (const key of ["filePath", "path", "file", "filename", "target"]) {
+    const v = a[key];
+    if (typeof v === "string" && v.length > 0)
+      return v;
+  }
+  return void 0;
+}
+var baseName = (path) => path.split(/[\\/]/).filter(Boolean).pop() ?? path;
+function computeReadDelta(prior, current, path) {
+  const a = prior.split("\n");
+  const b = current.split("\n");
+  let p = 0;
+  while (p < a.length && p < b.length && a[p] === b[p])
+    p += 1;
+  let s = 0;
+  while (s < a.length - p && s < b.length - p && a[a.length - 1 - s] === b[b.length - 1 - s])
+    s += 1;
+  const changed = b.slice(p, b.length - s);
+  if (changed.length === 0)
+    return null;
+  const from = p + 1;
+  const to = b.length - s;
+  return `\u27E8Agent-Blackbox: ${baseName(path)} changed since your last read \u2014 showing only lines ${from}\u2013${to}; the ${p} leading and ${s} trailing lines are unchanged from your earlier copy.\u27E9
+` + changed.join("\n");
+}
+function decideReadServe(prior, current, gen, path) {
+  if (!prior || prior.gen !== gen)
+    return { mode: "full", saved: 0 };
+  if (prior.hash === current.hash) {
+    const lines = current.content.split("\n").length;
+    const note = `\u27E8Agent-Blackbox: identical to your earlier read of ${baseName(path)} (${lines} lines, unchanged) \u2014 reuse that copy instead of re-reading.\u27E9`;
+    return { mode: "noop", output: note, saved: Math.max(0, current.content.length - note.length) };
+  }
+  const diff = computeReadDelta(prior.content, current.content, path);
+  if (diff && diff.length < current.content.length * 0.8) {
+    return { mode: "diff", output: diff, saved: current.content.length - diff.length };
+  }
+  return { mode: "full", saved: 0 };
+}
+var WORKING_SET_START = "\u27E8agent-blackbox:working-set\u27E9";
+var WORKING_SET_END = "\u27E8/agent-blackbox:working-set\u27E9";
+function buildWorkingSetBlock(files, commands) {
+  const hot = [...files].sort((x, y) => y.reads + y.edits - (x.reads + x.edits)).slice(0, 8);
+  const cmds = [...new Set(commands)].slice(0, 4);
+  if (hot.length === 0 && cmds.length === 0)
+    return null;
+  const lines = [];
+  if (hot.length > 0) {
+    lines.push("Files already in play (read once and reuse \u2014 don't re-read whole files):");
+    for (const f of hot) {
+      const touches = [f.reads ? `read ${f.reads}\xD7` : "", f.edits ? `edited ${f.edits}\xD7` : ""].filter(Boolean).join(", ");
+      lines.push(`- ${f.path}${touches ? ` (${touches})` : ""}`);
+    }
+  }
+  if (cmds.length > 0) {
+    lines.push("Verified commands (reuse, don't rediscover):");
+    for (const c of cmds)
+      lines.push(`- ${c}`);
+  }
+  return [WORKING_SET_START, "Agent-Blackbox working set \u2014 what this run has already established:", ...lines, WORKING_SET_END].join("\n");
+}
+var NAV_VERBS = /* @__PURE__ */ new Set([
+  "ls",
+  "pwd",
+  "cat",
+  "find",
+  "grep",
+  "rg",
+  "fd",
+  "head",
+  "tail",
+  "echo",
+  "which",
+  "env",
+  "cd",
+  "tree",
+  "stat",
+  "wc",
+  "sort",
+  "uniq",
+  "clear",
+  "sleep",
+  "true",
+  "false"
+]);
+var isReusableCommand = (command) => {
+  const verb = command.trim().split(/\s+/)[0] ?? "";
+  return verb.length > 0 && !NAV_VERBS.has(verb);
+};
+
+// packages/storage/src/ndjson.ts
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+function serializeTraceEvent(event) {
+  assertTraceEvent(event);
+  return `${JSON.stringify(event)}
+`;
+}
+async function appendTraceEvent(filePath, event) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await appendFile(filePath, serializeTraceEvent(event), "utf8");
+}
+
+// packages/opencode-adapter/dist/sink.js
+import { join } from "node:path";
+function createTraceSink(options) {
+  if (options.sink) {
+    return options.sink;
+  }
+  if (options.daemonUrl) {
+    return createHttpTraceSink(options.daemonUrl);
+  }
+  return createFileTraceSink(options.eventsFile ?? join(options.directory, ".agent-blackbox", "events.ndjson"));
+}
+function createFileTraceSink(eventsFile) {
+  return {
+    async write(event) {
+      await appendTraceEvent(eventsFile, event);
+    }
+  };
+}
+function createHttpTraceSink(daemonUrl, options = {}) {
+  const endpoint = new URL("/events", daemonUrl.endsWith("/") ? daemonUrl : `${daemonUrl}/`);
+  const retries = options.retries ?? 3;
+  const timeoutMs = options.timeoutMs ?? 4e3;
+  const retryDelayMs = options.retryDelayMs ?? 120;
+  const warn = options.onWarn ?? ((message) => console.warn(`[agent-blackbox] ${message}`));
+  return {
+    async write(event) {
+      let lastError = "";
+      for (let attempt = 0; attempt <= retries; attempt += 1) {
+        try {
+          const response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(event),
+            signal: AbortSignal.timeout(timeoutMs)
+          });
+          if (response.ok) {
+            return;
+          }
+          if (response.status < 500) {
+            warn(`daemon rejected event ${event.id}: HTTP ${response.status}`);
+            return;
+          }
+          lastError = `HTTP ${response.status}`;
+        } catch (error) {
+          lastError = error instanceof Error ? error.message : String(error);
+        }
+        if (attempt < retries) {
+          await delay(retryDelayMs * (attempt + 1));
+        }
+      }
+      warn(`could not deliver event ${event.id} after ${retries + 1} attempts (${lastError}); dropping it`);
+    }
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function resolveRecorderOptions(options) {
+  const resolved = {};
+  const daemonUrl = options.daemonUrl ?? process.env.AGENT_BLACKBOX_DAEMON_URL;
+  const runId = options.runId ?? process.env.AGENT_BLACKBOX_RUN_ID;
+  if (daemonUrl)
+    resolved.daemonUrl = daemonUrl;
+  if (runId)
+    resolved.runId = runId;
+  if (options.cliPrompt)
+    resolved.cliPrompt = options.cliPrompt;
+  if (options.eventsFile)
+    resolved.eventsFile = options.eventsFile;
+  if (options.sink)
+    resolved.sink = options.sink;
+  if (options.homeDir)
+    resolved.homeDir = options.homeDir;
+  if (options.projectDir)
+    resolved.projectDir = options.projectDir;
+  if (typeof options.rawStored === "boolean")
+    resolved.rawStored = options.rawStored;
+  if (typeof options.optimize === "boolean")
+    resolved.optimize = options.optimize;
+  return resolved;
+}
+
+// packages/opencode-adapter/dist/index.js
+async function createOpenCodeRecorder(context, options = {}) {
+  const resolved = resolveRecorderOptions(options);
+  const directory = context.directory ?? process.cwd();
+  const runId = resolved.runId ?? `opencode-${Date.now()}`;
+  const cliPrompt = resolved.cliPrompt ?? detectOpenCodeRunPrompt(process.argv);
+  const sink = createTraceSink({
+    directory,
+    ...resolved.daemonUrl ? { daemonUrl: resolved.daemonUrl } : {},
+    ...resolved.eventsFile ? { eventsFile: resolved.eventsFile } : {},
+    ...resolved.sink ? { sink: resolved.sink } : {}
+  });
+  const optimize = resolved.optimize ?? process.env.AGENT_BLACKBOX_OPTIMIZE === "1";
+  const factory = createOpenCodeEventFactory({
+    runId,
+    sink,
+    defaultSessionId: "unknown-session",
+    optimize,
+    ...resolved.homeDir ? { homeDir: resolved.homeDir } : {},
+    projectDir: resolved.projectDir ?? directory,
+    ...cliPrompt ? { cliPrompt } : {},
+    rawStored: resolved.rawStored ?? false
+  });
+  return {
+    event: async ({ event }) => {
+      await factory.writeEvent(event);
+    },
+    "tool.execute.before": async (input, output) => {
+      await factory.writeToolBefore(input, output);
+    },
+    "tool.execute.after": async (input, output) => {
+      await factory.writeToolAfter(input, output);
+    },
+    // In-run actuator (opt-in). A compaction means the agent may have lost content,
+    // so we reset the "still in context" generation; the system transform injects
+    // the working-set memory. Both no-op when optimize is off.
+    "experimental.session.compacting": async () => {
+      factory.onCompaction();
+    },
+    "experimental.chat.system.transform": async (_input, output) => {
+      factory.injectWorkingSet(output);
+    }
+  };
+}
+function createOpenCodePlugin(options = {}) {
+  return async (context) => createOpenCodeRecorder(context, options);
+}
+var AgentBlackboxOpenCode = createOpenCodePlugin();
+function createOpenCodeEventFactory(options) {
+  let seq = 0;
+  let cliPromptEmitted = false;
+  const subagentSessions = /* @__PURE__ */ new Map();
+  const readCache = /* @__PURE__ */ new Map();
+  const wsFiles = /* @__PURE__ */ new Map();
+  const wsCommands = [];
+  let compactionGen = 0;
+  const bumpFile = (path, kind, hash) => {
+    const f = wsFiles.get(path) ?? { path, reads: 0, edits: 0 };
+    if (kind === "read")
+      f.reads += 1;
+    else
+      f.edits += 1;
+    if (hash)
+      f.hash = hash;
+    wsFiles.set(path, f);
+  };
+  const optimizeReadAfter = (input, output) => {
+    const tool = input.tool;
+    const path = readArgPath(input.args);
+    if (isEditTool(tool) && path)
+      bumpFile(path, "edit");
+    if (isBashTool(tool)) {
+      const command = readString2(input.args, "command");
+      const exit = readExitCode(output);
+      if (command && isReusableCommand(command) && (exit === 0 || exit === void 0)) {
+        if (!wsCommands.includes(command))
+          wsCommands.push(command);
+      }
+    }
+    if (!isReadTool(tool) || !path)
+      return;
+    const current = typeof output.output === "string" ? output.output : "";
+    if (!current)
+      return;
+    const key = `${readString2(input, "sessionID") ?? "s"}::${path}`;
+    const hash = hashContent(current);
+    const decision = decideReadServe(readCache.get(key), { hash, content: current }, compactionGen, path);
+    readCache.set(key, { hash, content: current, gen: compactionGen });
+    bumpFile(path, "read", hash);
+    if (decision.mode !== "full" && typeof decision.output === "string") {
+      output.output = decision.output;
+    }
+  };
+  const attributeToSubagent = (event) => {
+    const owner = subagentSessions.get(event.sessionId);
+    if (!owner)
+      return event;
+    return {
+      ...event,
+      agentId: owner.agent,
+      agentRole: "subagent",
+      parentSessionId: event.parentSessionId ?? owner.parentId
+    };
+  };
+  const nextContext = () => {
+    seq += 1;
+    return {
+      runId: options.runId,
+      seq,
+      defaultSessionId: options.defaultSessionId,
+      ...options.homeDir ? { homeDir: options.homeDir } : {},
+      ...options.projectDir ? { projectDir: options.projectDir } : {},
+      rawStored: options.rawStored
+    };
+  };
+  return {
+    async writeEvent(rawEvent) {
+      const subagent = subagentSessionFromEvent(rawEvent);
+      if (subagent) {
+        subagentSessions.set(subagent.sessionId, { agent: subagent.agent, parentId: subagent.parentId });
+      }
+      if (!shouldRecordOpenCodeEvent(rawEvent)) {
+        return;
+      }
+      const event = attributeToSubagent(normalizeOpenCodeEvent(rawEvent, nextContext()));
+      await options.sink.write(event);
+      if (options.cliPrompt && !cliPromptEmitted && !subagent && event.kind === "session_created") {
+        cliPromptEmitted = true;
+        await options.sink.write(normalizeSyntheticUserPrompt(options.cliPrompt, event, nextContext()));
+      }
+    },
+    async writeToolBefore(input, output) {
+      await options.sink.write(attributeToSubagent(normalizeToolBefore(input, output, nextContext())));
+    },
+    async writeToolAfter(input, output) {
+      if (options.optimize)
+        optimizeReadAfter(input, output);
+      await options.sink.write(attributeToSubagent(normalizeToolAfter(input, output, nextContext())));
+    },
+    onCompaction() {
+      if (options.optimize)
+        compactionGen += 1;
+    },
+    injectWorkingSet(output) {
+      if (!options.optimize)
+        return;
+      const block = buildWorkingSetBlock([...wsFiles.values()], wsCommands);
+      if (!block)
+        return;
+      const system = output.system;
+      if (Array.isArray(system))
+        system.push(block);
+    }
+  };
+}
+function isEditTool(tool) {
+  return typeof tool === "string" && ["edit", "write", "patch", "multiedit", "apply_patch"].includes(tool.toLowerCase());
+}
+function isBashTool(tool) {
+  return typeof tool === "string" && ["bash", "shell", "sh", "run", "command"].includes(tool.toLowerCase());
+}
+function readString2(record, key) {
+  if (!record || typeof record !== "object")
+    return void 0;
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readExitCode(output) {
+  const direct = output.exitCode ?? output.exit;
+  if (typeof direct === "number")
+    return direct;
+  const meta = output.metadata;
+  if (meta && typeof meta === "object") {
+    const m = meta;
+    const v = m.exitCode ?? m.exit;
+    if (typeof v === "number")
+      return v;
+  }
+  return void 0;
+}
+function detectOpenCodeRunPrompt(argv) {
+  const runIndex = argv.indexOf("run");
+  const promptFlagIndex = argv.indexOf("--prompt");
+  if (promptFlagIndex >= 0 && argv[promptFlagIndex + 1]) {
+    return cleanCliPrompt(argv[promptFlagIndex + 1]);
+  }
+  if (runIndex < 0)
+    return void 0;
+  const valueFlags = /* @__PURE__ */ new Set([
+    "-m",
+    "--model",
+    "-s",
+    "--session",
+    "--dir",
+    "--port",
+    "--hostname",
+    "--log-level",
+    "--mdns-domain",
+    "--agent",
+    "--prompt"
+  ]);
+  const messageParts = [];
+  for (let index = runIndex + 1; index < argv.length; index += 1) {
+    const part = argv[index];
+    if (valueFlags.has(part)) {
+      index += 1;
+      continue;
+    }
+    if (part.startsWith("--"))
+      continue;
+    messageParts.push(part);
+  }
+  return cleanCliPrompt(messageParts.join(" "));
+}
+function cleanCliPrompt(value) {
+  const prompt = value?.trim();
+  if (!prompt)
+    return void 0;
+  return prompt.length > 2e3 ? `${prompt.slice(0, 1997)}...` : prompt;
+}
+
+// packages/opencode-adapter/dist/plugin-entry.js
+var AgentBlackbox = createOpenCodePlugin({
+  daemonUrl: process.env.AGENT_BLACKBOX_DAEMON_URL ?? "__ABB_DAEMON_URL__"
+});
+export {
+  AgentBlackbox
+};