negotium 0.2.7 → 0.2.9

package/dist/runtime/src/agents/model-catalog.ts

@@ -55,7 +55,8 @@ export interface SelectableModel {
 }
 
 /**
- * Pricing and quota observations were checked on 2026-07-19.
+ * Pricing and quota observations were checked on 2026-07-19, DeepSeek pricing
+ * re-checked 2026-08-04 for the new deepseek-v4-flash model.
  * Official references:
  * - https://learn.chatgpt.com/docs/pricing
  * - https://help.openai.com/en/articles/20001106
@@ -67,9 +68,9 @@ export interface SelectableModel {
  * meter cached input, fresh input, output, reasoning, speed, and model choice
  * differently and may change server-side weights without publishing a token cap.
  */
-export const MODEL_COST_RESEARCHED_AT = "2026-07-19";
+export const MODEL_COST_RESEARCHED_AT = "2026-08-04";
 export const MODEL_COST_ROUTING_SUMMARY =
-  "Cost basis (2026-07-19): Codex Pro 20x and Claude Max 20x are each $200/month; Maestro models are pay-per-token. DeepSeek Pro is cheapest.";
+  "Cost basis (2026-08-04): Codex Pro 20x and Claude Max 20x are each $200/month; Maestro models are pay-per-token. DeepSeek Flash is cheapest.";
 
 const CODEX_PRO_20X_COST = "ChatGPT Pro 20x subscription: $200/month";
 const CODEX_COMMUNITY_WEEKLY =
@@ -173,13 +174,26 @@ export const SELECTABLE_MODELS: readonly SelectableModel[] = [
     agent: "maestro",
     description: "API-priced Sonnet-level route for cost-efficient everyday work.",
     intelligenceTier: "sonnet",
-    routingSummary: "cost-efficient everyday work; pay-per-token and cheapest route",
+    routingSummary: "cost-efficient everyday work; pay-per-token, pricier than DeepSeek Flash",
     accessCost: "DeepSeek V4 Pro pay-as-you-go API; no monthly subscription required",
     marginalTokenCost:
       "DeepSeek API: $0.435/M uncached input, $0.003625/M cached input, $0.87/M output",
     estimatedUsage:
       "No subscription token cap; pay per token. Official account concurrency limit is 500 requests.",
   },
