agentus 0.2.0 → 0.3.0

package/packages/server/src/settings.ts

@@ -114,6 +114,24 @@ export const CALL_DEFAULT: CallSettings = {
 
 export const INTERRUPT_MODES: InterruptMode[] = ["voice", "button"];
 
+/** How the cockpit treats AGENT PROCESSES — as opposed to what a conversation contains. AionUi
+ *  ships the same knob in 设置 → 系统 as 「Agent 空闲超时（分钟）」 (default 5, 1–60, step 5) with the
+ *  honest description 「空闲超过该时长后自动终止 Agent 进程以释放内存」. Agentus keeps that meaning
+ *  and adds ONE thing AionUi does not have: 0 = 关闭. A cockpit deliberately left holding a
+ *  long-running slot (a build, a tunnel watcher, a call) must be able to say "never reclaim this",
+ *  and "set it to 60 and hope" is not the same statement. */
+export interface AgentSettings {
+  /** minutes of no activity before a live slot's agent process is stopped to reclaim memory;
+   *  0 = never. The row and its transcript always survive — this only stops the process. */
+  idleKillMin: number;
+}
+
+export const AGENT_DEFAULT: AgentSettings = { idleKillMin: 5 };
+
+/** What the settings page may offer: the ends of the number field. Server-side enforcement uses
+ *  the same pair, so a hand-written request cannot store a nonsense value. */
+export const AGENT_IDLE_RANGE: [number, number] = [0, 60];
+
 /** The NUMERIC knobs. `interruptMode` is a two-way choice, not a slider, so it is deliberately
  *  outside both the range table and the loops that validate numbers. */
 export const CALL_NUMERIC = ["bargeSensitivity", "bargeMs", "silenceMs", "minChars"] as const;
@@ -147,6 +165,7 @@ export interface Settings {
   theme: ThemeSettings;
   call: CallSettings;
   prefs: PrefsSettings;
+  agent: AgentSettings;
   updatedAt: number;
 }
 
@@ -173,7 +192,7 @@ let db: Store | null = null;
 let legacyFile = "";
 let cache: Settings = {
   voice: { ...DEFAULTS }, theme: { ...THEME_DEFAULT }, call: { ...CALL_DEFAULT },
-  prefs: { ...PREFS_DEFAULT }, updatedAt: 0,
+  prefs: { ...PREFS_DEFAULT }, agent: { ...AGENT_DEFAULT }, updatedAt: 0,
 };
 /** keys that came from env/.env (shown as "auto-detected" and used when settings are empty) */
 let envCreds: { apiKey: string; baseUrl: string; source: string } | null = null;
@@ -237,6 +256,7 @@ export function initSettings(dataDir: string, store: Store): Settings {
     theme: { ...THEME_DEFAULT, ...(stored.theme ?? {}) },
     call: pickCall(stored.call),
     prefs: pickPrefs(stored.prefs),
+    agent: pickAgent(stored.agent),
     updatedAt: Number((stored as Settings).updatedAt ?? 0),
   };
   // an unset baseUrl/apiKey bootstrap from the environment: the operator said the
@@ -266,6 +286,20 @@ function pickCall(raw: unknown): CallSettings {
   return out;
 }
 
+/** The agent-process knobs. Out-of-range or unparseable values fall back to the shipped default
+ *  rather than throwing: this section decides whether a slot's process is reclaimed, and a settings
+ *  row that cannot be read must never leave the reaper in an undefined state (an undefined `> 0`
+ *  comparison would silently turn reclaiming OFF — the safe failure is the documented default). */
+function pickAgent(raw: unknown): AgentSettings {
+  const out = { ...AGENT_DEFAULT };
+  if (raw && typeof raw === "object") {
+    const v = Number((raw as Record<string, unknown>).idleKillMin);
+    const [lo, hi] = AGENT_IDLE_RANGE;
+    if (Number.isFinite(v) && v >= lo && v <= hi) out.idleKillMin = v;
+  }
+  return out;
+}
+
 function pickPrefs(raw: unknown): PrefsSettings {
   const out = { ...PREFS_DEFAULT };
   if (raw && typeof raw === "object") {
@@ -289,6 +323,7 @@ function persist(): void {
     db.setSetting("theme", cache.theme);
     db.setSetting("call", cache.call);
     db.setSetting("prefs", cache.prefs);
+    db.setSetting("agent", cache.agent);
   } catch (e) {
     console.error(`[agentus] cannot write settings: ${(e as Error).message}`);
   }
@@ -331,6 +366,9 @@ export function publicSettings(): Record<string, unknown> {
     hotwordLimit: v.hotwordLimit,
     prefs: cache.prefs,
     prefsDefaults: PREFS_DEFAULT,
+    agent: cache.agent,
+    agentDefaults: AGENT_DEFAULT,
+    agentIdleRange: AGENT_IDLE_RANGE,
     // the defaults, so the UI can offer "reset to Bailian defaults"
     defaults: { ...DEFAULTS, apiKey: undefined, baseUrl: undefined },
     updatedAt: cache.updatedAt,
@@ -456,6 +494,31 @@ export function savePrefs(patch: Record<string, unknown>): Settings {
   return cache;
 }
 
+/** Agent-process knobs: its own update, like theme/call, so a bad number here cannot lock the
+ *  operator out of the page that would fix it. Range-checked against AGENT_IDLE_RANGE before it is
+ *  stored — this number decides whether agent processes get killed, so it is not a text field. */
+export function saveAgent(patch: Record<string, unknown>): Settings {
+  const a = { ...cache.agent };
+  if ("idleKillMin" in patch) {
+    const raw = typeof patch.idleKillMin === "number" ? patch.idleKillMin : Number(patch.idleKillMin);
+    const [lo, hi] = AGENT_IDLE_RANGE;
+    if (!Number.isFinite(raw) || raw < lo || raw > hi) {
+      throw new Error(`invalid idleKillMin: ${JSON.stringify(patch.idleKillMin)} (expected ${lo}…${hi} minutes, 0 = off)`);
+    }
+    a.idleKillMin = raw;
+  }
+  cache = { ...cache, agent: a, updatedAt: Date.now() };
+  persist();
+  return cache;
+}
+
+/** The agent-process knobs as the reaper reads them — on every tick, so a settings change applies
+ *  without a restart. Returns the live cache object, not a copy: a caller that wants a snapshot has
+ *  no business holding this one. */
+export function agentSettings(): AgentSettings {
+  return cache.agent;
+}
+
 /** Normalise the two URL shapes operators paste: MaaS root or .../compatible-mode/v1. */
 export function dashscopeUrls(baseUrl: string): { root: string; compat: string; ws: string } {
   const trimmed = baseUrl.replace(/\/+$/, "");

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

@@ -75,6 +75,9 @@ export interface SessionRow {
   pid: number | null;
   createdAt: number;
   closedAt: number | null;
+  /** When the OPERATOR put this session away (已归档). Null = it belongs in 工作空间. A storage
+   *  state: it says nothing about whether a process is running (see SessionInfo.archivedAt). */
+  archivedAt: number | null;
   /** JSON round-trip of the ACP mode state + config options, so a resumed
    *  session (M4-lite) comes back with the operator's mode/effort intact. */
   modes?: unknown;
@@ -105,7 +108,7 @@ export interface SessionRow {
 interface RawSessionRow {
   id: string; backend: BackendId; acp_session_id: string | null; cwd: string;
   title: string; auto_title?: string | null; status: SessionStatus; pid: number | null;
-  created_at: number; closed_at: number | null;
+  created_at: number; closed_at: number | null; archived_at?: number | null;
   modes?: string | null; config_options?: string | null;
   usage?: string | null; commands?: string | null;
   workspace?: string | null;
@@ -169,7 +172,7 @@ function rowToSession(r: RawSessionRow): SessionRow {
   return {
     id: r.id, backend: r.backend, acpSessionId: r.acp_session_id, cwd: r.cwd,
     title: r.title, autoTitle: r.auto_title ?? null, status: r.status, pid: r.pid,
-    createdAt: r.created_at, closedAt: r.closed_at,
+    createdAt: r.created_at, closedAt: r.closed_at, archivedAt: r.archived_at ?? null,
     modes: parseJson(r.modes), configOptions: parseJson(r.config_options) ?? [],
     usage: parseJson(r.usage), commands: parseJson(r.commands) ?? [],
     workspace: r.workspace ?? null,
@@ -182,6 +185,7 @@ function rowToSession(r: RawSessionRow): SessionRow {
 interface RawBackendRow {
   id: string; label: string; kind: string; cmd: string; args: string; env: string;
   home: string | null; profile: string | null; cwd: string | null; notes: string;
+  default_mode: string | null;
   native_plan_source: string | null;
   builtin: number; created_at: number; updated_at: number;
   // health snapshot (M6.1) — system-written, see registry.BackendHealth
@@ -212,6 +216,9 @@ function rowToBackend(r: RawBackendRow): BackendRow {
     home: r.home ?? null,
     profile: r.profile ?? null,
     cwd: r.cwd ?? null,
+    // A row predating the column (or a seeded one) says nothing: send no mode at all, so the agent
+    // keeps its own default. No mode name is invented here — "缺省" must mean "不上手".
+    defaultMode: (r.default_mode ?? "").trim() || null,
     notes: r.notes ?? "",
     builtin: r.builtin === 1,
     health: {
@@ -304,6 +311,8 @@ export class Store {
         id text primary key, label text not null, kind text not null,
         cmd text not null, args text not null default '[]', env text not null default '{}',
         home text, profile text, cwd text, notes text not null default '',
+        -- the ACP mode a NEW session from this row starts in (null = the agent's own default)
+        default_mode text,
         builtin integer not null default 0,
         created_at integer not null, updated_at integer not null
       );
@@ -334,6 +343,13 @@ export class Store {
     this.#db.exec("update sessions set auto_title = title where auto_title is null or auto_title = ''");
     // integer column, so it gets its own migration (the loop above assumes text)
     if (!cols.has("context_limit")) this.#db.exec("alter table sessions add column context_limit integer");
+    // WHEN THE OPERATOR PUT THE SESSION AWAY (已归档 — a STORAGE state). Before this column the rail
+    // inferred "archived" from "has no process", so a slot that merely crashed (or was killed by an
+    // idle reap) filed itself under 已归档 next to the ones the operator really put away, and
+    // 「我在归档一栏里看到的」 stopped meaning anything. NULL is the honest default for every existing
+    // row: nobody ever archived them, they were just dead. The 已归档 section starts empty and fills
+    // with what the operator actually archives.
+    if (!cols.has("archived_at")) this.#db.exec("alter table sessions add column archived_at integer");
     // The session's own ACTIVITY clock — when the operator or the agent last really said something
     // in it. A COLUMN, not a derived `max(messages.created_at)` (AionUi's model: `modified_at` on
     // the conversation row, indexed, which is what its sidebar sorts by): every ingestion path
@@ -362,6 +378,9 @@ export class Store {
       // P1 (plan service): which channel carries this backend's plan, `acp` | `none`. Nullable on
       // purpose — a row that predates it follows the same default as a seeded one (see rowToBackend).
       "native_plan_source",
+      // The permission mode a new session starts in. Nullable like the rest: a row that predates the
+      // column means "send nothing" (the agent's own default), not "some mode we invented".
+      "default_mode",
     ]) {
       if (!beCols.has(col)) this.#db.exec(`alter table backends add column ${col} text`);
     }
@@ -693,6 +712,16 @@ export class Store {
     }
   }
 
+  /** Put this session away — or take it back out (已归档). Its OWN statement, like `home`: the
+   *  archive flag is the one thing the operator sets directly, and a routine row upsert (a status
+   *  change, a rename, an idle reap) must not be able to clear it. Returns whether a row matched. */
+  setArchived(sessionId: string, at: number | null): boolean {
+    const info = this.#db
+      .prepare("update sessions set archived_at = ? where id = ?")
+      .run(at, sessionId);
+    return Number(info.changes ?? 0) > 0;
+  }
+
   /** Record (or adopt) the home a session was created under. Used when a legacy row — created
    *  before the column existed — is resumed successfully: the successful load is itself the
    *  proof of which home holds its state, so the row stops being ambiguous. */
@@ -1153,16 +1182,18 @@ export class Store {
     this.#db
       .prepare(
         `insert into backends (id, label, kind, cmd, args, env, home, profile, cwd, notes,
+                               default_mode,
                                native_plan_source,
                                builtin, created_at, updated_at,
                                last_check_status, last_check_kind, last_check_error_code,
                                last_check_error_message, last_check_guidance, last_check_latency_ms,
                                last_check_at, last_success_at, last_failure_at, handshake, handshake_at)
-         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          on conflict(id) do update set
            label = excluded.label, kind = excluded.kind, cmd = excluded.cmd, args = excluded.args,
            env = excluded.env, home = excluded.home, profile = excluded.profile, cwd = excluded.cwd,
            notes = excluded.notes,
+           default_mode = excluded.default_mode,
            native_plan_source = excluded.native_plan_source,
            updated_at = excluded.updated_at,
            -- the evidence travels with the row: a spawn-relevant edit replaces it with a cleared
@@ -1179,6 +1210,7 @@ export class Store {
       .run(
         row.id, row.label, row.kind, row.cmd, JSON.stringify(row.args), JSON.stringify(row.env ?? {}),
         row.home, row.profile, row.cwd, row.notes ?? "",
+        row.defaultMode ?? null,
         row.nativePlanSource ?? null,
         row.builtin ? 1 : 0, row.createdAt, row.updatedAt,
         row.health?.status ?? null, row.health?.kind ?? null, row.health?.errorCode ?? null,

package/packages/shared/src/index.ts

@@ -22,6 +22,7 @@ export type SessionStatus =
   | "starting" // subprocess spawned, initialize/newSession in flight
   | "ready" // accepts prompts
   | "running" // a prompt turn is in flight
+  | "reaped" // no process: it was idle past the operator's threshold (settings.agent.idleKillMin)
   | "error" // subprocess died or handshake failed
   | "closed";
 
@@ -74,6 +75,15 @@ export interface SessionInfo {
    *  This — not `createdAt`, and not `lastSeq` (a per-session counter) — is what the rail
    *  orders by: "which of these did I last talk to". */
   lastAt?: number;
+  /** The operator PUT THIS SESSION AWAY: it belongs in the rail's 已归档 section, whatever its
+   *  process is doing. This is a STORAGE state, not a liveness one — the rail used to infer
+   *  `archived` from `has no process`, which filed a crashed slot and a deliberately archived
+   *  one in the same place (the operator's complaint: 「我设想的点击归档是一种存储态」). */
+  archivedAt?: number | null;
+  /** No agent process right now — it was closed, it crashed, or it was REAPED for being idle.
+   *  Derived server-side and sent with the row, so the client never infers liveness from which
+   *  list a row arrived in (that inference is what merged 已归档 with 死了). */
+  cold?: boolean;
 }
 
 export interface AvailableCommandView {
@@ -148,7 +158,7 @@ export interface PermissionDiff {
 // ---- WS envelope (server -> browser) ----
 export type ServerEvent =
   | { t: "hello"; clientId: string; resumed: boolean }
-  | { t: "sessions"; sessions: SessionInfo[]; /** requests already waiting for an answer, so a page that connects or refreshes learns about them (they are STATE; the events happened before it existed) */ pending?: PermissionRequestView[] }
+  | { t: "sessions"; sessions: SessionInfo[]; /** rows on disk with NO process and no archive flag — they belong in 工作空间 beside the live ones (a crashed slot must not look archived, and must not vanish from the rail either) */ cold?: SessionInfo[]; /** rows the operator explicitly archived (archivedAt set) — the 已归档 section, whatever their process state */ archived?: SessionInfo[]; /** requests already waiting for an answer, so a page that connects or refreshes learns about them (they are STATE; the events happened before it existed) */ pending?: PermissionRequestView[] }
   | { t: "session"; session: SessionInfo }
   | { t: "messages"; sessionId: string; messages: StoredMessage[]; hasMore: boolean; partial?: boolean }
   | { t: "message"; message: StoredMessage; /** text to APPEND for a streamed block that grew (absent