opencode-multiagent 0.2.0 → 0.3.0-next.1

package/src/opencode-multiagent/mailbox.ts

@@ -1,287 +0,0 @@
-import { randomUUID } from "node:crypto";
-
-import { note } from "./log.ts";
-
-/** A single inter-agent message stored in the mailbox. */
-export type Message = {
-  id: string;
-  /** Sender sessionID or agent name. */
-  from: string;
-  /** Target sessionID or agent name (used as inbox key). */
-  to: string;
-  content: string;
-  timestamp: number;
-  read: boolean;
-  delivered: boolean;
-};
-
-/**
- * Minimal client interface required for mailbox delivery.
- *
- * Uses the typed SDK `session.prompt({ path, body })` single-object form.
- * Falls back to the runtime-only `session.promptAsync()` used elsewhere
- * in the plugin when the typed form is unavailable.
- */
-export type MailboxClient = {
-  session?: {
-    /**
-     * Typed SDK method — single-object form:
-     * `prompt({ path: { id }, body: { agent?, parts, noReply } })`
-     *
-     * `noReply: false` causes the LLM to process and act on the message.
-     * `noReply: true` injects silently (used for system-level notes only).
-     */
-    prompt?: (input: {
-      path: { id: string };
-      body: {
-        agent?: string;
-        parts: Array<{ type: string; text?: string; name?: string }>;
-        noReply?: boolean;
-      };
-    }) => Promise<unknown>;
-    /** Runtime-only method used in supervision/quality controllers. */
-    promptAsync?: (input: {
-      sessionID: string;
-      noReply?: boolean;
-      parts: Array<{ type: string; text: string }>;
-    }) => Promise<unknown>;
-  };
-};
-
-/**
- * Creates an in-memory mailbox for inter-agent messaging.
- *
- * Messages are keyed by the `to` field (target sessionID/name).
- * Delivery is attempted via `client.session.prompt({ path, body })` (preferred)
- * or `client.session.promptAsync()` (fallback).  Messages are delivered with
- * `noReply: false` so the receiving agent's LLM actively processes each message.
- *
- * @example
- * ```ts
- * const mailbox = createMailbox();
- * mailbox.send("lead-session-id", "worker-session-id", "Hello!");
- * await mailbox.deliverPending("worker-session-id", client);
- * ```
- */
-export const createMailbox = () => {
-  /** inbox keyed by sessionID (or agent name used as `to`) */
-  const messagesBySession = new Map<string, Message[]>();
-  /** all messages by ID for fast mutation */
-  const allMessages = new Map<string, Message>();
-
-  const getInbox = (sessionID: string): Message[] => {
-    if (!messagesBySession.has(sessionID)) messagesBySession.set(sessionID, []);
-    return messagesBySession.get(sessionID)!;
-  };
-
-  /**
-   * Enqueue a new message from `from` to `to`.
-   * The message is stored undelivered and unread.
-   */
-  const send = (from: string, to: string, content: string): Message => {
-    const msg: Message = {
-      id: randomUUID(),
-      from,
-      to,
-      content,
-      timestamp: Date.now(),
-      read: false,
-      delivered: false,
-    };
-    getInbox(to).push(msg);
-    allMessages.set(msg.id, msg);
-    return msg;
-  };
-
-  /** Return all unread messages for `sessionID`. */
-  const getUnread = (sessionID: string): Message[] =>
-    (messagesBySession.get(sessionID) ?? []).filter((m) => !m.read);
-
-  /** Return all messages (read + unread) for `sessionID`. */
-  const getAll = (sessionID: string): Message[] =>
-    [...(messagesBySession.get(sessionID) ?? [])];
-
-  /** Return messages that have not yet been delivered to the session. */
-  const getPending = (sessionID: string): Message[] =>
-    (messagesBySession.get(sessionID) ?? []).filter((m) => !m.delivered);
-
-  /** Mark a single message as read. */
-  const markRead = (messageID: string): void => {
-    const msg = allMessages.get(messageID);
-    if (msg) msg.read = true;
-  };
-
-  /** Mark a single message as delivered. */
-  const markDelivered = (messageID: string): void => {
-    const msg = allMessages.get(messageID);
-    if (msg) msg.delivered = true;
-  };
-
-  /**
-   * Attempt to deliver all pending messages for `sessionID` by
-   * injecting them into the target session via the OpenCode client.
-   *
-   * Uses `client.session.prompt({ path, body })` (typed SDK, preferred) with
-   * `noReply: false` so the receiving agent's LLM processes and acts on each
-   * message.  Falls back to `client.session.promptAsync()` when unavailable.
-   *
-   * Failed deliveries are silently skipped and retried on the next
-   * `session.idle` event for the target session.
-   *
-   * @returns The number of messages successfully delivered.
-   */
-  const deliverPending = async (sessionID: string, client: MailboxClient): Promise<number> => {
-    const pending = getPending(sessionID);
-    if (pending.length === 0) return 0;
-
-    const canDeliver = Boolean(client.session?.prompt ?? client.session?.promptAsync);
-    if (!canDeliver) return 0;
-
-    let delivered = 0;
-    for (const msg of pending) {
-      const text = `[opencode-multiagent mailbox] From: ${msg.from}\n${msg.content}`;
-      try {
-        if (client.session?.prompt) {
-          // noReply: false — the receiving agent processes and responds to the message.
-          await client.session.prompt({
-            path: { id: sessionID },
-            body: { parts: [{ type: "text", text }], noReply: false },
-          });
-        } else if (client.session?.promptAsync) {
-          await client.session.promptAsync({
-            sessionID,
-            noReply: false,
-            parts: [{ type: "text", text }],
-          });
-        }
-        markDelivered(msg.id);
-        delivered++;
-      } catch {
-        // Best-effort: skip failed deliveries, will retry on next idle event.
-      }
-    }
-    return delivered;
-  };
-
-  /**
-   * Send a lead-notification message when a child session completes.
-   * Enqueues the notification and attempts immediate delivery.
-   *
-   * @param childSessionID  The completed child session.
-   * @param parentSessionID The lead / parent session to notify.
-   * @param agentName       Optional agent name for the completion message.
-   * @param client          OpenCode client for delivery.
-   */
-  const notifyLeadOnCompletion = async (
-    childSessionID: string,
-    parentSessionID: string,
-    agentName: string | null,
-    client: MailboxClient,
-  ): Promise<void> => {
-    const agentLabel = agentName ? ` (agent: ${agentName})` : "";
-    const content =
-      `Child session ${childSessionID}${agentLabel} has completed. ` +
-      "Review its output and proceed with the next task.";
-    try {
-      send(childSessionID, parentSessionID, content);
-      const delivered = await deliverPending(parentSessionID, client);
-      await note("mailbox_lead_notify", {
-        observation: true,
-        childSessionID,
-        parentSessionID,
-        agentName,
-        delivered,
-      });
-    } catch {
-      // Best-effort notification; do not let delivery failure propagate.
-    }
-  };
-
-  /**
-   * Release all in-memory state for `sessionID`.
-   * Call this when a session is deleted to avoid memory leaks.
-   */
-  const cleanup = (sessionID: string): void => {
-    const msgs = messagesBySession.get(sessionID) ?? [];
-    for (const msg of msgs) allMessages.delete(msg.id);
-    messagesBySession.delete(sessionID);
-  };
-
-  return {
-    send,
-    getUnread,
-    getAll,
-    getPending,
-    markRead,
-    markDelivered,
-    deliverPending,
-    notifyLeadOnCompletion,
-    cleanup,
-  };
-};
-
-export type Mailbox = ReturnType<typeof createMailbox>;
-
-// ---------------------------------------------------------------------------
-// Event-hook integration helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Creates a mailbox event handler to be called from the plugin's `event()` hook.
- *
- * Handles two lifecycle events:
- * - `session.idle` → deliver any pending messages to the idle session.
- * - `session.deleted` → release mailbox state for the terminated session.
- *
- * For `session.deleted` on a child session it also notifies the parent (lead).
- *
- * @example Integration (in hooks.ts `event()` handler):
- * ```ts
- * const mailboxHandler = createMailboxEventHandler(mailbox, client, childInfo);
- * // …inside event():
- * await mailboxHandler(input.event);
- * ```
- */
-export const createMailboxEventHandler = (
-  mailbox: Mailbox,
-  client: MailboxClient,
-  /** Lookup function: given a childSessionID returns its parentSessionID + agentName or undefined. */
-  getChildInfo: (sessionID: string) => { parentID: string; agentName: string | null } | undefined,
-) => {
-  return async (event: { type?: string; properties?: unknown }): Promise<void> => {
-    const props = (event.properties ?? {}) as Record<string, unknown>;
-    const type = event.type ?? "";
-
-    if (type === "session.idle") {
-      const sessionID = typeof props.sessionID === "string" ? props.sessionID : undefined;
-      if (!sessionID) return;
-      const pending = mailbox.getPending(sessionID);
-      if (pending.length === 0) return;
-      await mailbox.deliverPending(sessionID, client);
-      await note("mailbox_idle_delivery", {
-        observation: true,
-        sessionID,
-        pending: pending.length,
-      });
-      return;
-    }
-
-    if (type === "session.deleted") {
-      const sessionID =
-        typeof (props.info as Record<string, unknown> | undefined)?.id === "string"
-          ? (props.info as Record<string, unknown>).id as string
-          : typeof props.sessionID === "string"
-            ? props.sessionID
-            : undefined;
-      if (!sessionID) return;
-
-      // Notify parent (lead) that this child finished before cleaning up.
-      const info = getChildInfo(sessionID);
-      if (info?.parentID) {
-        await mailbox.notifyLeadOnCompletion(sessionID, info.parentID, info.agentName, client);
-      }
-
-      mailbox.cleanup(sessionID);
-    }
-  };
-};

