agentus 0.6.1 → 0.8.0

package/packages/server/src/index.ts

@@ -23,6 +23,7 @@ import { dictationContext, hotwordsFor, vocabularyOf } from "./hotwords.js";
 import { openDashscopeStream, summarizeForSpeech } from "./dashscope.js";
 import {
   SUMMARY_CHARS_RANGE, SUMMARY_MODEL_DEFAULT, SUMMARY_PROMPT_DEFAULT,
+  SUMMARY_MAX_INPUT_CHARS, SUMMARY_THINKING_BUDGET,
   agentSettings, getSettings, initSettings, observerSettings, planHintSettings, publicSettings,
   saveAgent, saveCall, saveObserver, savePrefs, saveSettings, saveSummary, saveTheme, summarySettings,
 } from "./settings.js";
@@ -760,7 +761,26 @@ const handleRequest = async (req: IncomingMessage, res: ServerResponse) => {
         if (!sendOk) return send(res, 403, { error: COCKPIT_ERRORS.sendsDisabled });
         const target = rowOf(to);
         if (!target) return send(res, 404, { error: COCKPIT_ERRORS.outOfScope });
-        if (target.cold) return send(res, 409, { error: COCKPIT_ERRORS.targetCold });
+        // #41: a cold target used to end the conversation here. Waking is now EXPLICIT (`--wake`),
+        // because it costs a process — but refusing every cold send made cross-session work
+        // unusable, since the idle reaper keeps targets cold by design.
+        const wantWake = body.wake === true;
+        let woke = false;
+        if (target.cold) {
+          if (!wantWake) {
+            return send(res, 409, {
+              error: COCKPIT_ERRORS.targetCold,
+              message: "the target has no running process; pass --wake (wake:true) to start it, then the message is delivered in the same call",
+              wakeable: !target.archivedAt,
+            });
+          }
+          try {
+            await mgr.resume(to);
+            woke = true;
+          } catch (e) {
+            return send(res, 409, { error: COCKPIT_ERRORS.wakeFailed, message: String((e as Error)?.message ?? e) });
+          }
+        }
         // Deliberately NOT `interrupt`: a cross-session message must never take the floor from a turn
         // the OPERATOR started. A busy target answers `target_busy` and the caller reports it as such.
         try {
@@ -774,7 +794,24 @@ const handleRequest = async (req: IncomingMessage, res: ServerResponse) => {
           const why = String((e as Error)?.message ?? e);
           return send(res, 409, { error: why.includes("turn already running") ? COCKPIT_ERRORS.targetBusy : why });
         }
-        return send(res, 200, { delivered: true, to, code: "delivered" });
+        return send(res, 200, { delivered: true, to, code: "delivered", ...(woke ? { delivered_after_wake: true } : {}) });
+      }
+      if (url.pathname === "/api/cockpit/wake" && req.method === "POST") {
+        const body = await readJson(req);
+        const id = String(body.id ?? "");
+        if (!id) return send(res, 400, { error: COCKPIT_ERRORS.badRequest });
+        // Same gate as send (#41): waking is what makes a send possible, so the two answers must
+        // never disagree about whether an agent may pull another session's process up.
+        if (!sendOk) return send(res, 403, { error: COCKPIT_ERRORS.sendsDisabled });
+        const target = rowOf(id);
+        if (!target) return send(res, 404, { error: COCKPIT_ERRORS.outOfScope });
+        if (!target.cold) return send(res, 200, { schema_version: COCKPIT_SCHEMA_VERSION, woke: false, already_live: true, id });
+        try {
+          const info = await mgr.resume(id);
+          return send(res, 200, { schema_version: COCKPIT_SCHEMA_VERSION, woke: true, id, status: info.status });
+        } catch (e) {
+          return send(res, 409, { error: COCKPIT_ERRORS.wakeFailed, message: String((e as Error)?.message ?? e) });
+        }
       }
       return send(res, 404, { error: "unknown cockpit command" });
     }
@@ -1592,12 +1629,19 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
           const row = store.getSession(id);
           if (!row) return { route: null, why: "会话不在库里" };
           const be = store.listBackends().find((b) => b.id === row.backend);
