@mafdet/cli 0.4.2 → 0.4.4

package/dist/agent/loop.js

@@ -1,4 +1,5 @@
 import { ApiError } from "../api/errors.js";
+import { compactForBudget, shouldCompact } from "./context-budget.js";
 import { toolToJsonSchema, } from "./tools/types.js";
 /** Plan §7.4. */
 export const DEFAULT_LIMITS = {
@@ -44,6 +45,8 @@ export async function runAgent(options) {
         completionTokens: 0,
         costMicroUsd: 0n,
     };
+    /** What the provider counted for the previous request; 0 until one lands. */
+    let lastPromptTokens = 0;
     for (let turn = 1; turn <= limits.maxTurns; turn += 1) {
         if (options.signal?.aborted)
             return stop(report, "cancelled");
@@ -55,6 +58,27 @@ export async function runAgent(options) {
         }
         report.turns = turn;
         options.onEvent?.({ type: "turn", turn });
+        // §7.4 · Shorten before asking, using what the provider counted last time.
+        if (shouldCompact(options.pricing?.contextLength, lastPromptTokens)) {
+            const compacted = compactForBudget(messages);
+            if (compacted.exhausted) {
+                // F-008 · Nothing left that can be dropped without breaking the
+                // conversation. Sending anyway means a request over the window, which
+                // fails upstream and is billed for the attempt - stopping and saying
+                // so is the only honest option.
+                return stop(report, "context_limit", `the conversation no longer fits in ${options.model}'s context window ` +
+                    `(${lastPromptTokens} input tokens last turn) and cannot be shortened further`);
+            }
+            options.onEvent?.({
+                type: "compacted",
+                exchanges: compacted.exchanges,
+                messages: compacted.removed,
+                promptTokens: lastPromptTokens,
+            });
+            // Reset the measurement: the next response measures the shorter
+            // history, and reusing the old figure would compact again every turn.
+            lastPromptTokens = 0;
+        }
         let response;
         try {
             response = await requestWithRateLimitHandling(options, limits, {
@@ -74,6 +98,7 @@ export async function runAgent(options) {
             return stop(report, "error", error instanceof Error ? error.message : String(error));
         }
         const usage = response.usage;
+        lastPromptTokens = usage?.prompt_tokens ?? lastPromptTokens;
         report.promptTokens += usage?.prompt_tokens ?? 0;
         report.completionTokens += usage?.completion_tokens ?? 0;
         // Cost comes from returned usage, never from the reservation: CLI-000B
@@ -89,6 +114,7 @@ export async function runAgent(options) {
             promptTokens: usage?.prompt_tokens ?? 0,
             completionTokens: usage?.completion_tokens ?? 0,
             costMicroUsd: turnCost,
+            priced: canPrice(options.pricing, usage),
         });
         const choice = response.choices?.[0];
         const message = choice?.message;
@@ -247,6 +273,12 @@ export function backoffMs(retryAfterSeconds, attempt, random = Math.random) {
     // Full jitter: a fleet of CLIs must not retry in lockstep.
     return Math.round(base * (0.5 + random() * 0.5));
 }
+/** F-012 · Whether `priceTurn` had everything it needed to give an answer. */
+function canPrice(model, usage) {
+    return (usage !== undefined &&
+        model?.inputPricePer1mMicroUsd !== undefined &&
+        model?.outputPricePer1mMicroUsd !== undefined);
+}
 function priceTurn(model, usage) {
     if (!model?.inputPricePer1mMicroUsd ||
         !model.outputPricePer1mMicroUsd ||

package/dist/agent/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/agent/session.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAY,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAapE,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,oEAAoE;IACpE,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,cAAc,CAAC,CAwFzB;AAgHD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,MAAM,CA2B7D"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/agent/session.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAY,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAapE,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,oEAAoE;IACpE,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,cAAc,CAAC,CA8FzB;AAgHD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,MAAM,CA2B7D"}

package/dist/agent/session.js

@@ -80,7 +80,13 @@ export async function runSession(options) {
                 history,
                 approver: options.approver,
                 signal: options.signal,
-                onEvent: options.onEvent ?? ((event) => reportEvent(event, options)),
+                // Both, not either: `onEvent` was replacing the progress display, so
+                // attaching a recorder would have silently blanked the terminal. An
+                // observer is an addition to the rendering, never a substitute for it.
+                onEvent: (event) => {
+                    reportEvent(event, options);
+                    options.onEvent?.(event);
+                },
             });
             summary.turns += report.turns;
             summary.modelRequests += report.modelRequests;

package/dist/agent/tools/run-command.d.ts

@@ -15,6 +15,34 @@ export interface CommandResult {
  * failure mode where a "timed out" test run keeps holding a port.
  */
 export declare function executeCommand(argv: readonly string[], cwd: string, timeoutMs?: number): Promise<CommandResult>;
+/**
+ * What "kill the whole tree" means on this platform.
+ *
+ * Pure, and separated from doing it, because the Windows branch cannot be
+ * executed here: there is no Windows machine in this project, and a kill path
+ * that has never run is exactly the kind of code that is wrong in a way only
+ * production finds. Keeping the decision pure means the *shape* of the command
+ * is under test on both platforms even though only one of them can be run.
+ *
+ * POSIX: a negative pid signals the process group, which is why the child is
+ * spawned detached. Killing the parent alone leaves grandchildren running -
+ * the familiar case where a "timed out" test runner keeps holding a port.
+ *
+ * Windows has no process groups in that sense. `taskkill /T` walks the child
+ * tree instead, and `/F` is the forceful pass: without it taskkill asks
+ * politely, which a console process is free to ignore - the same distinction
+ * as SIGTERM and SIGKILL.
+ */
+export type KillPlan = {
+    readonly kind: "signal";
+    readonly target: number;
+    readonly signal: NodeJS.Signals;
+} | {
+    readonly kind: "spawn";
+    readonly command: string;
+    readonly args: readonly string[];
+};
+export declare function killPlan(pid: number, force: boolean, platform?: string): KillPlan;
 export declare const runCommandTool: ToolDefinition;
 export declare const COMMAND_TOOLS: ToolDefinition[];
 //# sourceMappingURL=run-command.d.ts.map

package/dist/agent/tools/run-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-command.d.ts","sourceRoot":"","sources":["../../../src/agent/tools/run-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAA+B,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9E,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB,SAAU,CAAC;AAG1C,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,SAAS,GAAE,MAA2B,GACrC,OAAO,CAAC,aAAa,CAAC,CAkDxB;AAwBD,eAAO,MAAM,cAAc,EAAE,cAmC5B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,cAAc,EAAqB,CAAC"}
+{"version":3,"file":"run-command.d.ts","sourceRoot":"","sources":["../../../src/agent/tools/run-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAA+B,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9E,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB,SAAU,CAAC;AAG1C,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,SAAS,GAAE,MAA2B,GACrC,OAAO,CAAC,aAAa,CAAC,CAkDxB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,QAAQ,GAChB;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC;CACjC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEN,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,QAAQ,GAAE,MAAyB,GAClC,QAAQ,CAaV;AA8BD,eAAO,MAAM,cAAc,EAAE,cAmC5B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,cAAc,EAAqB,CAAC"}

package/dist/agent/tools/run-command.js

@@ -48,8 +48,8 @@ export async function executeCommand(argv, cwd, timeoutMs = COMMAND_TIMEOUT_MS)
         const timer = setTimeout(() => {
             timedOut = true;
             killTree(child.pid);
-            // A process ignoring SIGTERM still has to go.
-            setTimeout(() => killTree(child.pid, "SIGKILL"), 2000).unref();
+            // A process ignoring the polite request still has to go.
+            setTimeout(() => killTree(child.pid, true), 2000).unref();
         }, timeoutMs);
         const finish = (code, signal) => {
             clearTimeout(timer);
@@ -59,23 +59,44 @@ export async function executeCommand(argv, cwd, timeoutMs = COMMAND_TIMEOUT_MS)
         child.on("close", (code, signal) => finish(code, signal));
     });
 }
+export function killPlan(pid, force, platform = process.platform) {
+    if (platform === "win32") {
+        return {
+            kind: "spawn",
+            command: "taskkill",
+            args: ["/PID", String(pid), "/T", ...(force ? ["/F"] : [])],
+        };
+    }
+    return {
+        kind: "signal",
+        target: -pid,
+        signal: force ? "SIGKILL" : "SIGTERM",
+    };
+}
 /**
- * Kill the whole process group, not just the child.
+ * Kill the whole tree.
  *
- * Killing the parent alone leaves grandchildren running - the familiar case
- * where a "timed out" test runner keeps holding a port. The negative pid is
- * POSIX; Windows has no process groups in this sense, so there the direct
- * child is killed and the limitation is stated rather than papered over
- * (no Windows machine here to verify a taskkill /T path).
+ * ⚠️ The Windows branch is UNVERIFIED on a real machine. Its shape is tested;
+ * whether `taskkill /T` actually reaches every grandchild of a Node-spawned
+ * process is not something this project has been able to check.
  */
-function killTree(pid, signal = "SIGTERM") {
+function killTree(pid, force = false) {
     if (pid === undefined)
         return;
+    const plan = killPlan(pid, force);
     try {
-        if (process.platform === "win32")
-            process.kill(pid, signal);
-        else
-            process.kill(-pid, signal);
+        if (plan.kind === "signal") {
+            process.kill(plan.target, plan.signal);
+            return;
+        }
+        // Detached and ignored: this is fire-and-forget cleanup, and a taskkill
+        // that fails must not become an unhandled error on the way out.
+        const killer = spawn(plan.command, [...plan.args], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        killer.on("error", () => { });
+        killer.unref();
     }
     catch {
         // Already exited, or never became a group leader.

package/dist/api/http.d.ts

@@ -44,10 +44,24 @@ export declare class HttpClient {
     postJson<T>(path: string, body: unknown, options?: RequestOptions): Promise<HttpResponse<T>>;
     /** For `/v1/audio/speech`, which answers with audio bytes. */
     postBinary(path: string, body: unknown, options?: RequestOptions): Promise<HttpResponse<Uint8Array>>;
-    /** Raw streaming response, for the SSE reader to consume. */
+    /**
+     * Raw streaming response, for the SSE reader to consume.
+     *
+     * F-009 · Returns `abort` and the limits the reader should apply. The
+     * request timeout in `send` is cleared once the headers arrive - which for a
+     * stream is the start - so from here on the deadline belongs to whoever is
+     * reading the body, and it needs a way to close the connection rather than
+     * merely stop reading. Generation is what gets billed; dropping our end of
+     * a socket we are no longer reading does not stop it.
+     */
     postStream(path: string, body: unknown, options?: RequestOptions): Promise<{
         response: Response;
         requestId?: string;
+        abort: () => void;
+        limits: {
+            idleTimeoutMs: number;
+            maxBytes: number;
+        };
     }>;
     private send;
     private readJson;

package/dist/api/http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/api/http.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB,SAAU,CAAC;AAC1C,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,QAAmB,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,CAAC;IACR,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;gBAE7B,OAAO,EAAE,iBAAiB;IAShC,OAAO,CAAC,CAAC,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAKrB,QAAQ,CAAC,CAAC,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAK3B,8DAA8D;IACxD,UAAU,CACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;IAiBpC,6DAA6D;IACvD,UAAU,CACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;YASxC,IAAI;YA4DJ,QAAQ;YAuCR,SAAS;CAexB;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC,CAkCrB"}
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/api/http.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB,SAAU,CAAC;AAC1C,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,QAAmB,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,CAAC;IACR,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;gBAE7B,OAAO,EAAE,iBAAiB;IAShC,OAAO,CAAC,CAAC,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAKrB,QAAQ,CAAC,CAAC,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAK3B,8DAA8D;IACxD,UAAU,CACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;IAiBpC;;;;;;;;;OASG;IACG,UAAU,CACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC;QACT,QAAQ,EAAE,QAAQ,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,IAAI,CAAC;QAClB,MAAM,EAAE;YAAE,aAAa,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KACrD,CAAC;YA2BY,IAAI;YA4DJ,QAAQ;YAuCR,SAAS;CAexB;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC,CAkCrB"}

package/dist/api/http.js

@@ -49,15 +49,36 @@ export class HttpClient {
             requestId,
         };
     }
-    /** Raw streaming response, for the SSE reader to consume. */
+    /**
+     * Raw streaming response, for the SSE reader to consume.
+     *
+     * F-009 · Returns `abort` and the limits the reader should apply. The
+     * request timeout in `send` is cleared once the headers arrive - which for a
+     * stream is the start - so from here on the deadline belongs to whoever is
+     * reading the body, and it needs a way to close the connection rather than
+     * merely stop reading. Generation is what gets billed; dropping our end of
+     * a socket we are no longer reading does not stop it.
+     */
     async postStream(path, body, options = {}) {
-        const response = await this.send("POST", path, body, options, {
-            accept: "text/event-stream",
-        });
+        const streamController = new AbortController();
+        const response = await this.send("POST", path, body, {
+            ...options,
+            signal: options.signal
+                ? AbortSignal.any([options.signal, streamController.signal])
+                : streamController.signal,
+        }, { accept: "text/event-stream" });
         const requestId = requestIdOf(response.headers);
         if (!response.ok)
             throw await this.errorFrom(response, requestId, options);
-        return { response, requestId };
+        return {
+            response,
+            requestId,
+            abort: () => streamController.abort(),
+            limits: {
+                idleTimeoutMs: options.timeoutMs ?? this.timeoutMs,
+                maxBytes: options.maxBytes ?? this.maxBytes,
+            },
+        };
     }
     async send(method, path, body, options, extraHeaders = {}) {
         const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;

package/dist/api/sse-parser.d.ts

@@ -62,11 +62,36 @@ export declare class ChatStreamAssembler {
     push(payload: string): boolean;
     result(): StreamResult;
 }
+/** F-009 · Limits that apply for the whole life of the stream. */
+export interface StreamLimits {
+    /**
+     * How long to wait for the *next* chunk, not for the whole stream. A total
+     * deadline would kill a legitimately long generation; what "hung" actually
+     * means is that nothing is arriving.
+     */
+    readonly idleTimeoutMs?: number;
+    /** Total bytes accepted before the stream is treated as hostile. */
+    readonly maxBytes?: number;
+    /**
+     * Closes the underlying connection. Cancelling the reader alone stops us
+     * reading; it does not reliably stop the gateway generating, and generation
+     * is what gets billed.
+     */
+    readonly abort?: () => void;
+}
+export declare const DEFAULT_STREAM_IDLE_MS = 120000;
+export declare const DEFAULT_STREAM_MAX_BYTES: number;
 /**
  * Read a streaming response to completion.
  *
  * `signal` is the user's Ctrl+C: aborting stops reading AND closes the
  * connection, which is what actually tells the gateway to stop generating.
+ *
+ * F-009 · The request timeout in `HttpClient` is cleared the moment the
+ * response headers arrive, which for a stream is the beginning rather than the
+ * end. Without the two limits below, a gateway that sent headers and then
+ * stopped would hang the CLI forever, and one that never stopped sending would
+ * grow the buffer until the process died.
  */
-export declare function readChatStream(response: Response, events?: StreamEvents, signal?: AbortSignal): Promise<StreamResult>;
+export declare function readChatStream(response: Response, events?: StreamEvents, signal?: AbortSignal, limits?: StreamLimits): Promise<StreamResult>;
 //# sourceMappingURL=sse-parser.d.ts.map

package/dist/api/sse-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sse-parser.d.ts","sourceRoot":"","sources":["../../src/api/sse-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf;AAWD,+EAA+E;AAC/E,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE;IAMjC,kDAAkD;IAClD,GAAG,IAAI,MAAM,EAAE;IASf,OAAO,CAAC,KAAK;CAYd;AAED,8DAA8D;AAC9D,qBAAa,mBAAmB;IAOlB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAC7D,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,KAAK,CAAC,CAAc;IAC5B,OAAO,CAAC,IAAI,CAAS;gBAEQ,MAAM,GAAE,YAAiB;IAEtD,4DAA4D;IAC5D,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAgD9B,MAAM,IAAI,YAAY;CASvB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,QAAQ,EAClB,MAAM,GAAE,YAAiB,EACzB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,YAAY,CAAC,CAkCvB"}
+{"version":3,"file":"sse-parser.d.ts","sourceRoot":"","sources":["../../src/api/sse-parser.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf;AAWD,+EAA+E;AAC/E,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE;IAMjC,kDAAkD;IAClD,GAAG,IAAI,MAAM,EAAE;IASf,OAAO,CAAC,KAAK;CAYd;AAED,8DAA8D;AAC9D,qBAAa,mBAAmB;IAOlB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAC7D,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,KAAK,CAAC,CAAc;IAC5B,OAAO,CAAC,IAAI,CAAS;gBAEQ,MAAM,GAAE,YAAiB;IAEtD,4DAA4D;IAC5D,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAgD9B,MAAM,IAAI,YAAY;CASvB;AAED,kEAAkE;AAClE,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,eAAO,MAAM,sBAAsB,SAAU,CAAC;AAC9C,eAAO,MAAM,wBAAwB,QAAmB,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,QAAQ,EAClB,MAAM,GAAE,YAAiB,EACzB,MAAM,CAAC,EAAE,WAAW,EACpB,MAAM,GAAE,YAAiB,GACxB,OAAO,CAAC,YAAY,CAAC,CA8DvB"}

package/dist/api/sse-parser.js

@@ -1,22 +1,5 @@
-/**
- * SSE reader for the chat data plane.
- *
- * Every rule here is a fact measured in Phase 0 against real transcripts from
- * DeepSeek, Kimi, Qwen and Vertex Gemini (tests/fixtures/cli-000*), not an
- * assumption about how streaming "usually" works:
- *
- *   - `id` and `name` arrive exactly once, so tool calls merge by `index`.
- *   - Qwen sends `"id": ""` on continuation frames; `??` would overwrite the
- *     real id with an empty string and the tool result would be rejected.
- *   - Gemini packs a thought signature into the id (700+ chars) and delivers a
- *     whole call in one frame, where Kimi takes nine — fragment counts mean
- *     nothing.
- *   - `finish_reason` arrives in its own frame with an empty delta; `[DONE]`
- *     ends the stream.
- *   - With `stream_options.include_usage`, usage arrives AFTER finish_reason
- *     in a frame whose `choices` is non-empty but whose delta is empty. A
- *     parser that only reads usage when `choices` is empty reports zero cost.
- */
+import { ApiError } from "./errors.js";
+import { ExitCode } from "../output/exit-codes.js";
 /** Split a byte stream into SSE `data:` payloads across arbitrary chunking. */
 export class SseFramer {
     buffer = "";
@@ -117,18 +100,29 @@ export class ChatStreamAssembler {
         };
     }
 }
+export const DEFAULT_STREAM_IDLE_MS = 120_000;
+export const DEFAULT_STREAM_MAX_BYTES = 32 * 1024 * 1024;
 /**
  * Read a streaming response to completion.
  *
  * `signal` is the user's Ctrl+C: aborting stops reading AND closes the
  * connection, which is what actually tells the gateway to stop generating.
+ *
+ * F-009 · The request timeout in `HttpClient` is cleared the moment the
+ * response headers arrive, which for a stream is the beginning rather than the
+ * end. Without the two limits below, a gateway that sent headers and then
+ * stopped would hang the CLI forever, and one that never stopped sending would
+ * grow the buffer until the process died.
  */
-export async function readChatStream(response, events = {}, signal) {
+export async function readChatStream(response, events = {}, signal, limits = {}) {
     const framer = new SseFramer();
     const assembler = new ChatStreamAssembler(events);
     const body = response.body;
     if (!body)
         return assembler.result();
+    const idleMs = limits.idleTimeoutMs ?? DEFAULT_STREAM_IDLE_MS;
+    const maxBytes = limits.maxBytes ?? DEFAULT_STREAM_MAX_BYTES;
+    let received = 0;
     const reader = body.getReader();
     const onAbort = () => void reader.cancel();
     // Attaching a listener is not enough: a signal that aborted between the
@@ -144,9 +138,29 @@ export async function readChatStream(response, events = {}, signal) {
         for (;;) {
             if (signal?.aborted)
                 break;
-            const { done, value } = await reader.read();
+            const chunk = await withIdleDeadline(reader.read(), idleMs);
+            if (chunk === IDLE) {
+                limits.abort?.();
+                await reader.cancel().catch(() => { });
+                throw new ApiError({
+                    kind: "timeout",
+                    exitCode: ExitCode.Unavailable,
+                    message: `the stream sent nothing for ${idleMs}ms`,
+                });
+            }
+            const { done, value } = chunk;
             if (done)
                 break;
+            received += value.byteLength;
+            if (received > maxBytes) {
+                limits.abort?.();
+                await reader.cancel().catch(() => { });
+                throw new ApiError({
+                    kind: "too_large",
+                    exitCode: ExitCode.Unavailable,
+                    message: `the stream exceeded the ${maxBytes} byte limit`,
+                });
+            }
             for (const payload of framer.push(value)) {
                 if (assembler.push(payload))
                     return assembler.result();
@@ -161,3 +175,30 @@ export async function readChatStream(response, events = {}, signal) {
     }
     return assembler.result();
 }
+/** Sentinel for "the deadline won", distinguishable from a real chunk. */
+const IDLE = Symbol("idle");
+/**
+ * Race a read against the idle deadline.
+ *
+ * The timer is unref'd and always cleared: a pending timer would keep the
+ * process alive after a stream that finished normally.
+ */
+async function withIdleDeadline(read, idleMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            read,
+            new Promise((resolve) => {
+                // Deliberately not unref'd: if a stalled stream were the only thing
+                // left, an unref'd timer would let the process exit silently instead
+                // of reporting the timeout. The finally below always clears it, so
+                // nothing is held open after a stream that ended normally.
+                timer = setTimeout(() => resolve(IDLE), idleMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}

package/dist/commands/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/commands/agent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAOvE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAatB,eAAO,MAAM,gBAAgB,0XAK+C,CAAC;AAE7E,eAAO,MAAM,YAAY,mgBAOmB,CAAC;AAE7C,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,qDAAqD;IACrD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,OAAO,uBAAuB,EAAE,QAAQ,CAAC;CACrD;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,OAAO,GACV,OAAO,CAAC,QAAQ,CAAC,CA+GnB;AAgFD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,kBAAkB,EAAE,OAAO,0JAI3E"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/commands/agent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAYvE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAatB,eAAO,MAAM,gBAAgB,0XAK+C,CAAC;AAE7E,eAAO,MAAM,YAAY,mgBAOmB,CAAC;AAE7C,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,qDAAqD;IACrD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,OAAO,uBAAuB,EAAE,QAAQ,CAAC;CACrD;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,OAAO,GACV,OAAO,CAAC,QAAQ,CAAC,CAsHnB;AAyJD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,kBAAkB,EAAE,OAAO,0JAI3E"}

package/dist/commands/agent.js

@@ -2,6 +2,11 @@ import { fetchAccessibleModels, fetchCatalog, intersectModels, } from "../api/mo
 import { approverFor } from "../agent/approvals.js";
 import { runAgent } from "../agent/loop.js";
 import { runSession } from "../agent/session.js";
+import { sessionsDir } from "../config/paths.js";
+import { keyDigest } from "../security/redact.js";
+import { decideRecording } from "../sessions/policy.js";
+import { SessionRecorder } from "../sessions/recorder.js";
+import { SessionWriter } from "../sessions/store.js";
 import { READ_ONLY_TOOLS } from "../agent/tools/read-only.js";
 import { COMMAND_TOOLS } from "../agent/tools/run-command.js";
 import { WRITE_TOOLS } from "../agent/tools/write.js";
@@ -74,8 +79,14 @@ export async function agentCommand(argv, io) {
                 io.stderr(`mafdet agent: no goal\n${USAGE}`);
                 return ExitCode.Usage;
             }
+            // F-007 · `decideRecording` already called this surface "interactive",
+            // so the policy claimed these runs were saved while nothing saved them.
+            const recorder = openRecorder(parsed, io, model, workspace.root, mode);
             const summary = await runSession({
                 client: runtime.dataPlane,
+                ...(recorder === undefined
+                    ? {}
+                    : { onEvent: (event) => recorder.observe(event) }),
                 model,
                 pricing: resolved,
                 catalog,
@@ -89,6 +100,7 @@ export async function agentCommand(argv, io) {
                 stderr: io.stderr,
                 signal: io.signal,
             });
+            recorder?.close();
             io.stderr("\n" +
                 renderRecord([
                     ["goals", `${summary.goals}`],
@@ -130,6 +142,45 @@ export async function agentCommand(argv, io) {
         return reportError(error, io);
     }
 }
+/**
+ * F-007 · A recorder for an interactive `mafdet agent`, or nothing.
+ *
+ * The same store, policy and failure behaviour as the TUI: `--no-history`
+ * writes nothing at all, and a store that cannot be opened costs the
+ * transcript rather than the session.
+ */
+function openRecorder(parsed, io, modelId, workspaceRoot, mode) {
+    const decision = decideRecording({
+        surface: "interactive",
+        noHistory: parsed.noHistory,
+        save: false,
+    });
+    if (!decision.record)
+        return undefined;
+    const env = io.env ?? process.env;
+    const root = sessionsDir(env);
+    try {
+        const writer = SessionWriter.create({
+            root,
+            title: parsed.title ??
+                workspaceRoot.split(/[\\/]/).filter(Boolean).at(-1) ??
+                "Conversation",
+            modelId,
+            workspace: workspaceRoot,
+            mode,
+        });
+        return new SessionRecorder({
+            writer,
+            root,
+            apiKeyRef: keyDigest(env.MAFDET_API_KEY ?? ""),
+            onProblem: (message) => io.stderr(`${message}\n`),
+        });
+    }
+    catch (error) {
+        io.stderr(`not recording this conversation: ${error instanceof Error ? error.message : String(error)}\n`);
+        return undefined;
+    }
+}
 function parseArgs(argv, io) {
     const positional = [];
     let model;
@@ -137,6 +188,8 @@ function parseArgs(argv, io) {
     let maxCostMicroUsd;
     let json = false;
     let allowWrite = false;
+    let noHistory = false;
+    let title;
     const allowedCommands = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -157,6 +210,25 @@ function parseArgs(argv, io) {
         }
         else if (arg === "--read-only")
             allowWrite = false;
+        else if (arg === "--no-history")
+            noHistory = true;
+        else if (arg === "--title") {
+            const entry = next();
+            if (!entry) {
+                io.stderr("mafdet agent: --title needs a value\n");
+                return ExitCode.Usage;
+            }
+            title = entry;
+        }
+        else if (arg === "--resume") {
+            // F-007 · Deliberately not implemented here, and said rather than
+            // silently ignored. Resuming has to reconcile the session's model and
+            // workspace against the current key, which the TUI has a place to do
+            // and this surface does not - and a second, weaker resume path is
+            // exactly how the two drift apart. F-003 was that drift.
+            io.stderr("mafdet agent: --resume is not available here; run 'mafdet --resume <id>'\n");
+            return ExitCode.Usage;
+        }
         else if (arg === "--max-turns") {
             const raw = next();
             maxTurns = Number(raw);
@@ -198,6 +270,8 @@ function parseArgs(argv, io) {
         maxTurns,
         maxCostMicroUsd,
         json,
+        noHistory,
+        ...(title === undefined ? {} : { title }),
     };
 }
 /**
@@ -258,6 +332,8 @@ function finish(report, json, io) {
         case "max_turns":
         case "timeout":
         case "max_cost":
+        // F-008 · A ceiling too: the window ran out, and the report says which.
+        case "context_limit":
             // Stopped short on purpose; the report says so rather than pretending.
             return ExitCode.LimitReached;
         case "rate_limited":

package/dist/commands/chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/commands/chat.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAUtB,MAAM,WAAW,MAAO,SAAQ,SAAS;IACvC,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,gDAAgD;IAChD,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAWD,wBAAsB,WAAW,CAC/B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,QAAQ,CAAC,CA8BnB;AAwLD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,KAAK,EAAE,WAAW,GACjB,MAAM,GAAG,SAAS,CASpB"}
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/commands/chat.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAWxE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAatB,MAAM,WAAW,MAAO,SAAQ,SAAS;IACvC,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,gDAAgD;IAChD,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAcD,wBAAsB,WAAW,CAC/B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,QAAQ,CAAC,CA8BnB;AA8SD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,KAAK,EAAE,WAAW,GACjB,MAAM,GAAG,SAAS,CASpB"}