package/src/opencode-multiagent/markdown.ts

@@ -1,99 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import { join, resolve } from "node:path";
-
-import { clone } from "./utils.ts";
-
-type FrontmatterData = Record<string, unknown>;
-
-const unquote = (value: unknown): unknown => {
-  if (typeof value !== "string" || value.length < 2) return value;
-  const first = value[0];
-  const last = value[value.length - 1];
-  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-};
-
-const parseScalar = (value: string): unknown => {
-  const trimmed = value.trim();
-  if (trimmed === "") return "";
-  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-    return unquote(trimmed);
-  }
-  if (trimmed === "true") return true;
-  if (trimmed === "false") return false;
-  if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) return Number(trimmed);
-  return trimmed;
-};
-
-export function parseFrontmatter(value: string): { data: FrontmatterData; body: string } {
-  if (typeof value !== "string" || !value.startsWith("---")) {
-    return { data: {}, body: value };
-  }
-  const openingMatch = value.match(/^---\r?\n/);
-  if (!openingMatch) return { data: {}, body: value };
-  const rest = value.slice(openingMatch[0].length);
-  const closingIndex = rest.search(/\r?\n---(?:\r?\n|$)/);
-  if (closingIndex < 0) return { data: {}, body: value };
-  const rawFrontmatter = rest.slice(0, closingIndex);
-  const closingSlice = rest.slice(closingIndex);
-  const closingMatch = closingSlice.match(/^\r?\n---(?:\r?\n|$)/);
-  if (!closingMatch) return { data: {}, body: value };
-  const body = closingSlice.slice(closingMatch[0].length);
-  const data: FrontmatterData = {};
-  const stack: Array<{ indent: number; obj: FrontmatterData }> = [{ indent: -1, obj: data }];
-
-  for (const line of rawFrontmatter.split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    const indent = line.match(/^ */)?.[0].length ?? 0;
-    const trimmed = line.trim();
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex < 0) continue;
-    const key = String(unquote(trimmed.slice(0, colonIndex).trim()));
-    const rawValue = trimmed.slice(colonIndex + 1).trim();
-
-    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
-      stack.pop();
-    }
-
-    const parent = stack[stack.length - 1].obj;
-    if (rawValue === "") {
-      parent[key] = {};
-      stack.push({ indent, obj: parent[key] as FrontmatterData });
-      continue;
-    }
-
-    parent[key] = parseScalar(rawValue);
-  }
-
-  return { data, body };
-}
-
-export const readJSON = async <T>(path: string, fallback: T): Promise<T> => {
-  try {
-    return JSON.parse(await readFile(path, "utf8")) as T;
-  } catch {
-    return clone(fallback);
-  }
-};
-
-export const dedupe = (values: Array<string | undefined>): string[] =>
-  [...new Set(values.filter(Boolean).map((value) => resolve(value as string)))];
-
-export async function loadMarkdownDefs(dirs: Array<string | undefined>) {
-  const defs = new Map<string, { data: FrontmatterData; body: string; source: string }>();
-  for (const dir of dedupe(dirs)) {
-    const files = await readdir(dir).catch(() => []);
-    for (const file of files.filter((name) => name.endsWith(".md")).sort()) {
-      try {
-        const value = await readFile(join(dir, file), "utf8");
-        const { data, body } = parseFrontmatter(value);
-        defs.set(file.slice(0, -3), { data, body, source: join(dir, file) });
-      } catch {
-        // Ignore unreadable definitions.
-      }
-    }
-  }
-  return defs;
-}