-          const models = (row.models ?? {}) as { currentModelId?: string | null };
+          // LIVE first, store second (#36). The ACP handshake reports the model, and the live
+          // session object holds it — but `sessions.models` is flushed later (observed: JSON null
+          // for every row on this box), so reading the store alone answered 「agent 未握手」 and
+          // every summary silently fell back to the voice endpoint's qwen-flash.
+          const live = mgr.list().find((s) => s.id === id);
+          const modelId = live?.models?.currentModelId
+            ?? ((row.models ?? {}) as { currentModelId?: string | null }).currentModelId
+            ?? null;
           // The provider keys live in this box's agent home, which is a property of the runtime —
           // not of the vendor that happens to be driving this session. A backend that owns no home
           // (mock, qoder) therefore still resolves a `deepseek:…` model through the Hermes home.
           const home = (be ? planFor(be).home : null) ?? HERMES_DEFAULT_HOME;
-          return routeForModel(models.currentModelId ?? null, home);
+          return routeForModel(modelId, home);
         };
         // 语音总结 (the message speaker's long press): ONE stored message, made listenable.
         //
@@ -1627,6 +1671,18 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
         if (spoken.length <= maxChars) {
           return send(res, 200, { ok: true, via: "verbatim", text: spoken, chars: spoken.length, ms: 0, maxChars });
         }
+        // Over the ceiling we REFUSE, loudly (#36). The old behaviour summarised the head and said
+        // so in a footnote — but a summary that drops the second half is worse than none, because
+        // that is where the conclusion lives. 20k chars is far above any reply worth listening to
+        // and still stops a pasted 200 KB log from becoming an invoice.
+        if (spoken.length > SUMMARY_MAX_INPUT_CHARS) {
+          return send(res, 409, {
+            error: `这条消息 ${spoken.length} 字，超出语音总结上限 ${SUMMARY_MAX_INPUT_CHARS} 字 —— 直接朗读，或截取要听的那段`,
+            code: "too_long",
+            chars: spoken.length,
+            limit: SUMMARY_MAX_INPUT_CHARS,
+          });
+        }
         try {
           // The operator's rule: bill this to the model he is already talking to. The voice
           // endpoint stays as the fallback (and is the whole route when followSession is off).
@@ -1638,6 +1694,10 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
             prompt: cfg.prompt.trim() || SUMMARY_PROMPT_DEFAULT,
             model,
             timeoutSec: cfg.timeoutSec,
+            // Thinking stays ON for qwen3 models, capped at 200 tokens (operator's call, #36):
+            // a little reasoning reads the sentence better than none, and 200 keeps it from
+            // wandering the way the default 4000 did (measured 235 output tokens on a 40-char ask).
+            thinkingBudget: /^qwen3/i.test(model) ? SUMMARY_THINKING_BUDGET : undefined,
             endpoint: own.route ? { baseUrl: own.route.baseUrl, apiKey: own.route.apiKey } : undefined,
           });
           // Newlines are the one thing the model keeps ignoring: 「不要换行」 in the prompt is a