+  {
+    model: "deepseek-flash",
+    agent: "maestro",
+    description:
+      "Faster, cheaper DeepSeek V4 variant (DeepSeek-V4-Flash-0731) at similar Sonnet-level quality for high-volume everyday work.",
+    intelligenceTier: "sonnet",
+    routingSummary: "cheapest overall route; pay-per-token, 1M context, 5x Pro's concurrency limit",
+    accessCost: "DeepSeek V4 Flash pay-as-you-go API; no monthly subscription required",
+    marginalTokenCost:
+      "DeepSeek API: $0.14/M uncached input, $0.0028/M cached input, $0.28/M output",
+    estimatedUsage:
+      "No subscription token cap; pay per token. Official account concurrency limit is 2500 requests.",
+  },
 ];
 
 const SELECTABLE_MODEL_ALIASES: Readonly<Record<string, string>> = {

package/dist/runtime/src/mcp/background-bash-server.ts

@@ -65,10 +65,29 @@ const COMPLETED_RETENTION_MS = 60 * 60_000;
 const MAX_COMPLETED_PROCS = 100;
 /** Count-based pruning ignores jobs this fresh; their turn may still be queued. */
 const PRUNE_GRACE_MS = 5 * 60_000;
+const DEFAULT_WATCH_TIMEOUT_SECONDS = 3_600;
+const MAX_WATCH_TIMEOUT_SECONDS = 86_400;
 
 /** Root for full-output spill files, one directory per bash id. */
 const SPILL_ROOT = join(RUN_DIR, "bg-bash-output");
 
+/**
+ * One-shot match-and-notify state for `background_bash_watch`. `matched` and
+ * `finished` are distinct: `matched` records the specific outcome (a line hit
+ * `regex`) for the injected message; `finished` guards against `finishProc`
+ * double-delivering once a match or timeout has already sent the one turn a
+ * watch job promises.
+ */
+interface WatchState {
+  regex: RegExp;
+  target: "stdout" | "stderr" | "both";
+  matched: boolean;
+  finished: boolean;
+  timeoutTimer?: ReturnType<typeof setTimeout>;
+  stdoutCarry: string;
+  stderrCarry: string;
+}
+
 interface BgProc {
   bashId: string;
   userId: string;
@@ -86,6 +105,8 @@ interface BgProc {
   startedAt: number;
   killTimer?: ReturnType<typeof setTimeout>;
   cleanupTimer?: ReturnType<typeof setTimeout>;
+  /** Present only for jobs started via `background_bash_watch`. */
+  watch?: WatchState;
 }
 
 const procs = new Map<string, BgProc>();
@@ -175,30 +196,33 @@ function describeStream(label: string, snapshot: OutputSnapshot): string | undef
   return `${label} (${notes.join(" · ")}):\n${body}`;
 }
 
-/**
- * Deliver the completion turn.
- *
- * Returns false when the inbox write failed. The tool promises the caller it
- * need not poll, so a dropped completion is the one failure that leaves a
- * background job silently unfinished — the caller must not treat it as done.
- */
-function injectCompletion(proc: BgProc): boolean {
+/** Render the shared header+output body used by every injected message. */
+function buildOutputMessage(proc: BgProc, header: string): string {
   const parts: string[] = [];
   const stdout = describeStream("stdout", proc.stdout.snapshot());
   const stderr = describeStream("stderr", proc.stderr.snapshot());
   if (stdout) parts.push(stdout);
   if (stderr) parts.push(stderr);
   const output = parts.join("\n") || "(no output)";
-
   // English on purpose: this text is injected into the model's context, and
   // every other model-facing string in this server — the tool descriptions it
   // sits alongside — is English. It is also cheaper in tokens.
-  const message =
-    `[background_bash ${proc.bashId} finished]\n` +
+  return (
+    `${header}\n` +
     `command: ${proc.command.slice(0, 200)}\n` +
     `exit code: ${proc.exitCode ?? "unknown"}\n` +
-    output;
+    output
+  );
+}
 
+/**
+ * Deliver one turn to the topic's inbox.
+ *
+ * Returns false when the inbox write failed. Every caller promises the
+ * caller it need not poll, so a dropped delivery is the one failure that
+ * leaves a background job silently unfinished — treat it as not-done.
+ */
+function injectMessage(proc: BgProc, message: string, label: string): boolean {
   // `proc.topic` is the canonical topic id (see mcp-config background-bash
   // build: `topicId ?? session`). Route through the shared helper so the
   // filename is the `topic-id-{base64url}` form the session-inbox worker
@@ -212,11 +236,11 @@ function injectCompletion(proc: BgProc): boolean {
       depth: 0,
       timestamp: new Date().toISOString(),
     });
-    process.stderr.write(`[bg-bash] injected completion ${proc.bashId} exit=${proc.exitCode}\n`);
+    process.stderr.write(`[bg-bash] injected ${label} ${proc.bashId} exit=${proc.exitCode}\n`);
     return true;
   } catch (e) {
     process.stderr.write(
-      `[bg-bash] FAILED to deliver completion ${proc.bashId} (exit=${proc.exitCode}): ${e}\n` +
+      `[bg-bash] FAILED to deliver ${label} ${proc.bashId} (exit=${proc.exitCode}): ${e}\n` +
         `[bg-bash] the topic will never be told this job finished; ` +
         `its output is kept at ${spillDir(proc.bashId)}\n`,
     );
@@ -224,6 +248,61 @@ function injectCompletion(proc: BgProc): boolean {
   }
 }
 
+function injectCompletion(proc: BgProc): boolean {
+  return injectMessage(
+    proc,
+    buildOutputMessage(proc, `[background_bash ${proc.bashId} finished]`),
+    "completion",
+  );
+}
+
+/**
+ * Test newly arrived bytes for `watch.regex`, line by line, carrying any
+ * trailing partial line to the next chunk so a match split across two reads
+ * is never missed. Returns the first matching line, if any.
+ */
+function checkWatchMatch(
+  proc: BgProc,
+  stream: "stdout" | "stderr",
+  chunk: Buffer,
+): string | undefined {
+  const watch = proc.watch;
+  if (!watch || watch.matched) return undefined;
+  if (watch.target !== "both" && watch.target !== stream) return undefined;
+  const carryKey = stream === "stdout" ? "stdoutCarry" : "stderrCarry";
+  const lines = (watch[carryKey] + chunk.toString("utf8")).split("\n");
+  watch[carryKey] = lines.pop() ?? "";
+  for (const line of lines) {
+    if (watch.regex.test(line)) return line;
+  }
+  return undefined;
+}
+
+/** A watch line matched: deliver the one promised turn and stop the process. */
+function handleWatchMatch(proc: BgProc, line: string): void {
+  const watch = proc.watch;
+  if (!watch || watch.matched) return;
+  watch.matched = true;
+  watch.finished = true;
+  if (watch.timeoutTimer) {
+    clearTimeout(watch.timeoutTimer);
+    watch.timeoutTimer = undefined;
+  }
+  const header = `[background_bash_watch ${proc.bashId} matched]\nmatched line: ${line.slice(0, 500)}`;
+  proc.delivered = injectMessage(proc, buildOutputMessage(proc, header), "watch match");
+  terminateProc(proc);
+}
+
+/** No line matched within the deadline: deliver a timeout turn and stop. */
+function handleWatchTimeout(proc: BgProc): void {
+  const watch = proc.watch;
+  if (!watch || watch.finished) return;
+  watch.finished = true;
+  const header = `[background_bash_watch ${proc.bashId} timed out without a match]`;
+  proc.delivered = injectMessage(proc, buildOutputMessage(proc, header), "watch timeout");
+  terminateProc(proc);
+}
+
 function signalProcessTree(child: ChildProcess, signal: NodeJS.Signals): boolean {
   if (!child.pid) return child.kill(signal);
   try {
@@ -288,7 +367,23 @@ function finishProc(proc: BgProc, exitCode: number | null): void {
   // paths, so anything reading them sees a closed, complete file.
   proc.stdout.close();
   proc.stderr.close();
-  proc.delivered = injectCompletion(proc);
+  if (proc.watch) {
+    if (proc.watch.timeoutTimer) {
+      clearTimeout(proc.watch.timeoutTimer);
+      proc.watch.timeoutTimer = undefined;
+    }
+    if (!proc.watch.finished) {
+      // The command exited on its own — no match, no timeout yet. This is
+      // still exactly one delivered turn, same one-shot guarantee.
+      proc.watch.finished = true;
+      const header = `[background_bash_watch ${proc.bashId} exited before matching]`;
+      proc.delivered = injectMessage(proc, buildOutputMessage(proc, header), "watch exit");
+    }
+    // Else: a match or timeout already delivered the one promised turn
+    // (`proc.delivered` was set there) — do not inject a second one.
+  } else {
+    proc.delivered = injectCompletion(proc);
+  }
   if (proc.delivered) {
     proc.cleanupTimer = setTimeout(() => forgetProc(proc), COMPLETED_RETENTION_MS);
     proc.cleanupTimer.unref?.();
@@ -299,10 +394,17 @@ function finishProc(proc: BgProc, exitCode: number | null): void {
   pruneCompletedProcs();
 }
 
+interface WatchConfig {
+  regex: RegExp;
+  target: "stdout" | "stderr" | "both";
+  timeoutSeconds: number;
+}
+
 function spawnBash(
   context: BgContext,
   command: string,
   cwd?: string,
+  watchConfig?: WatchConfig,
 ): { bashId: string } | { error: string } {
   if (!command.trim()) return { error: "empty command" };
   const bashId = newBashId();
@@ -337,11 +439,29 @@ function spawnBash(
     exitCode: null,
     delivered: false,
     startedAt: Date.now(),
+    watch: watchConfig
+      ? {
+          regex: watchConfig.regex,
+          target: watchConfig.target,
+          matched: false,
+          finished: false,
+          stdoutCarry: "",
+          stderrCarry: "",
+        }
+      : undefined,
   };
   // Raw Buffers: decoding per chunk would split multi-byte characters that
   // straddle a chunk boundary. The buffer decodes at read time instead.
-  child.stdout?.on("data", (c: Buffer) => proc.stdout.append(c));
-  child.stderr?.on("data", (c: Buffer) => proc.stderr.append(c));
+  child.stdout?.on("data", (c: Buffer) => {
+    proc.stdout.append(c);
+    const line = checkWatchMatch(proc, "stdout", c);
+    if (line !== undefined) handleWatchMatch(proc, line);
+  });
+  child.stderr?.on("data", (c: Buffer) => {
+    proc.stderr.append(c);
+    const line = checkWatchMatch(proc, "stderr", c);
+    if (line !== undefined) handleWatchMatch(proc, line);
+  });
   child.on("close", (code) => {
     finishProc(proc, code);
   });
@@ -350,6 +470,13 @@ function spawnBash(
     finishProc(proc, -1);
   });
   procs.set(bashId, proc);
+  if (proc.watch) {
+    proc.watch.timeoutTimer = setTimeout(
+      () => handleWatchTimeout(proc),
+      watchConfig!.timeoutSeconds * 1_000,
+    );
+    proc.watch.timeoutTimer.unref?.();
+  }
   process.stderr.write(`[bg-bash] started ${bashId}: ${command.slice(0, 80)}\n`);
   return { bashId };
 }
@@ -421,6 +548,56 @@ function buildMcpServer(context: BgContext): McpServer {
     },
   );
 
+  server.tool(
+    "background_bash_watch",
+    [
+      "Start a background shell command and watch its stdout/stderr for a regex match, one line at a time.",
+      "The moment a line matches `match`, the process is stopped and the matching line plus buffered",
+      "output is injected into this session as a new turn — you do NOT need to poll.",
+      "If nothing matches within `timeout_seconds` (default 3600), or the command exits on its own first,",
+      "a final status turn is injected instead. Exactly one turn is ever injected per watch — this is",
+      "one-shot only, there is no repeat/streaming mode yet.",
+      "Prefer this over `background_bash_run` + manual `background_bash_output` polling when you are",
+      "waiting for a specific condition to appear (a deploy readiness line, an error) rather than for",
+      "the command itself to finish.",
+    ].join(" "),
+    {
+      command: z.string().describe("Shell command (executed via bash -c)"),
+      match: z.string().describe("Regular expression tested against each output line"),
+      cwd: z.string().optional().describe("Working directory (absolute path)"),
+      stream: z
+        .enum(["stdout", "stderr", "both"])
+        .optional()
+        .describe("Which stream(s) to test against `match` (default both)"),
+      timeout_seconds: z
+        .number()
+        .int()
+        .positive()
+        .max(MAX_WATCH_TIMEOUT_SECONDS)
+        .optional()
+        .describe(
+          `Give up waiting for a match after this many seconds (default ${DEFAULT_WATCH_TIMEOUT_SECONDS}, max ${MAX_WATCH_TIMEOUT_SECONDS})`,
+        ),
+    },
+    async ({ command, match, cwd, stream, timeout_seconds }) => {
+      let regex: RegExp;
+      try {
+        regex = new RegExp(match);
+      } catch (e) {
+        return mcpError(
+          `invalid regex in \`match\`: ${e instanceof Error ? e.message : String(e)}`,
+        );
+      }
+      const result = spawnBash(context, command, cwd, {
+        regex,
+        target: stream ?? "both",
+        timeoutSeconds: timeout_seconds ?? DEFAULT_WATCH_TIMEOUT_SECONDS,
+      });
+      if ("error" in result) return mcpError(result.error);
+      return mcpOk(JSON.stringify({ bash_id: result.bashId, status: "watching" }));
+    },
+  );
+
   server.tool(
     "background_bash_kill",
     "Terminate a background process (SIGTERM → SIGKILL after 5s). Idempotent.",

package/dist/runtime/src/platform/config.ts

@@ -99,7 +99,7 @@ export function resolveOutputLanguage(): string {
 }
 
 /** Browser.rs release tested with this Negotium version. */
-export const BROWSER_RS_VERSION = "v0.1.16";
+export const BROWSER_RS_VERSION = "v0.1.17";
 /** Require the authenticated listener and the current Browser.rs tool contract. */
 export const BROWSER_RS_MIN_SECURE_VERSION = "0.1.15";
 

package/dist/runtime/src/platform/playwright/vault-broker.ts

@@ -14,6 +14,13 @@ const BOUNDED_OUTPUTS: Record<string, { argument: string; field: string }> = {
   browser_api_request: { argument: "maxBytes", field: "body" },
   browser_get_visible_text: { argument: "maxLength", field: "text" },
   browser_get_visible_html: { argument: "maxLength", field: "html" },
+  // browser-rs 0.1.17's own `maxLength` doc comment: "Managed hosts may raise
+  // this so secrets are redacted before the caller-visible limit is applied."
+  // `field` is unused here (the tool returns a plain string, not `{content}`
+  // JSON — see `redactTextEntry`'s non-JSON fallback), but the `argument`
+  // override is what matters: it raises the request to MAX_SAFE_INTEGER so
+  // browser-rs never truncates a secret mid-string before redaction sees it.
+  browser_iframe_read: { argument: "maxLength", field: "content" },
 };
 
 interface RedactionBoundary {

package/dist/runtime/src/runtime/turn-runner.ts

@@ -1423,9 +1423,29 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
     ].join("\n");
   }
 
+  /**
+   * Per-turn `<system-reminder>` blocks, appended to the *user* prompt rather
+   * than the system prompt.
+   *
+   * These facts flip between turns on the same model — whether the browser MCP
+   * came up, whether this turn is an auto-resume. A prompt cache invalidates
+   * from the first diverging byte, so putting them in the system prompt means
+   * every flip re-reads the entire prompt: measured against the live DeepSeek
+   * API, one flip at turn 15 of a 20-turn conversation cost 17,852 uncached
+   * tokens (hit=0) versus 1,215 with the reminder on the user turn — 40% more
+   * uncached tokens across the run. On the user turn the divergence lands at
+   * the tail, where the text is new anyway.
+   *
+   * Applied after the conversation log is written, so a reminder never becomes
+   * part of the recorded user message (it would then persist into synthesized
+   * rollouts and defeat the point).
+   */
+  const turnReminders: string[] = [];
+
   if (params.from === FROM_AUTO_CONTINUE) {
-    systemPrompt +=
-      "\n\n<system-reminder>이 턴은 설정 자동 조정(effort/model/agent) 후 자동 재개된 턴이다. effort/model/agent 난이도 재평가 및 설정 변경 없이 즉시 작업을 시작할 것.</system-reminder>";
+    turnReminders.push(
+      "<system-reminder>이 턴은 설정 자동 조정(effort/model/agent) 후 자동 재개된 턴이다. effort/model/agent 난이도 재평가 및 설정 변경 없이 즉시 작업을 시작할 것.</system-reminder>",
+    );
   }
 
   if (!silent && !sessionRetried) {
@@ -1538,25 +1558,28 @@ export function startAiTurn(params: StartAiTurnParams): string | null {
         );
       }
     }
-    let effectiveSystemPrompt = systemPrompt;
     if (playwrightRequested && !browserProfileOwner) {
-      const ownerOnlyNote =
-        "<system-reminder>Browser tools are unavailable in this turn because browser profiles are private to the topic owner. Do not attempt browser calls or ask to reuse the owner's login state.</system-reminder>";
-      effectiveSystemPrompt = `${effectiveSystemPrompt}\n\n${ownerOnlyNote}`;
+      turnReminders.push(
+        "<system-reminder>Browser tools are unavailable in this turn because browser profiles are private to the topic owner. Do not attempt browser calls or ask to reuse the owner's login state.</system-reminder>",
+      );
     }
     if (consumePlaywrightUnavailable(userId, topic.title)) {
-      const playwrightNote =
-        "<system-reminder>Playwright browser tools are UNAVAILABLE this turn. The `mcp__playwright__*` tools have been removed from this turn's catalog because the long-lived browser MCP could not be prepared. Do not attempt to call browser tools. If browser interaction is required, ask the user to retry shortly or use a non-browser alternative.</system-reminder>";
-      effectiveSystemPrompt = `${effectiveSystemPrompt}\n\n${playwrightNote}`;
+      turnReminders.push(
+        "<system-reminder>Playwright browser tools are UNAVAILABLE this turn. The `mcp__playwright__*` tools have been removed from this turn's catalog because the long-lived browser MCP could not be prepared. Do not attempt to call browser tools. If browser interaction is required, ask the user to retry shortly or use a non-browser alternative.</system-reminder>",
+      );
     }
+    // The system prompt is now byte-identical across turns of a topic, so the
+    // provider's prefix cache survives; per-turn facts ride the prompt tail.
+    const effectivePrompt =
+      turnReminders.length > 0 ? `${agentPrompt}\n\n${turnReminders.join("\n\n")}` : agentPrompt;
 
     try {
       yield* runAgent({
         agent: agentKind,
-        prompt: agentPrompt,
+        prompt: effectivePrompt,
         attachments: promptAttachments,
         cwd: workspaceCwd,
-        systemPrompt: effectiveSystemPrompt,
+        systemPrompt,
         sessionId,
         userId,
         vaultUserId,

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.2.7";
+export const NEGOTIUM_VERSION = "0.2.9";

package/dist/runtime-helpers.js

@@ -451,7 +451,7 @@ var DM_WORKSPACE_DIR = resolve(STATE_DIR, "data", "dm");
 var SESSION_WORKSPACE_DIR = resolve(STATE_DIR, "data", "sessions");
 var CLAUDE_EXECUTABLE_ENV = envText("NEGOTIUM_CLAUDE_EXECUTABLE");
 var CLAUDE_EXECUTABLE = CLAUDE_EXECUTABLE_ENV ? resolve(CLAUDE_EXECUTABLE_ENV) : undefined;
-var BROWSER_RS_VERSION = "v0.1.16";
+var BROWSER_RS_VERSION = "v0.1.17";
 var BROWSER_RS_MIN_SECURE_VERSION = "0.1.15";
 function versionAtLeast(actualVersion, minimumVersion) {
   const actual = actualVersion.split(".").map(Number);
@@ -1132,4 +1132,4 @@ export {
   CLAUDE_EFFORT_VALUES
 };
 
-//# debugId=38CF47A0C3C063A564756E2164756E21
+//# debugId=078B7BFBF513B96264756E2164756E21