maqcli 0.2.0

package/dist/core/interactive.js

@@ -0,0 +1,137 @@
+/**
+ * Interactive worker — the "steer a running worker" capability (CAO's live-PTY
+ * value) WITHOUT a mandatory native PTY dependency. It spawns a worker with a
+ * kept-open stdin pipe, streams stdout/stderr line-by-line as normalized
+ * events, infers a live status (starting → processing ⇄ idle → exited), and
+ * lets a caller `write()` follow-up input mid-task (inbox → stdin steering).
+ *
+ * Zero runtime deps (node:child_process). A full terminal-emulation PTY backend
+ * (node-pty) can be added later as an opt-in for CLIs that require a real TTY;
+ * this covers CLIs that read line-based stdin.
+ */
+import { spawn } from "node:child_process";
+import { makeEvent } from "./types.js";
+import { normalizeLine } from "../phases/execute.js";
+/** Heuristic: worker output that indicates the CLI needs the user to (re)login. */
+const LOGIN_RE = /\b(not logged in|please (log|sign)\s?in|login required|authenticate|unauthorized|session expired|invalid api key|run .*login|401 )\b/i;
+export class InteractiveWorker {
+    bin;
+    args;
+    child = null;
+    _status = "starting";
+    idleTimer = null;
+    outBuf = "";
+    errBuf = "";
+    idleMs;
+    opts;
+    exitResolve = null;
+    constructor(bin, args = [], opts = {}) {
+        this.bin = bin;
+        this.args = args;
+        this.opts = opts;
+        this.idleMs = opts.idleMs ?? 800;
+    }
+    get status() {
+        return this._status;
+    }
+    start() {
+        const child = spawn(this.bin, this.args, {
+            cwd: this.opts.cwd ?? process.cwd(),
+            env: this.opts.env ?? process.env,
+            shell: false,
+            windowsHide: true,
+        });
+        this.child = child;
+        this.setStatus("starting");
+        child.stdout.on("data", (d) => this.pump(d.toString(), "stdout"));
+        child.stderr.on("data", (d) => this.pump(d.toString(), "stderr"));
+        child.on("error", (e) => {
+            this.emit(makeEvent("agent.stderr", { text: String(e) }));
+            this.setStatus("exited");
+        });
+        child.on("close", (code) => {
+            if (this.outBuf)
+                this.emitLine(this.outBuf, "stdout");
+            if (this.errBuf)
+                this.emitLine(this.errBuf, "stderr");
+            if (this.idleTimer)
+                clearTimeout(this.idleTimer);
+            this.setStatus("exited");
+            this.exitResolve?.(code);
+        });
+    }
+    /** Steer the worker: send a line of input to its stdin. */
+    write(text) {
+        if (!this.child || this._status === "exited")
+            return false;
+        try {
+            this.child.stdin.write(text.endsWith("\n") ? text : text + "\n");
+            this.setStatus("processing");
+            this.armIdle();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Signal end-of-input (close stdin). */
+    end() {
+        try {
+            this.child?.stdin.end();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    kill() {
+        try {
+            this.child?.kill("SIGKILL");
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    /** Resolve when the process exits. */
+    wait() {
+        if (this._status === "exited")
+            return Promise.resolve(null);
+        return new Promise((resolve) => (this.exitResolve = resolve));
+    }
+    pump(chunk, which) {
+        this.setStatus("processing");
+        let buf = (which === "stdout" ? this.outBuf : this.errBuf) + chunk;
+        const parts = buf.split(/\r?\n/);
+        buf = parts.pop() ?? "";
+        if (which === "stdout")
+            this.outBuf = buf;
+        else
+            this.errBuf = buf;
+        for (const line of parts)
+            this.emitLine(line, which);
+        this.armIdle();
+    }
+    emitLine(line, which) {
+        if (LOGIN_RE.test(line)) {
+            this.emit(makeEvent("agent.event", { alert: "needs-login", hint: line.slice(0, 200) }));
+        }
+        this.emit(normalizeLine({ stream: which, line }));
+    }
+    armIdle() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => {
+            if (this._status === "processing")
+                this.setStatus("idle");
+        }, this.idleMs);
+    }
+    setStatus(s) {
+        if (this._status === s)
+            return;
+        this._status = s;
+        this.opts.onStatus?.(s);
+        this.emit(makeEvent("agent.event", { status: s }));
+    }
+    emit(e) {
+        this.opts.onEvent?.(e);
+    }
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,16 @@
+/** Minimal, dependency-free logger with level control and a quiet/JSON mode. */
+export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+export declare class Logger {
+    private level;
+    private json;
+    constructor(level?: LogLevel, json?: boolean);
+    setLevel(level: LogLevel): void;
+    private emit;
+    debug(msg: string, extra?: Record<string, unknown>): void;
+    info(msg: string, extra?: Record<string, unknown>): void;
+    warn(msg: string, extra?: Record<string, unknown>): void;
+    error(msg: string, extra?: Record<string, unknown>): void;
+    /** Structured, user-facing output goes to stdout (so it can be piped). */
+    out(line: string): void;
+}
+export declare const logger: Logger;

package/dist/core/logger.js

@@ -0,0 +1,46 @@
+/** Minimal, dependency-free logger with level control and a quiet/JSON mode. */
+const LEVELS = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    silent: 99,
+};
+export class Logger {
+    level;
+    json;
+    constructor(level = "info", json = false) {
+        this.level = LEVELS[level];
+        this.json = json;
+    }
+    setLevel(level) {
+        this.level = LEVELS[level];
+    }
+    emit(level, msg, extra) {
+        if (LEVELS[level] < this.level)
+            return;
+        if (this.json) {
+            process.stderr.write(JSON.stringify({ level, msg, ...extra }) + "\n");
+            return;
+        }
+        const prefix = level === "error" ? "x" : level === "warn" ? "!" : level === "debug" ? "." : "-";
+        process.stderr.write(`${prefix} ${msg}\n`);
+    }
+    debug(msg, extra) {
+        this.emit("debug", msg, extra);
+    }
+    info(msg, extra) {
+        this.emit("info", msg, extra);
+    }
+    warn(msg, extra) {
+        this.emit("warn", msg, extra);
+    }
+    error(msg, extra) {
+        this.emit("error", msg, extra);
+    }
+    /** Structured, user-facing output goes to stdout (so it can be piped). */
+    out(line) {
+        process.stdout.write(line + "\n");
+    }
+}
+export const logger = new Logger();

package/dist/core/memory.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Self-learning memory loop.
+ *
+ * When Verify fails, we append a short, structured lesson to the project's
+ * AGENTS.md (the convention worker CLIs read for standing instructions). Over
+ * repeated runs this becomes corrective guidance the worker sees up front, so
+ * the same failure is less likely to recur — the "headroom learn" idea from the
+ * product docs, implemented locally and dependency-free.
+ *
+ * It is intentionally conservative: it only ever appends, caps file growth, and
+ * never rewrites existing content.
+ */
+import type { PipelineResult } from "./types.js";
+export interface LessonInput {
+    task: string;
+    method: string;
+    details: string;
+    errors?: string[];
+}
+/** Format a single lesson block. */
+export declare function formatLesson(input: LessonInput): string;
+/**
+ * Append a lesson to AGENTS.md in `cwd`. Returns the path written, or null if
+ * skipped (e.g. file already at the size cap). Never throws.
+ */
+export declare function recordLesson(cwd: string, input: LessonInput): string | null;
+/** Convenience: learn from a completed pipeline result when it failed verify. */
+export declare function learnFromResult(cwd: string, result: PipelineResult): string | null;

package/dist/core/memory.js

@@ -0,0 +1,70 @@
+/**
+ * Self-learning memory loop.
+ *
+ * When Verify fails, we append a short, structured lesson to the project's
+ * AGENTS.md (the convention worker CLIs read for standing instructions). Over
+ * repeated runs this becomes corrective guidance the worker sees up front, so
+ * the same failure is less likely to recur — the "headroom learn" idea from the
+ * product docs, implemented locally and dependency-free.
+ *
+ * It is intentionally conservative: it only ever appends, caps file growth, and
+ * never rewrites existing content.
+ */
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const HEADER = "# AGENTS.md\n\nStanding notes for worker CLIs. MAQ appends lessons from failed verifications below.\n";
+const SECTION = "\n## MAQ — lessons from verification failures\n";
+const MAX_BYTES = 64 * 1024;
+/** Format a single lesson block. */
+export function formatLesson(input) {
+    const ts = new Date().toISOString();
+    const errs = (input.errors ?? []).filter(Boolean).slice(0, 3);
+    const lines = [
+        `\n### ${ts}`,
+        `- Task: ${clip(input.task, 200)}`,
+        `- Verification: ${clip(input.method, 120)} — ${clip(input.details, 300)}`,
+    ];
+    if (errs.length)
+        lines.push(`- Errors: ${errs.map((e) => clip(e, 200)).join(" | ")}`);
+    lines.push(`- Rule: re-check this path next time; add/adjust a test that would have caught it.`);
+    return lines.join("\n") + "\n";
+}
+/**
+ * Append a lesson to AGENTS.md in `cwd`. Returns the path written, or null if
+ * skipped (e.g. file already at the size cap). Never throws.
+ */
+export function recordLesson(cwd, input) {
+    try {
+        const path = join(cwd, "AGENTS.md");
+        if (!existsSync(path)) {
+            writeFileSync(path, HEADER + SECTION, "utf8");
+        }
+        else {
+            const cur = readFileSync(path, "utf8");
+            if (cur.length > MAX_BYTES)
+                return null;
+            if (!cur.includes(SECTION.trim()))
+                appendFileSync(path, SECTION, "utf8");
+        }
+        appendFileSync(path, formatLesson(input), "utf8");
+        return path;
+    }
+    catch {
+        return null;
+    }
+}
+/** Convenience: learn from a completed pipeline result when it failed verify. */
+export function learnFromResult(cwd, result) {
+    if (result.verify.verified)
+        return null;
+    return recordLesson(cwd, {
+        task: result.task,
+        method: result.verify.method,
+        details: result.verify.details,
+        errors: result.execute.errors,
+    });
+}
+function clip(s, n) {
+    const t = (s ?? "").replace(/\s+/g, " ").trim();
+    return t.length > n ? t.slice(0, n) + "…" : t;
+}

package/dist/core/metered.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Metering wrapper — records every master model call into a CostMeter without
+ * changing any caller. Wrap a provider before handing it to a phase and the
+ * pipeline gets end-to-end token/cost visibility (the "$0 / token-efficiency"
+ * story, made measurable rather than assumed).
+ */
+import type { ModelProvider } from "./model.js";
+import type { CostMeter } from "./cost.js";
+export declare function meteredProvider(inner: ModelProvider, meter: CostMeter): ModelProvider;

package/dist/core/metered.js

@@ -0,0 +1,16 @@
+/**
+ * Metering wrapper — records every master model call into a CostMeter without
+ * changing any caller. Wrap a provider before handing it to a phase and the
+ * pipeline gets end-to-end token/cost visibility (the "$0 / token-efficiency"
+ * story, made measurable rather than assumed).
+ */
+export function meteredProvider(inner, meter) {
+    return {
+        name: inner.name,
+        async complete(req) {
+            const res = await inner.complete(req);
+            meter.record(res.model, res.promptTokensEst, res.completionTokensEst);
+            return res;
+        },
+    };
+}

package/dist/core/model.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Model provider abstraction (LiteLLM-style single interface).
+ *
+ * All master-model calls (Scout summaries, Plan candidate generation, Verify
+ * review) go through one interface so the provider/model is swappable and cost
+ * is trackable. A "heuristic" provider is included so the whole pipeline runs
+ * fully offline with no API key — this is what makes the CLI verifiable and
+ * usable at $0, and doubles as the deterministic fallback.
+ */
+export type Role = "system" | "user" | "assistant";
+export interface Message {
+    role: Role;
+    content: string;
+}
+export interface CompletionRequest {
+    model: string;
+    messages: Message[];
+    maxTokens?: number;
+    /** Free-form tier hint the router can use: "cheap" | "strong". */
+    tier?: "cheap" | "strong";
+}
+export interface CompletionResponse {
+    text: string;
+    model: string;
+    provider: string;
+    promptTokensEst: number;
+    completionTokensEst: number;
+    /** Estimated USD cost for this call (0 for local/offline providers). */
+    costUsd?: number;
+}
+export interface ModelProvider {
+    readonly name: string;
+    complete(req: CompletionRequest): Promise<CompletionResponse>;
+}
+/**
+ * Deterministic, offline provider. It does not call any network. It produces
+ * structured, useful-enough output for the pipeline by pattern-matching on a
+ * lightweight instruction convention embedded in the system message:
+ *   - "MODE:plan"   -> emit 2-3 candidate approaches as a JSON array
+ *   - "MODE:verify" -> emit a pass/fail verdict as JSON
+ *   - otherwise     -> emit a concise summary of the user content
+ */
+export declare class HeuristicProvider implements ModelProvider {
+    readonly name = "heuristic";
+    complete(req: CompletionRequest): Promise<CompletionResponse>;
+    private summarize;
+    private planCandidates;
+    private verify;
+}
+/**
+ * Factory: returns a provider for the configured provider name.
+ *
+ * Recognized names (case-insensitive):
+ *   heuristic            -> offline deterministic provider (no network, $0)
+ *   openai               -> OpenAI (OPENAI_API_KEY, OPENAI_BASE_URL?)
+ *   anthropic            -> Anthropic Messages API (ANTHROPIC_API_KEY)
+ *   ollama               -> local Ollama native API (OLLAMA_HOST?)
+ *   groq                 -> Groq OpenAI-compatible (GROQ_API_KEY)
+ *   openai-compatible |
+ *   litellm              -> any OpenAI-compatible endpoint
+ *                           (MAQ_PROVIDER_BASE_URL, MAQ_PROVIDER_API_KEY)
+ *
+ * Missing credentials fall back to the heuristic provider so the pipeline
+ * always runs. Pass `strict: true` to throw instead (used by `maq models`).
+ */
+export declare function getProvider(name: string, opts?: {
+    strict?: boolean;
+}): ModelProvider;
+/**
+ * RouteLLM-style tier hint: cheap for triage/scout/verify, strong for the hard
+ * plan/exec step. Kept trivial and deterministic here; a trained router slots
+ * in behind this signature later.
+ */
+export declare function routeTier(complexity: "trivial" | "standard" | "complex"): "cheap" | "strong";

package/dist/core/model.js

@@ -0,0 +1,199 @@
+/**
+ * Model provider abstraction (LiteLLM-style single interface).
+ *
+ * All master-model calls (Scout summaries, Plan candidate generation, Verify
+ * review) go through one interface so the provider/model is swappable and cost
+ * is trackable. A "heuristic" provider is included so the whole pipeline runs
+ * fully offline with no API key — this is what makes the CLI verifiable and
+ * usable at $0, and doubles as the deterministic fallback.
+ */
+import { OpenAICompatibleProvider, AnthropicProvider, OllamaProvider, CliProvider } from "./providers.js";
+import { detectAgents, agentSpec } from "./registry.js";
+import { execSafe } from "./exec.js";
+function estTokens(s) {
+    return Math.ceil(s.length / 4);
+}
+/**
+ * Deterministic, offline provider. It does not call any network. It produces
+ * structured, useful-enough output for the pipeline by pattern-matching on a
+ * lightweight instruction convention embedded in the system message:
+ *   - "MODE:plan"   -> emit 2-3 candidate approaches as a JSON array
+ *   - "MODE:verify" -> emit a pass/fail verdict as JSON
+ *   - otherwise     -> emit a concise summary of the user content
+ */
+export class HeuristicProvider {
+    name = "heuristic";
+    async complete(req) {
+        const sys = req.messages.find((m) => m.role === "system")?.content ?? "";
+        const user = req.messages.filter((m) => m.role === "user").map((m) => m.content).join("\n");
+        let text;
+        if (sys.includes("MODE:plan")) {
+            text = JSON.stringify(this.planCandidates(user));
+        }
+        else if (sys.includes("MODE:verify")) {
+            text = JSON.stringify(this.verify(user));
+        }
+        else {
+            text = this.summarize(user);
+        }
+        const prompt = req.messages.map((m) => m.content).join("\n");
+        return {
+            text,
+            model: req.model,
+            provider: this.name,
+            promptTokensEst: estTokens(prompt),
+            completionTokensEst: estTokens(text),
+        };
+    }
+    summarize(text) {
+        const firstLine = text.split(/\r?\n/).find((l) => l.trim().length > 0) ?? "";
+        return firstLine.slice(0, 240).trim();
+    }
+    planCandidates(task) {
+        // The plan prompt embeds several lines; pull out the actual task line.
+        const taskLine = task.split(/\r?\n/).find((l) => /^task:/i.test(l.trim()))?.replace(/^task:\s*/i, "") ?? task;
+        const t = taskLine.replace(/\s+/g, " ").trim();
+        return [
+            {
+                summary: `Direct approach: implement "${t.slice(0, 80)}" with the smallest change set`,
+                steps: [
+                    "Identify the exact file(s) to change from scout findings",
+                    "Apply the minimal change",
+                    "Run the project's tests",
+                ],
+            },
+            {
+                summary: `Isolated approach: implement via a new, separately-testable module`,
+                steps: [
+                    "Create a new module for the change",
+                    "Wire it into the existing entry point",
+                    "Add focused tests, then run the suite",
+                ],
+            },
+            {
+                summary: `Refactor-first approach: clean the surrounding seam, then implement`,
+                steps: [
+                    "Extract the affected logic to a clear boundary",
+                    "Implement the change against the new boundary",
+                    "Run tests and lint",
+                ],
+            },
+        ];
+    }
+    verify(diffOrLog) {
+        const s = diffOrLog.toLowerCase();
+        const failed = /\b(error|failed|exception|traceback|not ok|fatal)\b/.test(s);
+        return failed
+            ? { pass: false, reason: "output contains failure signals" }
+            : { pass: true, reason: "no failure signals detected in output" };
+    }
+}
+/**
+ * Factory: returns a provider for the configured provider name.
+ *
+ * Recognized names (case-insensitive):
+ *   heuristic            -> offline deterministic provider (no network, $0)
+ *   openai               -> OpenAI (OPENAI_API_KEY, OPENAI_BASE_URL?)
+ *   anthropic            -> Anthropic Messages API (ANTHROPIC_API_KEY)
+ *   ollama               -> local Ollama native API (OLLAMA_HOST?)
+ *   groq                 -> Groq OpenAI-compatible (GROQ_API_KEY)
+ *   openai-compatible |
+ *   litellm              -> any OpenAI-compatible endpoint
+ *                           (MAQ_PROVIDER_BASE_URL, MAQ_PROVIDER_API_KEY)
+ *
+ * Missing credentials fall back to the heuristic provider so the pipeline
+ * always runs. Pass `strict: true` to throw instead (used by `maq models`).
+ */
+export function getProvider(name, opts = {}) {
+    const key = (name || "heuristic").toLowerCase();
+    const timeoutMs = envNum("MAQ_MODEL_TIMEOUT_MS", 60000);
+    const maxRetries = envNum("MAQ_MODEL_RETRIES", 3);
+    // CLI-as-provider: "cli:<agent>" reuses an authenticated worker CLI as the
+    // master's model at $0 marginal cost.
+    if (key.startsWith("cli")) {
+        const agentName = key.includes(":") ? key.slice(key.indexOf(":") + 1) : "";
+        const spec = agentSpec(agentName);
+        const agents = detectAgents();
+        const found = agents.find((a) => a.name === agentName);
+        if (!agentName || !spec || !spec.headless || !found?.binPath) {
+            return fallback(key, `CLI agent '${agentName}' not available/authenticated`, opts.strict);
+        }
+        const runner = async (bin, args) => {
+            const o = await execSafe(bin, args, { timeoutMs });
+            return { code: o.code, stdout: o.stdout, stderr: o.stderr };
+        };
+        return new CliProvider(agentName, found.binPath, spec.headless, runner, timeoutMs);
+    }
+    switch (key) {
+        case "heuristic":
+        case "offline":
+            return new HeuristicProvider();
+        case "openai": {
+            const apiKey = process.env.OPENAI_API_KEY;
+            if (!apiKey)
+                return fallback("openai", "OPENAI_API_KEY not set", opts.strict);
+            return new OpenAICompatibleProvider("openai", {
+                baseUrl: process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+                apiKey,
+                timeoutMs,
+                maxRetries,
+            });
+        }
+        case "anthropic": {
+            const apiKey = process.env.ANTHROPIC_API_KEY;
+            if (!apiKey)
+                return fallback("anthropic", "ANTHROPIC_API_KEY not set", opts.strict);
+            return new AnthropicProvider({
+                baseUrl: process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com/v1",
+                apiKey,
+                timeoutMs,
+                maxRetries,
+            });
+        }
+        case "groq": {
+            const apiKey = process.env.GROQ_API_KEY;
+            if (!apiKey)
+                return fallback("groq", "GROQ_API_KEY not set", opts.strict);
+            return new OpenAICompatibleProvider("groq", {
+                baseUrl: process.env.GROQ_BASE_URL ?? "https://api.groq.com/openai/v1",
+                apiKey,
+                timeoutMs,
+                maxRetries,
+            });
+        }
+        case "ollama":
+            return new OllamaProvider({ timeoutMs: envNum("MAQ_MODEL_TIMEOUT_MS", 120000), maxRetries });
+        case "openai-compatible":
+        case "litellm":
+        case "proxy": {
+            const baseUrl = process.env.MAQ_PROVIDER_BASE_URL ?? process.env.LITELLM_BASE_URL;
+            if (!baseUrl)
+                return fallback(key, "MAQ_PROVIDER_BASE_URL not set", opts.strict);
+            return new OpenAICompatibleProvider(key, {
+                baseUrl,
+                apiKey: process.env.MAQ_PROVIDER_API_KEY ?? process.env.LITELLM_API_KEY,
+                timeoutMs,
+                maxRetries,
+            });
+        }
+        default:
+            return fallback(key, `unknown provider '${name}'`, opts.strict);
+    }
+}
+function fallback(name, reason, strict) {
+    if (strict)
+        throw new Error(`provider '${name}' unavailable: ${reason}`);
+    return new HeuristicProvider();
+}
+function envNum(name, dflt) {
+    const v = Number(process.env[name]);
+    return Number.isFinite(v) && v > 0 ? v : dflt;
+}
+/**
+ * RouteLLM-style tier hint: cheap for triage/scout/verify, strong for the hard
+ * plan/exec step. Kept trivial and deterministic here; a trained router slots
+ * in behind this signature later.
+ */
+export function routeTier(complexity) {
+    return complexity === "complex" ? "strong" : "cheap";
+}

package/dist/core/pipeline.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pipeline orchestrator: Scout -> Plan -> Execute -> Verify.
+ *
+ * The cost/quality dial lives here: trivial tasks skip Scout+Plan and go
+ * straight to a minimal Execute; standard/complex tasks run the full pipeline.
+ * Every phase transition emits a normalized event so a UI can render progress
+ * uniformly regardless of which worker CLI runs underneath.
+ */
+import type { MaqEvent, PipelineResult } from "./types.js";
+import { agentSpec } from "./registry.js";
+export interface PipelineOptions {
+    cwd?: string;
+    target?: string;
+    dryRun?: boolean;
+    /** Sink for progress events (defaults to collecting only). */
+    onEvent?: (e: MaqEvent) => void;
+    timeoutMs?: number;
+    /** Abort signal; when aborted, in-flight worker processes are killed. */
+    signal?: AbortSignal;
+    /**
+     * Cooperative control checkpoint, awaited at every phase boundary. It should
+     * reject (to abort the run) when cancelled, and stay pending while paused.
+     */
+    checkpoint?: () => Promise<void>;
+    /** Ad-hoc provider override (else config.provider). */
+    provider?: string;
+    /** Ad-hoc model override applied to both tiers (else config tier models). */
+    model?: string;
+    /** Write run artifacts + a hash-chained audit log under .maq/runs/<id>. */
+    audit?: boolean;
+}
+export declare function runPipeline(task: string, opts?: PipelineOptions): Promise<PipelineResult>;
+export { agentSpec };