@@ -1649,7 +1709,7 @@ async function post(path){const r=await fetch(path,{method:'POST'});alert(r.ok?'
             // echo the bucket: the note prints 「约 150 字」 and a summary that silently used the
             // configured number would make the menu look broken
             maxChars,
-            ms: r.ms, truncated: r.truncated, model,
+            ms: r.ms, model,
             // which account this call was billed to — the note prints it, and a fallback that
             // silently used the OTHER provider would be a lie about the cost
             route: own.route ? "session" : "voice",

package/packages/server/src/settings.ts

@@ -189,10 +189,16 @@ export interface AgentSettings {
    *  this is what the CLI and the gateway already do, and the failure it prevents is the silent one —
    *  a session that looks finished while a build is still running, whose result nobody ever reads. */
   completionWake: boolean;
+  /** 显示不唤醒的后台进程 (issue #35). OFF by default: the row and the rail badge answer
+   *  「这个会话还在干活吗」, and a silent process the agent is polling itself is noise — the
+   *  agent knows it is there, the operator does not need to. Turned ON, every running process
+   *  shows, which is what the fork's original "a snapshot is the only witness" design wanted. */
+  showSilentBackground: boolean;
 }
 
 export const AGENT_DEFAULT: AgentSettings = {
   idleKillMin: 5, warmSlots: 5, warmTtlHours: 24, cockpitSend: false, completionWake: true,
+  showSilentBackground: false,
 };
 
 /** The numeric half of `AgentSettings` — the keys the range-checked helpers may write. */
@@ -298,8 +304,26 @@ export const SUMMARY_CHARS_RANGE: [number, number] = [40, 400];
 export const SUMMARY_TIMEOUT_RANGE: [number, number] = [5, 60];
 /** Measured against this operator's workspace, 2026-10-18: `qwen-flash` answered a 40-character
  *  ask with 67 prompt / 20 completion tokens. `qwen3-flash` and `qwen-turbo` are 404 there ("Model
- *  not exist"), and `qwen3.8-flash` spent 235 output tokens thinking about the same sentence. */
-export const SUMMARY_MODEL_DEFAULT = "qwen-flash";
+ *  not exist"), and `qwen3.8-flash` spent 235 output tokens thinking about the same sentence.
+ *
+ *  2026-10-20 (operator's call): the fallback IS `qwen3.8-flash` anyway — it is the model this
+ *  workspace already talks to, and `qwen-flash` was a second vendor's answer to a problem that has
+ *  a proper knob. The 235-token overspend is what `SUMMARY_THINKING_BUDGET` below exists for:
+ *  thinking stays ON (it reads the message better) but is capped at 200 tokens. */
+export const SUMMARY_MODEL_DEFAULT = "qwen3.8-flash";
+
+/** Thinking cap for qwen3-family models, in tokens (`thinking_budget`). 200 is deliberate: enough
+ *  to hold the sentence together, too small to wander — measured 235 → 200 keeps the visible
+ *  answer intact at a fifth of the default 4000. NOT used for non-qwen3 models (DeepSeek ignores
+ *  the field, and sending it there would be a lie about what we asked for). */
+export const SUMMARY_THINKING_BUDGET = 200;
+
+/** The most characters this feature will ever hand a model. Above it the call is REFUSED with a
+ *  visible 409 instead of quietly summarising the head (#36) — a summary that silently drops the
+ *  second half is worse than no summary, because the conclusion usually lives there. 20k ≈ 10k
+ *  tokens: longer than any agent reply worth listening to, short enough that a pasted 200 KB log
+ *  cannot turn one long press into a bill. */
+export const SUMMARY_MAX_INPUT_CHARS = 20_000;
 
 export const SUMMARY_PROMPT_DEFAULT = [
   "下面是我在一个工作会话里拿到的一段输出。请把它改写成一段「用嘴念出来」的摘要：",
@@ -492,6 +516,7 @@ function pickAgent(raw: unknown): AgentSettings {
     take("warmTtlHours", AGENT_WARM_TTL_RANGE);
     if (typeof r.cockpitSend === "boolean") out.cockpitSend = r.cockpitSend;
     if (typeof r.completionWake === "boolean") out.completionWake = r.completionWake;
+    if (typeof r.showSilentBackground === "boolean") out.showSilentBackground = r.showSilentBackground;
   }
   return out;
 }
@@ -807,6 +832,10 @@ export function saveAgent(patch: Record<string, unknown>): Settings {
     if (typeof patch.completionWake !== "boolean") throw new Error("invalid completionWake: expected true or false");
     a.completionWake = patch.completionWake;
   }
+  if ("showSilentBackground" in patch) {
+    if (typeof patch.showSilentBackground !== "boolean") throw new Error("invalid showSilentBackground: expected true or false");
+    a.showSilentBackground = patch.showSilentBackground;
+  }
   cache = { ...cache, agent: a, updatedAt: Date.now() };
   persist();
   return cache;

package/packages/server/src/speech/route.ts

@@ -56,8 +56,10 @@ const BUILTIN: Record<string, { baseUrl: string; keys: string[]; baseEnv?: strin
 
 /**
  * ACP model ids arrive as `deepseek:deepseek-v4-flash` (provider prefix, wire form) or
- * `openrouter:anthropic/claude-x`; older agents use `provider/model`. Returns "" for a bare id
- * with no prefix — the caller then has to ask config.yaml who owns it.
+ * `openrouter:anthropic/claude-x`. Returns "" for a bare id with no prefix — the caller then has to
+ * ask config.yaml who owns it. The `provider/model` form is NOT handled here (a prefix here can be
+ * a vendor namespace rather than a provider); `slashProvider()` below resolves it with the provider
+ * tables in hand (#36).
  */
 export function splitModelId(raw: string | null | undefined): { provider: string; model: string } {
   const id = String(raw ?? "").trim();
@@ -91,6 +93,21 @@ function readConfig(home: string | null): Record<string, unknown> {
 const asString = (v: unknown): string => (typeof v === "string" ? v.trim() : typeof v === "number" ? String(v) : "");
 const trimSlash = (u: string): string => u.replace(/\/+$/, "");
 
+/**
+ * `provider/model` — the second id form a session can report. Only stripped when the prefix really
+ * names a provider this box knows (declared in config.yaml or in the builtin table): a catalogue
+ * slug like `anthropic/claude-x` must survive intact, or an OpenRouter model id would be mangled
+ * into provider `anthropic` + model `claude-x`.
+ */
+function slashProvider(cfgProviders: Record<string, unknown>, model: string): { provider: string; model: string } {
+  const slash = model.indexOf("/");
+  if (slash <= 0) return { provider: "", model };
+  const cand = model.slice(0, slash).trim().toLowerCase();
+  if (!(cand in BUILTIN) && !(cand in cfgProviders)) return { provider: "", model };
+  const rest = model.slice(slash + 1).trim();
+  return rest ? { provider: cand, model: rest } : { provider: "", model };
+}
+
 /**
  * Resolve the route for one session's model. `home` is the home of the backend that session runs
  * on (`planFor(row).home`) — reading a DIFFERENT agent's config would hand this call a key its
@@ -101,10 +118,19 @@ export function routeForModel(modelId: string | null | undefined, home: string |
   why: string;
 } {
   const parsed = splitModelId(modelId);
-  const model = parsed.model;
-  if (!model) return { route: null, why: "会话还没报出模型（agent 未握手）" };
+  if (!parsed.model) return { route: null, why: "会话还没报出模型（agent 未握手）" };
 
   const cfg = readConfig(home);
+  // Slash form is a LAST resort after the colon form (#36): `deepseek/deepseek-v4-flash` is what
+  // this session reports, and before this the split returned no provider at all, so the summary
+  // silently fell back to the voice endpoint on `qwen-flash`.
+  const slash = parsed.provider
+    ? { provider: parsed.provider, model: parsed.model }
+    : slashProvider(
+        (cfg.providers && typeof cfg.providers === "object" ? cfg.providers : {}) as Record<string, unknown>,
+        parsed.model,
+      );
+  const model = slash.model;
   // An alias row may rename the model as well as point at a provider (`lab-qwen38-27b` →
   // `qwen38-27b`); the wire id is not the name the vendor knows.
   const aliasRow = (aliases: Record<string, unknown>): Record<string, unknown> | null => {
@@ -121,7 +147,7 @@ export function routeForModel(modelId: string | null | undefined, home: string |
   // Who owns this model? The id's own prefix wins; otherwise config.yaml's default provider, and
   // only when the model really is that default (a session can be running a model the default no
   // longer names — then guessing the provider would send the request to the wrong vendor).
-  let provider = parsed.provider;
+  let provider = slash.provider;
   if (!provider) {
     if (aliasNow) provider = asString(aliasNow.provider).toLowerCase();
   }

package/packages/server/src/store/store.ts

@@ -3,7 +3,7 @@
 // messages carry monotonic per-session `seq` (reconnect replay anchor, AC6).
 import fs from "node:fs";
 import { DatabaseSync } from "node:sqlite";
-import type { BackendId, PlanSnapshot, SessionStatus, StoredMessage } from "../../../shared/src/index.js";
+import type { BackendId, PlanSnapshot, SessionStatus, StatusNoteItem, StoredMessage } from "../../../shared/src/index.js";
 import type { BackendHandshake, BackendHealth, BackendKind, BackendRow } from "../acp/registry.js";
 import { normalizeItems } from "../plan/plan.js";
 import { DEFAULT_NATIVE_PLAN_SOURCE } from "../acp/backends.js";
@@ -965,7 +965,11 @@ export class Store {
    * （说明这中间没有别的消息落下），就更新它，而不是再加一行；位置变了（新消息进来了）就另起一行。
    * 于是「压缩中 → 完成」收敛成一行（保留开始时间），一个回合一次回忆也只留一行。
    */
-  appendNote(sessionId: string, note: { category: string; text: string; createdAt?: number }): StoredMessage {
+  appendNote(sessionId: string, note: {
+    category: string; text: string; createdAt?: number;
+    /** memory 行的条目（issue #37）—— 只在 category==="memory" 时有意义。 */
+    items?: StatusNoteItem[]; truncated?: boolean;
+  }): StoredMessage {
     const createdAt = note.createdAt ?? Date.now();
     const edge = this.#db
       .prepare("select coalesce(max(seq),0) as seq from messages where session_id = ?")
@@ -974,9 +978,18 @@ export class Store {
       .prepare("select seq, payload, created_at from messages where session_id = ? and kind = 'note' order by seq desc limit 1")
       .get(sessionId) as { seq: number; payload: string; created_at: number } | undefined;
     if (last && last.seq === edge.seq) {
-      const prev = JSON.parse(last.payload) as { category?: string; text?: string; hits?: number };
+      const prev = JSON.parse(last.payload) as {
+        category?: string; text?: string; hits?: number; items?: StatusNoteItem[]; truncated?: boolean;
+      };
       if (prev.category === note.category) {
-        const payload = { category: note.category, text: note.text, hits: (prev.hits ?? 1) + 1 };
+        // 折叠只发生在「位置上没有别的消息插进来」时（压缩的开始/心跳/完成）。条目取**最新一次**：
+        // 折叠出来的是同一行，这行的内容是最后一次召回，而不是第一次的残留。
+        const payload: Record<string, unknown> = {
+          category: note.category, text: note.text, hits: (prev.hits ?? 1) + 1,
+        };
+        const items = note.items ?? prev.items;
+        if (items?.length) payload.items = items;
+        if (note.truncated ?? prev.truncated) payload.truncated = true;
         // `created_at` stays: it answers "这一轮什么时候开始回忆/压缩的", and the heartbeat is not news.
         this.#db
           .prepare("update messages set payload = ? where session_id = ? and seq = ?")
@@ -986,9 +999,10 @@ export class Store {
         };
       }
     }
-    const row = this.appendMessage({
-      sessionId, kind: "note", payload: { category: note.category, text: note.text, hits: 1 }, createdAt,
-    });
+    const payload: Record<string, unknown> = { category: note.category, text: note.text, hits: 1 };
+    if (note.items?.length) payload.items = note.items;
+    if (note.truncated) payload.truncated = true;
+    const row = this.appendMessage({ sessionId, kind: "note", payload, createdAt });
     // Bounded: a session left open for weeks must not keep every recall it ever did. 80 is well past
     // what any transcript page shows, and a note is ~120 bytes.
     const over = this.#db

package/packages/shared/src/index.ts

@@ -263,6 +263,21 @@ export interface BackgroundTask {
   status: "running" | "exited";
   uptimeSeconds?: number;
   exitCode?: number | null;
+  /** What this row IS (issue #39). `process` = a `terminal(background=true)` child in the process
+   *  registry; `delegation` = a live `delegate_task(background=true)` subagent, which never appears
+   *  there. Absent on frames from an older agent, and absent must read as `process`: that is what
+   *  every field above has always meant. */
+  kind?: "process" | "delegation";
+  /** Delegations only: the ledger's own phase (`running` / `stalling` / `finalizing`). `status`
+   *  stays the host's two-state vocabulary, so a `finalizing` child still reads as running. */
+  phase?: string;
+  /** Delegations only: how many children one row stands for (a batch of N counts N). */
+  taskCount?: number;
+  /** Does this process OWE the session a wake-up (`notify_on_complete`)? Issue #35: that is the
+   *  difference between 「agent 已经收工」 and 「agent 还在等这次唤醒才能继续」. Optional — an
+   *  older agent never sends it, and `undefined` must read as "silent", never as "unknown so
+   *  show it anyway". */
+  notifyOnComplete?: boolean;
 }
 
 export interface WebNotice {
@@ -429,6 +444,18 @@ export type ClientCommand =
       signature?: string; // "<kind>:<toolCallTitle>" for always-allow memory
     };
 
+/** 一条记忆召回条目 —— `note` 行 `payload.items` 的元素（issue #37）。
+ *
+ *  「recalled 8 memories」只说记忆被用上了，没说用上的是哪几条，于是「召回错了/召回旧了」和
+ *  「召回得好」在屏幕上长得一模一样。条目由 provider 侧截断（200 字符/条、6K/轮），server 再按
+ *  自己的上限（20 条 / 300 字符）限一次，因为这条数据来自 agent 进程并且要落库。
+ */
+export interface StatusNoteItem {
+  text: string;
+  tags?: string[];
+  type?: string;
+}
+
 export interface StoredMessage {
   seq: number; // monotonic per session — reconnect dedup anchor
   sessionId: string;