@bakers-build/conductor 0.0.0-stage → 0.1.0-next.42

package/dist/src/core/host-key.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Host stem for `bb_machine.host_key` — the one entity that carries the
+ * field. `bb_conductor` has none, and reading one off it is precisely what
+ * left the host gate with no input at all (BB-450 review B7). Prefer
+ * `config.host_key` from MachineContext.machine_id; fall back to a
+ * best-effort parse of the composed `conductor_id` only when the loader could
+ * not supply the stem.
+ *
+ * Shared by the `Conductor` registration payload and the lifecycle commands
+ * (`stop`/`start`), so both agree on "this machine's" host_key — the input
+ * `signalVerifiedProcess()` compares a record's `host_key` against (BB-450
+ * AC-4). Two callers computing this independently is exactly how a gate can
+ * end up with no input on one side and a different answer on the other.
+ */
+export declare function hostKeyOf(config: {
+    host_key?: string;
+    conductor_id?: string;
+    machine_id?: string;
+}): string;

package/dist/src/core/host-key.js

@@ -0,0 +1,27 @@
+/**
+ * Host stem for `bb_machine.host_key` — the one entity that carries the
+ * field. `bb_conductor` has none, and reading one off it is precisely what
+ * left the host gate with no input at all (BB-450 review B7). Prefer
+ * `config.host_key` from MachineContext.machine_id; fall back to a
+ * best-effort parse of the composed `conductor_id` only when the loader could
+ * not supply the stem.
+ *
+ * Shared by the `Conductor` registration payload and the lifecycle commands
+ * (`stop`/`start`), so both agree on "this machine's" host_key — the input
+ * `signalVerifiedProcess()` compares a record's `host_key` against (BB-450
+ * AC-4). Two callers computing this independently is exactly how a gate can
+ * end up with no input on one side and a different answer on the other.
+ */
+export function hostKeyOf(config) {
+    const fromConfig = config.host_key?.trim();
+    if (fromConfig)
+        return fromConfig;
+    const id = config.conductor_id ?? config.machine_id ?? '';
+    const parts = id.split('-');
+    if (parts.length >= 3 && parts[0] && parts[1]) {
+        const middle = parts.slice(1, -1).join('-');
+        if (middle)
+            return middle;
+    }
+    return id;
+}

package/dist/src/core/inbox-runtime.d.ts

@@ -0,0 +1,48 @@
+import type { ConductorLogger } from '@bakers-build/core';
+import { type MessageResult } from '@bakers-build/message';
+import type { LoadedInbox } from '../plugins/message.js';
+import type { BbRemote, InboxMessage, Ticket } from '../plugins/remote.js';
+import type { ActionQueue } from './action-queue.js';
+/** Per-handler timeout; the request's `signal` aborts after it. */
+export declare const HANDLER_TIMEOUT_MS = 60000;
+type Outcome = {
+    status: 'done';
+    result: MessageResult;
+} | {
+    status: 'failed';
+    result: MessageResult;
+};
+export declare class InboxRuntime {
+    private readonly addons;
+    private readonly remote;
+    private readonly logger;
+    private readonly env;
+    private readonly ids;
+    private registeredOk;
+    constructor(addons: LoadedInbox[], remote: BbRemote, logger: ConductorLogger, env: (ticket: Ticket) => Promise<Record<string, string>>);
+    /** Whether this conductor runs no contract-2 addon. */
+    get empty(): boolean;
+    /** Whether the last registration reached the server. */
+    get registered(): boolean;
+    /**
+     * Registers every loaded addon's contract-2 definition. An empty list is
+     * sent too, so a conductor that dropped its addons leaves every version it
+     * was listed on.
+     */
+    register(conductorId: string): Promise<void>;
+    /** The addon and message key a message names, if this conductor runs it. */
+    private target;
+    /** Runs the handler a message names. Never throws. */
+    handle(msg: InboxMessage): Promise<Outcome>;
+    /** Runs one handler with the timeout and validates its result. */
+    private run;
+}
+/** Answers one inbox message through the contract-2 runtime. Catches its own errors. */
+export declare function answerV2(remote: BbRemote, runtime: InboxRuntime, msg: InboxMessage, logger: ConductorLogger): Promise<void>;
+/**
+ * The tick step: enqueue every pending message this conductor handles on the
+ * action queue; the queue answers them. Catches its own errors so the tick
+ * continues.
+ */
+export declare function runInbox(remote: BbRemote, runtime: InboxRuntime, conductorId: string, logger: ConductorLogger, queue: ActionQueue): Promise<void>;
+export {};

