autodev-cli 1.4.190 → 1.4.192

package/out/pendingSteers.d.ts

@@ -0,0 +1,28 @@
+export interface PendingSteer {
+    /** A2A delivery id — the dedup key (a reconnect-replay carries the same id). */
+    id: string;
+    /** The steer text (already trimmed / attachment-folded by the caller). */
+    text: string;
+    /** Enqueue time (ms since epoch). */
+    ts: number;
+}
+export declare const PENDING_STEERS_FILE = ".autodev/pending-steers.jsonl";
+/**
+ * Read + parse the queue, deduped by id (last write wins), skipping any malformed
+ * / partially-written lines. Returns [] when the file is absent. PURE read.
+ */
+export declare function readPendingSteers(root: string): PendingSteer[];
+/** True if a steer with this id is already queued. */
+export declare function hasPendingSteer(root: string, id: string): boolean;
+/**
+ * Append a steer to the queue unless one with the same id is already present
+ * (dedup). Returns true if it was newly enqueued, false if it was a duplicate
+ * (or could not be written). Best-effort; a write failure is swallowed.
+ */
+export declare function enqueuePendingSteer(root: string, steer: PendingSteer): boolean;
+/**
+ * Remove the steer with this id from the queue by rewriting the file without it.
+ * Best-effort. When the queue becomes empty the file is left as an empty file
+ * (readPendingSteers treats it as []).
+ */
+export declare function removePendingSteer(root: string, id: string): void;

package/out/pendingSteers.js