package/src/opencode-multiagent/mcp.ts

@@ -1,35 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { packageRoot } from "./constants.ts";
-import { note } from "./log.ts";
-import { clone, own } from "./utils.ts";
-
-const defaultsFilePath = join(packageRoot, "defaults", "mcp-defaults.json");
-
-let cachedDefaults: Record<string, unknown> | undefined;
-
-export async function loadMcpDefaults(): Promise<Record<string, unknown>> {
-  if (cachedDefaults) return clone(cachedDefaults);
-  try {
-    const parsed = JSON.parse(await readFile(defaultsFilePath, "utf8")) as Record<string, unknown>;
-    cachedDefaults = parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    cachedDefaults = {};
-    await note("config_warning", {
-      observation: true,
-      warning: "mcp_defaults_unreadable",
-      path: defaultsFilePath,
-    });
-  }
-  return clone(cachedDefaults);
-}
-
-export function applyMcpDefaults(cfg: Record<string, unknown>, defaults: Record<string, unknown>): void {
-  if (!cfg.mcp || typeof cfg.mcp !== "object") cfg.mcp = {};
-  const mcp = cfg.mcp as Record<string, unknown>;
-  for (const [name, definition] of Object.entries(defaults ?? {})) {
-    if (own(mcp, name)) continue;
-    mcp[name] = clone(definition);
-  }
-}