package/dist/src/core/inbox-runtime.js

@@ -0,0 +1,180 @@
+// Contract-2 inbox dispatch (BB-661): one message, one handler, one
+// `{ markdown }` answer. `runInbox` is the tick step: it registers the
+// addon's messages and enqueues every pending inbox message this conductor
+// handles.
+import { existsSync } from 'node:fs';
+import { validateResult } from '@bakers-build/message';
+/** Per-handler timeout; the request's `signal` aborts after it. */
+export const HANDLER_TIMEOUT_MS = 60_000;
+const failed = (text) => ({
+    status: 'failed',
+    result: { markdown: text },
+});
+export class InboxRuntime {
+    addons;
+    remote;
+    logger;
+    env;
+    ids = new Map();
+    registeredOk = false;
+    constructor(addons, remote, logger, env) {
+        this.addons = addons;
+        this.remote = remote;
+        this.logger = logger;
+        this.env = env;
+    }
+    /** Whether this conductor runs no contract-2 addon. */
+    get empty() {
+        return this.addons.length === 0;
+    }
+    /** Whether the last registration reached the server. */
+    get registered() {
+        return this.registeredOk;
+    }
+    /**
+     * Registers every loaded addon's contract-2 definition. An empty list is
+     * sent too, so a conductor that dropped its addons leaves every version it
+     * was listed on.
+     */
+    async register(conductorId) {
+        const reg = await this.remote.registerAddons(conductorId, this.addons.map((a) => ({
+            name: a.name,
+            version: a.version,
+            contract: 2,
+            messages: a.messages,
+            ...(a.label !== undefined ? { label: a.label } : {}),
+            ...(a.icon !== undefined ? { icon: a.icon } : {}),
+        })));
+        this.registeredOk = true;
+        for (const a of reg.accepted)
+            this.ids.set(a.name, a.id);
+        for (const r of reg.rejected) {
+            this.logger.error({ addon: r.name, version: r.version, reason: r.error }, `addon ${r.name}@${r.version} rejected by the server: ${r.error}`);
+        }
+    }
+    /** The addon and message key a message names, if this conductor runs it. */
+    target(msg) {
+        const dot = msg.messageId.indexOf('.');
+        const addon = this.addons.find((a) => a.name === msg.messageId.slice(0, dot));
+        const key = msg.messageId.slice(dot + 1);
+        return dot > 0 && addon?.messages[key] && addon.handlers[key]
+            ? [addon, key]
+            : undefined;
+    }
+    /** Runs the handler a message names. Never throws. */
+    async handle(msg) {
+        const target = this.target(msg);
+        if (!target)
+            return failed(`no handler for message ${msg.messageId}`);
+        const [addon, key] = target;
+        try {
+            const ticket = await this.remote.getTicket(msg.ticketUuid);
+            if (!msg.worktreePath || !existsSync(msg.worktreePath)) {
+                return failed(`no worktree for ${ticket.identifier} on this machine`);
+            }
+            const result = await this.run(addon, key, ticket, msg);
+            return { status: 'done', result };
+        }
+        catch (err) {
+            return failed(err instanceof Error ? err.message : String(err));
+        }
+    }
+    /** Runs one handler with the timeout and validates its result. */
+    async run(addon, key, ticket, msg) {
+        const handler = addon.handlers[key];
+        if (!handler)
+            throw new Error(`no handler for ${key}`);
+        const worktreePath = msg.worktreePath ?? '';
+        const controller = new AbortController();
+        let timer;
+        const timeout = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+                reject(new Error(`timed out after ${HANDLER_TIMEOUT_MS / 1000}s`));
+                controller.abort();
+            }, HANDLER_TIMEOUT_MS);
+        });
+        try {
+            const result = await Promise.race([
+                handler({
+                    id: msg.id,
+                    messageType: msg.messageId,
+                    addonVersion: addon.version,
+                    requestedBy: msg.requestedBy ?? '',
+                    ticket,
+                    ...(Object.keys(msg.payload).length > 0
+                        ? { payload: msg.payload }
+                        : {}),
+                    worktreePath,
+                    env: await this.env(ticket),
+                    logger: this.logger,
+                    signal: controller.signal,
+                }),
+                timeout,
+            ]);
+            const valid = validateResult(result);
+            if (!valid.ok)
+                throw new Error(`invalid result: ${valid.errors.join('; ')}`);
+            return result;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/** One line per answer: status and a bounded prefix of the markdown. */
+function logAnswer(logger, msg, outcome) {
+    const line = `inbox message ${msg.messageId} ${outcome.status}`;
+    const meta = { id: msg.id, ticket: msg.ticketUuid };
+    if (outcome.status === 'failed')
+        logger.warn(meta, line);
+    else
+        logger.info(meta, line);
+}
+/** Answers one inbox message through the contract-2 runtime. Catches its own errors. */
+export async function answerV2(remote, runtime, msg, logger) {
+    try {
+        await remote.writeInboxResult(msg.id, 'running');
+        const outcome = await runtime.handle(msg);
+        try {
+            await remote.writeInboxResult(msg.id, outcome.status, outcome.result);
+        }
+        catch (err) {
+            await remote.writeInboxResult(msg.id, 'failed', {
+                markdown: `Could not store the result: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            throw err;
+        }
+        logAnswer(logger, msg, outcome);
+    }
+    catch (err) {
+        logger.error({ message: msg.messageId, id: msg.id, err: String(err) }, 'inbox message failed');
+    }
+}
+/**
+ * The tick step: enqueue every pending message this conductor handles on the
+ * action queue; the queue answers them. Catches its own errors so the tick
+ * continues.
+ */
+export async function runInbox(remote, runtime, conductorId, logger, queue) {
+    if (runtime.empty)
+        return;
+    try {
+        if (!runtime.registered)
+            await runtime.register(conductorId);
+        const snapshot = await remote.fetchInbox(conductorId);
+        for (const msg of snapshot.messages) {
+            const run = () => answerV2(remote, runtime, msg, logger);
+            const queued = queue.enqueue({
+                key: `message:${msg.id}`,
+                lane: msg.ticketUuid,
+                run,
+            });
+            if (queued) {
+                logger.info({ id: msg.id, ticket: msg.ticketUuid, payload: msg.payload }, `inbox message ${msg.messageId} received`);
+            }
+        }
+    }
+    catch (err) {
+        logger.error({ conductorId, err: String(err) }, 'inbox step failed');
+    }
+}

package/dist/src/core/mr-changes.d.ts

@@ -0,0 +1,18 @@
+import type { TicketMetric } from '../plugins/remote.js';
+/** The `mr_changes` measurement (skill definition `mr-changes.json`). */
+export interface MrChanges {
+    score: number;
+    files_changed: number;
+    additions: number;
+    deletions: number;
+}
+/** Sums `git diff --numstat` output; a binary file (`-`) counts as 0 lines. */
+export declare function parseNumstat(text: string): MrChanges;
+/** The fixed-format `bb_metric` rows, one shared `recorded`. */
+export declare function mrChangesRows(v: MrChanges, recorded: number): TicketMetric[];
+/**
+ * Measures the ticket branch checked out in `worktreePath` against the merge
+ * base with `origin/<baseBranch>` — the diff the merge request's Changes tab
+ * shows. `HEAD`, not the remote branch: a merge deletes the remote branch.
+ */
+export declare function measureMrChanges(worktreePath: string, baseBranch: string): Promise<MrChanges>;

package/dist/src/core/mr-changes.js

@@ -0,0 +1,47 @@
+import { exec } from '@bakers-build/core';
+/** Definition order and units of the `mr_changes` values. */
+const VALUES = [
+    ['score', 'lines'],
+    ['files_changed', 'count'],
+    ['additions', 'lines'],
+    ['deletions', 'lines'],
+];
+/** Sums `git diff --numstat` output; a binary file (`-`) counts as 0 lines. */
+export function parseNumstat(text) {
+    let additions = 0;
+    let deletions = 0;
+    let files = 0;
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        const [added = '', deleted = ''] = line.split('\t');
+        additions += Number(added) || 0;
+        deletions += Number(deleted) || 0;
+        files += 1;
+    }
+    return {
+        score: additions + deletions,
+        files_changed: files,
+        additions,
+        deletions,
+    };
+}
+/** The fixed-format `bb_metric` rows, one shared `recorded`. */
+export function mrChangesRows(v, recorded) {
+    return VALUES.map(([name, unit]) => ({
+        name: `mr_changes.${name}`,
+        value: v[name].toFixed(4),
+        unit,
+        recorded,
+    }));
+}
+/**
+ * Measures the ticket branch checked out in `worktreePath` against the merge
+ * base with `origin/<baseBranch>` — the diff the merge request's Changes tab
+ * shows. `HEAD`, not the remote branch: a merge deletes the remote branch.
+ */
+export async function measureMrChanges(worktreePath, baseBranch) {
+    await exec('git', ['fetch', 'origin', baseBranch], { cwd: worktreePath });
+    const out = await exec('git', ['diff', '--numstat', '-M', `origin/${baseBranch}...HEAD`], { cwd: worktreePath });
+    return parseNumstat(out);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export type * from '@bakers-build/core';
+export { conductorId } from '@bakers-build/core';
+export { BB_CONFIG_SCHEMA_VERSION, readConfigSchemaVersion, } from './cli/config-schema.js';
+export { type AddonRenameResult, type ConfigSurface, HOST_BARREL_PATHS, migrateAddonNames, migrateAddonNamesInFile, RENAMED_ADDONS, runAddonRenameMigration, } from './cli/migrate-addon-names.js';
+export { type BbCliDeps, default as conductorCommandPlugin, runConductorCli, } from './commands/conductor.js';
+export { composeConductorConfig, DEFAULT_AGENT_PROMPT, loadConductorConfig, resolveConfigPath, stripLegacyConnectionFromConfigSource, } from './config.js';
+export * from './contract.js';
+export { Conductor } from './core/conductor.js';

package/dist/src/index.js

@@ -0,0 +1,27 @@
+// BB-224: the conductor registry lives ONLY in `@bakers-build/core` — the former
+// thin re-export shim under `./cli/` is deleted and importers name core direct.
+export { conductorId } from '@bakers-build/core';
+// BB-216: the connection-config schema version + its regex reader. BB-230:
+// the host's `bakers config upgrade` intro prints the `from → to` pair from these.
+export { BB_CONFIG_SCHEMA_VERSION, readConfigSchemaVersion, } from './cli/config-schema.js';
+// BB-224 (Finding 8b): the addon package-name rename pass `bakers config upgrade` runs
+// as its last step (`@bakers-build/plugin-*` + the deleted `@bakers-build/core/builtins`
+// and `@bakers-build/core/plugins` → `@bakers-build/addon-*`).
+export { HOST_BARREL_PATHS, migrateAddonNames, migrateAddonNamesInFile, RENAMED_ADDONS, runAddonRenameMigration, } from './cli/migrate-addon-names.js';
+// BB-201: the conductor is now a COMMAND PLUGIN mounted by the `@bakers-build/bakers`
+// host, not the CLI entrypoint. `main`/`runBbCli` are gone; the default export
+// is the `BbCommandPlugin`, exposed here as `./commands/conductor` too.
+export { default as conductorCommandPlugin, runConductorCli, } from './commands/conductor.js';
+// BB-218: the balanced strip is exported for the host/tests + reuse.
+export { composeConductorConfig, DEFAULT_AGENT_PROMPT, loadConductorConfig, resolveConfigPath, stripLegacyConnectionFromConfigSource, } from './config.js';
+// BB-224 (Finding 6): this package now OWNS the conductor-surface contract —
+// the interfaces, the config types, the preset view and the slot selectors — and
+// re-exports the whole of it here. The runtime-light subpath
+// `@bakers-build/conductor/contract` is the one an ADDON should import (this main
+// entry pulls the engine + the command plugin). The built-in IMPLEMENTATIONS it
+// used to re-export from the deleted `@bakers-build/core/plugins` barrel now live in
+// their own addons (`@bakers-build/addon-remote-drupal`,
+// `@bakers-build/addon-workspace-git`, `@bakers-build/addon-fake`) and are deliberately NOT
+// re-exported: the engine must not edge an addon (acyclic layer rule).
+export * from './contract.js';
+export { Conductor } from './core/conductor.js';

package/dist/src/plugins/agent-args.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared validation and known-scalar override detection for harness `args`.
+ * Quote only at final command assembly with `shellQuote`; this helper returns
+ * a copied list of raw validated strings so override detection never has to
+ * decode shell quoting, and later mutation of the caller's array cannot
+ * introduce unvalidated switches.
+ */
+export type KnownScalarKind = 'model' | 'effort';
+export interface KnownOptionSpec {
+    kind: KnownScalarKind;
+    /** Long and short flags, e.g. `['--model', '-m']`. */
+    flags: readonly string[];
+    /** Codex `-c`/`--config` assignment keys, matched before the first `=`. */
+    configKeys?: readonly string[];
+}
+export interface KnownOverrides {
+    model: boolean;
+    effort: boolean;
+}
+/**
+ * Validate `args` (omitted → `[]`) and return a shallow copy of the raw
+ * strings. Rejects non-arrays, non-string members, NUL, tilde paths, and
+ * reserved flag forms.
+ */
+export declare function validateAgentArgs(args: unknown, reserved: readonly string[]): string[];
+export declare function validateOptionalString(value: unknown, field: string): string | undefined;
+export declare function validateOptionalBoolean(value: unknown, field: string): boolean | undefined;
+/**
+ * Detect whether `args` already carries a known model or effort option.
+ * Caller args are never removed, reordered, or normalized; this only
+ * suppresses bakers.build-generated defaults. Unknown flags stay literal.
+ */
+export declare function detectKnownOverrides(args: readonly string[], specs: readonly KnownOptionSpec[]): KnownOverrides;
+export declare function resolveAgentCliOptions(input: {
+    args?: unknown;
+    model?: unknown;
+    effort?: unknown;
+}, reserved: readonly string[], known: readonly KnownOptionSpec[]): {
+    args: string[];
+    model: string | undefined;
+    effort: string | undefined;
+    overrides: KnownOverrides;
+};

package/dist/src/plugins/agent-args.js

@@ -0,0 +1,221 @@
+/**
+ * Shared validation and known-scalar override detection for harness `args`.
+ * Quote only at final command assembly with `shellQuote`; this helper returns
+ * a copied list of raw validated strings so override detection never has to
+ * decode shell quoting, and later mutation of the caller's array cannot
+ * introduce unvalidated switches.
+ */
+const CONFIG_FLAGS = ['-c', '--config'];
+function isShortFlag(flag) {
+    return flag.startsWith('-') && !flag.startsWith('--');
+}
+function isReservedToken(token, reserved) {
+    if (token === reserved) {
+        return true;
+    }
+    if (token.startsWith(`${reserved}=`)) {
+        return true;
+    }
+    if (isShortFlag(reserved) &&
+        token.startsWith(reserved) &&
+        token.length > reserved.length &&
+        !token.startsWith('--')) {
+        return true;
+    }
+    return false;
+}
+function rejectTilde(value, label) {
+    if (value.startsWith('~')) {
+        throw new Error(`${label} starts with ~; use an absolute path`);
+    }
+    const eq = value.indexOf('=');
+    if (value.startsWith('--') &&
+        eq !== -1 &&
+        value.slice(eq + 1).startsWith('~')) {
+        throw new Error(`${label} assigns a path starting with ~; use an absolute path`);
+    }
+}
+function rejectReserved(value, reserved) {
+    for (const flag of reserved) {
+        if (isReservedToken(value, flag)) {
+            throw new Error(`args contains reserved flag ${flag}`);
+        }
+    }
+}
+function configAssignment(token) {
+    const eq = token.indexOf('=');
+    if (eq <= 0) {
+        return null;
+    }
+    return { key: token.slice(0, eq), value: token.slice(eq + 1) };
+}
+function matchFlag(token, flag) {
+    if (token === flag) {
+        return { flag };
+    }
+    if (token.startsWith(`${flag}=`)) {
+        return { flag, value: token.slice(flag.length + 1) };
+    }
+    if (isShortFlag(flag) &&
+        token.startsWith(flag) &&
+        token.length > flag.length &&
+        !token.startsWith('--')) {
+        const rest = token.slice(flag.length);
+        return {
+            flag,
+            value: rest.startsWith('=') ? rest.slice(1) : rest,
+        };
+    }
+    return null;
+}
+/**
+ * Validate `args` (omitted → `[]`) and return a shallow copy of the raw
+ * strings. Rejects non-arrays, non-string members, NUL, tilde paths, and
+ * reserved flag forms.
+ */
+export function validateAgentArgs(args, reserved) {
+    if (args === undefined) {
+        return [];
+    }
+    if (!Array.isArray(args)) {
+        throw new Error('args must be an array of strings');
+    }
+    const copy = [];
+    for (let i = 0; i < args.length; i++) {
+        const value = args[i];
+        if (typeof value !== 'string') {
+            throw new Error(`args[${i}] must be a string`);
+        }
+        if (value.includes('\0')) {
+            throw new Error(`args[${i}] contains a NUL byte`);
+        }
+        rejectReserved(value, reserved);
+        rejectTilde(value, `args[${i}]`);
+        copy.push(value);
+    }
+    return copy;
+}
+export function validateOptionalString(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`${field} must be a string`);
+    }
+    if (value.includes('\0')) {
+        throw new Error(`${field} contains a NUL byte`);
+    }
+    return value;
+}
+export function validateOptionalBoolean(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'boolean') {
+        throw new Error(`${field} must be a boolean`);
+    }
+    return value;
+}
+function kindForConfigKey(key, specs) {
+    for (const spec of specs) {
+        if (spec.configKeys?.includes(key)) {
+            return spec.kind;
+        }
+    }
+    return undefined;
+}
+function consumeConfig(token, next, specs) {
+    let assignment;
+    let consumed = 0;
+    for (const flag of CONFIG_FLAGS) {
+        if (token === flag) {
+            if (next === undefined) {
+                throw new Error(`${flag} requires a value`);
+            }
+            assignment = next;
+            consumed = 2;
+            break;
+        }
+        if (token.startsWith(`${flag}=`)) {
+            assignment = token.slice(flag.length + 1);
+            consumed = 1;
+            break;
+        }
+        if (isShortFlag(flag) &&
+            token.startsWith(flag) &&
+            token.length > flag.length &&
+            !token.startsWith('--')) {
+            const rest = token.slice(flag.length);
+            assignment = rest.startsWith('=') ? rest.slice(1) : rest;
+            consumed = 1;
+            break;
+        }
+    }
+    if (assignment === undefined) {
+        return null;
+    }
+    const parsed = configAssignment(assignment);
+    if (!parsed) {
+        return { consumed };
+    }
+    const kind = kindForConfigKey(parsed.key, specs);
+    return kind ? { kind, consumed } : { consumed };
+}
+/**
+ * Detect whether `args` already carries a known model or effort option.
+ * Caller args are never removed, reordered, or normalized; this only
+ * suppresses bakers.build-generated defaults. Unknown flags stay literal.
+ */
+export function detectKnownOverrides(args, specs) {
+    const overrides = { model: false, effort: false };
+    const usesConfig = specs.some((spec) => (spec.configKeys?.length ?? 0) > 0);
+    for (let i = 0; i < args.length; i++) {
+        const token = args[i];
+        if (token === undefined) {
+            continue;
+        }
+        if (usesConfig) {
+            const config = consumeConfig(token, args[i + 1], specs);
+            if (config) {
+                if (config.kind === 'model') {
+                    overrides.model = true;
+                }
+                if (config.kind === 'effort') {
+                    overrides.effort = true;
+                }
+                i += config.consumed - 1;
+                continue;
+            }
+        }
+        for (const spec of specs) {
+            for (const flag of spec.flags) {
+                const matched = matchFlag(token, flag);
+                if (!matched) {
+                    continue;
+                }
+                if (matched.value === undefined) {
+                    if (args[i + 1] === undefined) {
+                        throw new Error(`${flag} requires a value`);
+                    }
+                    i += 1;
+                }
+                if (spec.kind === 'model') {
+                    overrides.model = true;
+                }
+                if (spec.kind === 'effort') {
+                    overrides.effort = true;
+                }
+            }
+        }
+    }
+    return overrides;
+}
+export function resolveAgentCliOptions(input, reserved, known) {
+    const args = validateAgentArgs(input.args, reserved);
+    return {
+        args,
+        model: validateOptionalString(input.model, 'model'),
+        effort: validateOptionalString(input.effort, 'effort'),
+        overrides: detectKnownOverrides(args, known),
+    };
+}