@@ -0,0 +1,145 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Durable steer queue — `.autodev/pending-steers.jsonl`.
+//
+// A mid-run STEER delivered to a persistent ACP process (grok / opencode) used to
+// be acked (marked seen server-side) the MOMENT it was handed to the process. If
+// the loop/session restarted BEFORE that steered turn actually ran, the steer was
+// silently LOST (the office had already stopped re-delivering it). This queue makes
+// steers survive a restart with AT-LEAST-ONCE delivery:
+//
+//   • A steer is APPENDED here BEFORE it is acked.
+//   • The server ack (onDelivered) + local removal fire only AFTER the steered turn
+//     COMPLETES — never merely on hand-off to the process.
+//   • On (re)start the loop DRAINS this file, re-delivering each queued steer to the
+//     live AcpSession as a loop-tracked turn, removing it only on completion.
+//   • Dedup is by `id` (the A2A delivery id): a server reconnect-replay of a still-
+//     queued steer, or one already completed, is a no-op.
+//
+// Deliberately NOT TODO.md: grok rewrites TODO.md mid-turn (taskLoop.ts:1212-1218)
+// and would clobber an appended steer. This is a separate, append-only journal.
+//
+// One loop process owns a given root, so plain sync fs (append + rewrite) is safe;
+// malformed / partially-written lines are skipped on read so a torn append (a kill
+// mid-write) never poisons the queue.
+// ---------------------------------------------------------------------------
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PENDING_STEERS_FILE = void 0;
+exports.readPendingSteers = readPendingSteers;
+exports.hasPendingSteer = hasPendingSteer;
+exports.enqueuePendingSteer = enqueuePendingSteer;
+exports.removePendingSteer = removePendingSteer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.PENDING_STEERS_FILE = '.autodev/pending-steers.jsonl';
+function filePath(root) {
+    return path.join(root, exports.PENDING_STEERS_FILE);
+}
+/**
+ * Read + parse the queue, deduped by id (last write wins), skipping any malformed
+ * / partially-written lines. Returns [] when the file is absent. PURE read.
+ */
+function readPendingSteers(root) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath(root), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const byId = new Map();
+    for (const line of raw.split('\n')) {
+        const t = line.trim();
+        if (!t) {
+            continue;
+        }
+        let obj;
+        try {
+            obj = JSON.parse(t);
+        }
+        catch {
+            continue;
+        } // torn / bad line → skip
+        const o = obj;
+        if (!o || typeof o.id !== 'string' || typeof o.text !== 'string') {
+            continue;
+        }
+        byId.set(o.id, { id: o.id, text: o.text, ts: typeof o.ts === 'number' ? o.ts : Date.now() });
+    }
+    // Preserve first-seen order (Map keeps insertion order; last-value wins but the
+    // key's position is its first insertion, which is the delivery order we want).
+    return [...byId.values()];
+}
+/** True if a steer with this id is already queued. */
+function hasPendingSteer(root, id) {
+    return readPendingSteers(root).some((s) => s.id === id);
+}
+/**
+ * Append a steer to the queue unless one with the same id is already present
+ * (dedup). Returns true if it was newly enqueued, false if it was a duplicate
+ * (or could not be written). Best-effort; a write failure is swallowed.
+ */
+function enqueuePendingSteer(root, steer) {
+    if (hasPendingSteer(root, steer.id)) {
+        return false;
+    }
+    try {
+        fs.mkdirSync(path.dirname(filePath(root)), { recursive: true });
+        fs.appendFileSync(filePath(root), JSON.stringify(steer) + '\n', 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove the steer with this id from the queue by rewriting the file without it.
+ * Best-effort. When the queue becomes empty the file is left as an empty file
+ * (readPendingSteers treats it as []).
+ */
+function removePendingSteer(root, id) {
+    const remaining = readPendingSteers(root).filter((s) => s.id !== id);
+    try {
+        if (remaining.length === 0) {
+            fs.writeFileSync(filePath(root), '', 'utf8');
+        }
+        else {
+            fs.writeFileSync(filePath(root), remaining.map((s) => JSON.stringify(s)).join('\n') + '\n', 'utf8');
+        }
+    }
+    catch { /* ignore */ }
+}
+//# sourceMappingURL=pendingSteers.js.map

package/out/pendingSteers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingSteers.js","sourceRoot":"","sources":["../src/pendingSteers.ts"],"names":[],"mappings":"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"}

package/out/providers/acp/AcpSession.d.ts

@@ -0,0 +1,197 @@
+/** Callbacks the host injects so hook emission + redaction stay in one place. */
+export interface AcpHostHooks {
+    /** Emit ONE hook event (host adds redaction + provider tagging). */
+    emitHook(name: string, extra: Record<string, unknown>): void;
+    /** Human log line. */
+    log(msg: string): void;
+}
+export interface AcpTurnResult {
+    clean: boolean;
+    stopReason: string;
+    error?: string;
+    /** True when the turn ended clean but produced NO assistant text / tool calls
+     *  (e.g. an unusable model). Lets the host surface a clear log instead of
+     *  silently spinning. */
+    emptyOutput?: boolean;
+}
+/** A decoded session/update notification (pure; unit-tested). */
+export type AcpUpdate = {
+    kind: 'assistant';
+    text: string;
+} | {
+    kind: 'reasoning';
+    text: string;
+} | {
+    kind: 'tool_call';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    kind: 'tool_result';
+    id: string;
+    outputText: string;
+    status: string;
+} | {
+    kind: 'other';
+};
+/** Provider-specific launch + decode configuration. */
+export interface AcpLaunchSpec {
+    /** Build the argv (after the binary) for `spawn`. */
+    buildArgs(model: string | undefined, extraArgs: string[]): string[];
+    /** Decode a raw JSON-RPC session/update into an AcpUpdate. Defaults to the
+     *  standard-ACP decoder (`decodeAcpUpdateStandard`). */
+    decodeUpdate?: (msg: unknown) => AcpUpdate;
+    /** Title attached to narration (Notification) hooks. */
+    narrationTitle: string;
+    /** Forward agent_thought_chunk as narration too (default false). */
+    narrateReasoning?: boolean;
+}
+/**
+ * STANDARD-ACP decoder (opencode, and the generic default). Handles the ACP-spec
+ * session/update shapes:
+ *   agent_message_chunk {content:{type:'text',text}}       -> assistant
+ *   agent_thought_chunk {content:{type:'text',text}}       -> reasoning
+ *   tool_call           {toolCallId,title,rawInput}        -> tool_call (name=title)
+ *   tool_call_update    {toolCallId,status,content|rawOutput} -> tool_result
+ * Anything else (available_commands_update, usage_update, plan, …) -> other. PURE.
+ */
+export declare function decodeAcpUpdateStandard(msg: unknown): AcpUpdate;
+/** Best-effort flatten of a tool_call_update's output into a short string. PURE. */
+export declare function extractToolOutput(u: Record<string, unknown>): string;
+/**
+ * Classify a session/prompt RESULT into clean-vs-error for the exit file. PURE.
+ * - end_turn / max_tokens / max_turn_requests → clean (exit 0)
+ * - cancelled → clean (an intentional interrupt, not a failure)
+ * - a JSON-RPC error, or any other stopReason → error (exit 1)
+ */
+export declare function classifyAcpResult(result: {
+    result?: {
+        stopReason?: string;
+    };
+    error?: {
+        message?: string;
+    };
+}): AcpTurnResult;
+/**
+ * One persistent ACP process for a workspace root. Not a singleton — the host
+ * keeps a Map<root, AcpSession> and reuses it. Provider behaviour is injected via
+ * the `spec`.
+ */
+export declare class AcpSession {
+    protected readonly root: string;
+    protected readonly model: string | undefined;
+    protected readonly bin: string;
+    protected readonly hooks: AcpHostHooks;
+    protected readonly extraArgs: string[];
+    protected readonly spec: AcpLaunchSpec;
+    /** Extra env vars merged into the child's environment (e.g. OPENCODE_CONFIG). */
+    protected readonly extraEnv: Record<string, string>;
+    private readonly _decode;
+    private child;
+    private buf;
+    private nextId;
+    private readonly pending;
+    private _sessionId;
+    private _wantSessionId;
+    private _ready;
+    private _busy;
+    private _startCount;
+    private earlyStderr;
+    /** True WHILE session/load is replaying prior history — every session/update
+     *  during the replay is dropped (emits ZERO hooks) so a (re)start never
+     *  re-spams historical narration + tool_calls to the office feed (Layer A.1). */
+    private _loading;
+    /** The active PRIMARY turn's stdout sink (assistant text). Null between turns. */
+    private _sink;
+    /** Tool-call names by id, so a tool_result can carry the originating name. */
+    private readonly _toolNames;
+    /** Accumulates assistant chunks so Notification hooks are line-granular. */
+    private _narrationBuf;
+    /** The current tool activity label (set on tool_call, cleared on result). */
+    private _activity;
+    /** Did the active turn produce ANY assistant text or tool call? (empty-turn guard) */
+    private _turnHadOutput;
+    /** ALL outstanding session/prompt promises — the primary turn AND any steered
+     *  (queued) continuation prompts. The turn is not "done" until this drains, so
+     *  the loop keeps the agent WORKING through steers instead of going idle while
+     *  the agent runs an untracked queued turn (Bug A). */
+    private readonly _inflight;
+    constructor(opts: {
+        root: string;
+        model?: string;
+        bin: string;
+        hooks: AcpHostHooks;
+        spec: AcpLaunchSpec;
+        initialSessionId?: string;
+        extraArgs?: string[];
+        extraEnv?: Record<string, string>;
+    });
+    /** Per-turn watchdog budget (ms). Env: AUTODEV_ACP_MAX_RUN_MS, else GROK_MAX_RUN_MS
+     *  (parity with the headless path), else 20 minutes. A 0/negative value disables. */
+    static maxRunMs(): number;
+    get pid(): number | undefined;
+    get sessionId(): string | undefined;
+    get activity(): string | undefined;
+    /** Busy while the primary turn is running OR any steered/queued prompt is still
+     *  in-flight — so the loop never treats the agent as idle mid-queue (Bug A). */
+    isBusy(): boolean;
+    isAlive(): boolean;
+    /** Spawn + initialize + session/new|load, once. Respawns transparently if dead. */
+    ensureReady(): Promise<void>;
+    private _startup;
+    private _spawnChild;
+    private _onExit;
+    private _onStdout;
+    private _handle;
+    private _onUpdate;
+    /**
+     * Bug B invariant: every forwarded tool-START must get a matching tool-END. On
+     * turn end / cancel / teardown, FLUSH any tool_call ids still open (never got a
+     * terminal tool_call_update) as ended, so pixel-office (which pairs start→end)
+     * never shows a tool stuck "running" after the agent is idle.
+     */
+    private _flushOpenTools;
+    /** Emit completed narration lines as Notification hooks. `final` flushes the
+     *  trailing partial line (turn end). Keeps the office feed line-granular. */
+    private _flushNarration;
+    /**
+     * Run ONE primary turn: send the prompt and await turn end. Streams assistant
+     * text to `sink`. Emits Stop/StopFailure + SessionEnd. The process stays alive.
+     */
+    runTurn(promptText: string, sink: (text: string) => void): Promise<AcpTurnResult>;
+    /**
+     * Deliver a mid-run STEER: send an additional session/prompt the agent QUEUES
+     * (FIFO) and runs next — without exiting. The prompt is TRACKED in `_inflight`
+     * so the in-progress runTurn drains it before finishing (Bug A) — the steered
+     * turn's session/update hooks are forwarded like a normal turn and the loop
+     * stays WORKING until it completes. Returns true if handed to the live agent.
+     */
+    steer(text: string): boolean;
+    /**
+     * Like {@link steer}, but returns a promise that resolves when THAT steered
+     * turn actually COMPLETES (grok/opencode runs the queued session/prompt to its
+     * stopReason) — or null if it can't be delivered (dead/no session). The prompt
+     * is tracked in `_inflight` exactly like `steer()`, so an active runTurn drains
+     * it (Bug A). Used by the durable-steer queue to ack / de-queue a steer only on
+     * completion, so a restart mid-steer re-delivers it (at-least-once).
+     */
+    steerTracked(text: string): Promise<AcpTurnResult> | null;
+    /** Send a tracked session/prompt (primary or steer) and register it in
+     *  `_inflight` until it resolves. */
+    private _promptRequest;
+    /** Wait until every in-flight/queued prompt has resolved. */
+    private _drainInflight;
+    /**
+     * Send a QUIET prompt (e.g. `/compact`) and await it WITHOUT emitting the
+     * Stop/SessionEnd turn-boundary hooks — used for maintenance commands so they
+     * don't register as a task turn. Best-effort.
+     */
+    sendQuiet(text: string): Promise<void>;
+    /** Cancel the running turn (process stays alive). */
+    cancel(): void;
+    /** Kill the persistent process. Preserves the known session id for a later load. */
+    close(): void;
+    private _request;
+    private _send;
+    get stderrSnapshot(): string;
+}