package/src/opencode-multiagent/policy.ts

@@ -1,67 +0,0 @@
-import {
-  blockedPathFragments,
-  blockedPathPrefixRegex,
-  blockedPathSuffixes,
-  destructiveBashFragments,
-  experimentalText,
-  noteText,
-  sensitiveMentions,
-  suspiciousTerms,
-} from "./constants.ts";
-
-export { destructiveBashFragments, experimentalText, noteText };
-
-const normalize = (value: unknown): string => String(value ?? "").toLowerCase();
-
-const hasBlockedEnvName = (value: string): boolean => {
-  const name = value.split("/").pop() ?? "";
-  if (name === ".env.example") return false;
-  return name.endsWith(".env") || name.includes(".env.");
-};
-
-export const blocked = (value: unknown): boolean => {
-  const normalized = normalize(value);
-  return (
-    blockedPathPrefixRegex.test(normalized) ||
-    blockedPathFragments.some((fragment) => normalized.includes(fragment)) ||
-    blockedPathSuffixes.some((suffix) => normalized.endsWith(suffix)) ||
-    hasBlockedEnvName(normalized)
-  );
-};
-
-export const tokenizedBashBlocked = (command: unknown): boolean => {
-  const normalized = normalize(command).replace(/\s+/g, " ").trim();
-  if (normalized.length === 0) return false;
-
-  const forkBombPattern =
-    /(?:^|[;&|])\s*(?::|[a-z_][a-z0-9_]*)\s*\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;?\s*(?::|[a-z_][a-z0-9_]*)\s*(?:$|[;&|])/;
-  if (forkBombPattern.test(normalized)) return true;
-
-  const segments = normalized
-    .split(/&&|\||;/)
-    .map((segment) => segment.trim())
-    .filter(Boolean);
-
-  if (segments.some((segment) => destructiveBashFragments.some((fragment) => segment.includes(fragment)))) {
-    return true;
-  }
-
-  for (let index = 0; index < segments.length - 1; index += 1) {
-    if (!/^(curl|wget)(?:\s|$)/.test(segments[index]!)) continue;
-    if (/\b(?:bash|sh)\b/.test(segments[index + 1]!)) return true;
-  }
-
-  return false;
-};
-
-export const mentions = (value: string): boolean => sensitiveMentions.some((fragment) => value.includes(fragment));
-
-export const flagged = (value: string): string[] =>
-  suspiciousTerms.filter((term, index, list) => value.includes(term) && list.indexOf(term) === index);
-
-export const risky = (value: unknown): boolean => {
-  const lower = normalize(value);
-  return mentions(lower) || blocked(lower) || tokenizedBashBlocked(lower);
-};
-
-export const nextSyntheticId = (): string => `plugin-part-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;

package/src/opencode-multiagent/quality.ts

@@ -1,140 +0,0 @@
-import { qualityEventTypes, qualitySignalRegex } from "./constants.ts";
-import { note } from "./log.ts";
-
-const cleanupIntervalMs = 5 * 60 * 1000;
-const staleSessionTtlMs = 30 * 60 * 1000;
-const maxTrackedSessions = 200;
-const evictionFraction = 0.2;
-
-type SessionQualityState = {
-  editedFiles: Set<string>;
-  lastEditAt: number;
-  qualityRemindedAt: number;
-  lastQualityEvidenceAt: number;
-  lastActivityAt: number;
-};
-
-type PromptClient = {
-  session?: {
-    prompt?: (options: {
-      path: { id: string };
-      body?: { parts: Array<{ type: string; text: string }>; noReply?: boolean };
-    }) => Promise<unknown>;
-  };
-};
-
-export const createQualityController = ({ flags, client }: { flags: Record<string, any>; client: PromptClient }) => {
-  const sessionState = new Map<string, SessionQualityState>();
-
-  const getSessionState = (sessionID: string): SessionQualityState => {
-    if (!sessionState.has(sessionID)) {
-      sessionState.set(sessionID, {
-        editedFiles: new Set(),
-        lastEditAt: 0,
-        qualityRemindedAt: 0,
-        lastQualityEvidenceAt: 0,
-        lastActivityAt: Date.now(),
-      });
-    }
-    return sessionState.get(sessionID)!;
-  };
-
-  const cleanupStaleSessions = (now = Date.now()): void => {
-    for (const [sessionID, state] of sessionState.entries()) {
-      if (now - state.lastActivityAt > staleSessionTtlMs) sessionState.delete(sessionID);
-    }
-  };
-
-  const enforceSessionLimit = (): void => {
-    if (sessionState.size <= maxTrackedSessions) return;
-    const toRemove = [...sessionState.entries()]
-      .sort((left, right) => left[1].lastActivityAt - right[1].lastActivityAt)
-      .slice(0, Math.max(1, Math.ceil(sessionState.size * evictionFraction)));
-    for (const [sessionID] of toRemove) sessionState.delete(sessionID);
-  };
-
-  let interval: ReturnType<typeof setInterval> | null = null;
-  if (flags.quality_gate) {
-    interval = setInterval(() => cleanupStaleSessions(), cleanupIntervalMs);
-    interval.unref?.();
-  }
-
-  const trackEdit = (sessionID: string | undefined, filePath: string | undefined): void => {
-    if (!sessionID || !filePath) return;
-    const state = getSessionState(sessionID);
-    state.editedFiles.add(filePath);
-    state.lastEditAt = Date.now();
-    state.lastActivityAt = Date.now();
-    enforceSessionLimit();
-  };
-
-  const recordQualityEvidence = (sessionID: string | undefined, command: unknown): void => {
-    if (!sessionID || typeof command !== "string") return;
-    if (!qualitySignalRegex.test(command)) return;
-    const state = getSessionState(sessionID);
-    state.lastQualityEvidenceAt = Date.now();
-    state.lastActivityAt = Date.now();
-  };
-
-  const handleQualityEvent = async (event: { type?: string; properties?: any }): Promise<void> => {
-    if (!flags.quality_gate || !qualityEventTypes.has(event?.type ?? "")) return;
-    const props = event.properties ?? {};
-
-    if (event.type === "file.edited") {
-      const sessionID =
-        typeof props.sessionID === "string" ? props.sessionID : typeof props.info?.sessionID === "string" ? props.info.sessionID : undefined;
-      const file = typeof props.file === "string" ? props.file : typeof props.info?.file === "string" ? props.info.file : undefined;
-      trackEdit(sessionID, file);
-      return;
-    }
-
-    if (event.type === "session.idle") {
-      const sessionID = typeof props.sessionID === "string" ? props.sessionID : undefined;
-      if (!sessionID || !client?.session?.prompt) return;
-      const state = sessionState.get(sessionID);
-      if (!state || state.editedFiles.size === 0) return;
-      state.lastActivityAt = Date.now();
-      if (state.lastQualityEvidenceAt >= state.lastEditAt) return;
-      const now = Date.now();
-      const idleMs = flags.quality_config?.reminder_idle_ms ?? 120000;
-      const cooldownMs = flags.quality_config?.reminder_cooldown_ms ?? 300000;
-      if (now - state.lastEditAt < idleMs || now - state.qualityRemindedAt < cooldownMs) return;
-      state.qualityRemindedAt = now;
-      const files = [...state.editedFiles].slice(0, 6).join(", ");
-      const reminder =
-        "[opencode-multiagent quality] This session edited files and no later verification signal was observed. " +
-        "Run `/quality` or equivalent repo-native checks before treating the work as done." +
-        (files ? ` Tracked files: ${files}` : "");
-      try {
-        await client.session.prompt({
-          path: { id: sessionID },
-          body: { parts: [{ type: "text", text: reminder }], noReply: true },
-        });
-      } catch {
-        return;
-      }
-      await note("quality_gate", {
-        event: "idle_reminder",
-        sessionID,
-        files: [...state.editedFiles].slice(0, 12),
-      });
-      return;
-    }
-
-    if (event.type === "session.deleted") {
-      const sessionID = typeof props.info?.id === "string" ? props.info.id : typeof props.sessionID === "string" ? props.sessionID : undefined;
-      if (sessionID) sessionState.delete(sessionID);
-    }
-  };
-
-  return {
-    handleQualityEvent,
-    recordQualityEvidence,
-    trackEdit,
-    cleanup(): void {
-      if (!interval) return;
-      clearInterval(interval);
-      interval = null;
-    },
-  };
-};

package/src/opencode-multiagent/runtime.ts

@@ -1,55 +0,0 @@
-import {
-  agentSettingsPath,
-  bundledAgentSettingsPath,
-  defaultFlags,
-  defaultProfiles,
-  flagsPath,
-  profilesPath,
-} from "./constants.ts";
-import { readJSON } from "./markdown.ts";
-import { merge } from "./utils.ts";
-
-type GenericRecord = Record<string, unknown>;
-
-export const resolveTier = (value: unknown, modelTiers: Record<string, string>): unknown => {
-  if (typeof value !== "string" || !value.startsWith("$")) return value;
-  const key = value.slice(1);
-  return modelTiers[key] ?? value;
-};
-
-export const resolveAlias = resolveTier;
-
-export const resolveExistingTierReferences = (cfg: GenericRecord | undefined, modelTiers: Record<string, string>): void => {
-  if (!cfg || typeof cfg !== "object") return;
-  if (typeof cfg.model === "string") cfg.model = resolveTier(cfg.model, modelTiers);
-  if (typeof cfg.small_model === "string") cfg.small_model = resolveTier(cfg.small_model, modelTiers);
-
-  for (const item of Object.values((cfg.agent as GenericRecord | undefined) ?? {})) {
-    if (item && typeof item === "object" && typeof (item as GenericRecord).model === "string") {
-      (item as GenericRecord).model = resolveTier((item as GenericRecord).model, modelTiers);
-    }
-  }
-
-  for (const item of Object.values((cfg.command as GenericRecord | undefined) ?? {})) {
-    if (item && typeof item === "object" && typeof (item as GenericRecord).model === "string") {
-      (item as GenericRecord).model = resolveTier((item as GenericRecord).model, modelTiers);
-    }
-  }
-};
-
-export async function loadRuntimeSettings(): Promise<{
-  flags: typeof defaultFlags;
-  modelTiers: Record<string, string>;
-  agentSettings: GenericRecord;
-}> {
-  const defaultAgentSettings = await readJSON<GenericRecord>(bundledAgentSettingsPath, {});
-  const userFlags = await readJSON<Partial<typeof defaultFlags>>(flagsPath, {});
-  const userAgentSettings = await readJSON<GenericRecord>(agentSettingsPath, {});
-  const userProfiles = await readJSON<Partial<typeof defaultProfiles>>(profilesPath, {});
-  const profiles = merge(defaultProfiles, userProfiles);
-  const profileName = typeof userFlags.profile === "string" ? userFlags.profile : defaultFlags.profile;
-  const profile = profiles[profileName as keyof typeof profiles] ?? {};
-  const flags = merge(merge(defaultFlags, profile), userFlags);
-  const agentSettings = merge(defaultAgentSettings, userAgentSettings);
-  return { flags, modelTiers: {}, agentSettings };
-}