@anytowork/cli 0.12.26 → 0.12.28

package/src/listener/run.js

@@ -0,0 +1,384 @@
+// Always-on listener: the running part (plan 01 sections 2.2 to 2.6, with the 11-15 decision that there is no
+// consent step and no on/off switch: installing it IS the default way to connect).
+//
+// What it does:
+//   - waits on the platform's event stream with its own cursor (long waits, no model runs while it waits);
+//   - for every workbench wake-up, starts the Agent's own start command, hands the prompt over on standard input
+//     (never on the command line) and waits for it to finish;
+//   - keeps the owner's quota safe: one run per session at a time, a few sessions in parallel, a gap for Agent-to-Agent
+//     calls, merging of quick messages, a daily limit, and a pause after repeated start failures;
+//   - never stops for network cuts; stops only when the login is gone (exit code 2).
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { getPoll, getListenerInfo, reportListener, getWbReadState, LISTENER_HEADER } from '../api.js';
+import { readCursor } from '../poll-state.js';
+import { resolveCredDir } from '../profile.js';
+import { CLI_VERSION } from '../client-version.js';
+import { WakeQueue } from './queue.js';
+import { buildPrompt, testPrompt } from './prompt.js';
+import { lt } from './text.js';
+import {
+  LISTENER_DEFAULTS, readState, writeState, countRun, runsToday, nextLocalMidnight,
+  readListenerCursor, writeListenerCursor, appendLog, promptsDir,
+} from './config.js';
+
+const RECONNECT_FIRST_MS = 1000;
+const RECONNECT_MAX_MS = 60_000;
+const BUSY_MIN_MS = 5000;
+const BUSY_SPAN_MS = 10_000;
+const QUICK_REPLY_MS = 2000;
+const QUICK_PAUSE_MS = 3000;
+const PAUSED_TICK_MS = 15_000;
+
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/;
+const UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+/** Only ids the platform really sends (a UUID or a plain number) may reach a command line or an environment variable. */
+export function isSafeId(x) {
+  return typeof x === 'string' && SAFE_ID.test(x);
+}
+
+function defaultSleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+/** Quote a path for the system shell (it comes from our own credentials directory, never from a message). */
+export function shellQuote(s, platform = process.platform) {
+  if (platform === 'win32') return `"${String(s).replace(/"/g, '')}"`;
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
+/** Fill {sid} {session_key} {group_id} {prompt_file} in the start command. Values are checked ids or our own paths. */
+export function expandCommand(command, vals, platform = process.platform) {
+  const map = {
+    '{sid}': vals.sid,
+    '{session_key}': vals.sessionKey,
+    '{group_id}': vals.groupId || '',
+    '{prompt_file}': shellQuote(vals.promptFile, platform),
+  };
+  let out = String(command);
+  for (const [k, v] of Object.entries(map)) out = out.split(k).join(String(v));
+  return out;
+}
+
+const ENV_KEEP = ['PATH', 'HOME', 'LANG', 'LC_ALL', 'LC_MESSAGES', 'USER', 'LOGNAME', 'SHELL', 'TMPDIR', 'TEMP', 'TMP',
+  'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'SystemRoot', 'ComSpec', 'ProgramFiles'];
+
+/** The environment of a run: a short safe list + the names the owner chose with --env + the wake details. */
+export function buildRunEnv({ base, cfg, vals, credDir }) {
+  const env = {};
+  for (const k of ENV_KEEP) if (base[k] != null) env[k] = base[k];
+  for (const k of cfg.env || []) if (base[k] != null) env[k] = base[k];
+  env.ANYTOWORK_SID = vals.sid;
+  env.ANYTOWORK_SESSION_KEY = vals.sessionKey;
+  env.ANYTOWORK_GROUP_ID = vals.groupId || '';
+  env.ANYTOWORK_WAKE_ID = vals.wakeId || '';
+  env.ANYTOWORK_WAKE_REASON = vals.reason || '';
+  if (vals.hireId) env.ANYTOWORK_HIRE_ID = vals.hireId;
+  env.ANYTOWORK_PROMPT_FILE = vals.promptFile;
+  // Same identity for every `anytowork chat ...` the Agent runs inside this run (several Agents on one computer).
+  env.ANYTOWORK_CONFIG_DIR = credDir;
+  return env;
+}
+
+/** Start the command through the system shell; resolves with {code, timedOut, error?}. Never rejects. */
+export function defaultExec({ command, input, env, cwd, timeoutMs }) {
+  return new Promise((resolve) => {
+    let done = false;
+    let timedOut = false;
+    let timer = null;
+    const finish = (r) => { if (done) return; done = true; if (timer) clearTimeout(timer); resolve(r); };
+    let child;
+    try {
+      child = spawn(command, {
+        shell: true, env, cwd: cwd || undefined, stdio: ['pipe', 'ignore', 'ignore'],
+        detached: process.platform !== 'win32', windowsHide: true,
+      });
+    } catch { return finish({ code: null, timedOut: false, error: 'spawn' }); }
+    child.on('error', () => finish({ code: null, timedOut: false, error: 'spawn' }));
+    child.on('close', (code) => finish({ code, timedOut }));
+    child.stdin.on('error', () => { /* the command may not read its input */ });
+    try { child.stdin.end(input); } catch { /* same */ }
+    timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        if (process.platform === 'win32') spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+        else process.kill(-child.pid, 'SIGKILL');
+      } catch { try { child.kill('SIGKILL'); } catch { /* already gone */ } }
+    }, timeoutMs);
+  });
+}
+
+function execName(command) {
+  const first = String(command).trim().split(/\s+/)[0] || '';
+  return path.basename(first).slice(0, 40);
+}
+
+export class Listener {
+  /**
+   * @param {object} p { cfg, baseUrl, credOpts, fetchImpl, log, err, deps, classify, flags }
+   *   deps: sleep, nowMs, random, execCommand, listenShouldStop, env — for tests
+   */
+  constructor(p) {
+    this.cfg = { ...LISTENER_DEFAULTS, ...p.cfg };   // saved settings + the built-in safety numbers
+    this.baseUrl = p.baseUrl;
+    this.credOpts = p.credOpts;
+    this.fetchImpl = p.fetchImpl;
+    this.err = p.err || (() => {});
+    this.classify = p.classify;
+    const d = p.deps || {};
+    this.sleep = d.sleep || defaultSleep;
+    this.nowMs = d.nowMs || Date.now;
+    this.random = d.random || Math.random;
+    this.execCommand = d.execCommand || defaultExec;
+    this.shouldStop = d.listenShouldStop || (() => false);
+    this.env = d.env || process.env;
+    this.queue = new WakeQueue({ config: { ...LISTENER_DEFAULTS, ...this.cfg }, nowMs: this.nowMs });
+    this.state = readState(this.credOpts);
+    this.active = new Set();
+    this.timer = null;
+    this.lastPlatformCheck = 0;
+    this.credDir = resolveCredDir(this.credOpts);
+  }
+
+  // ---- state helpers ---------------------------------------------------------------------------------
+  save() { writeState(this.state, this.credOpts); }
+  logLine(line) { appendLog(this.credOpts, line, this.nowMs()); }
+  isPaused() { return !!this.state.paused; }
+
+  async report(body) {
+    try {
+      await reportListener(this.baseUrl, this.credOpts, {
+        os: process.platform, exec_name: execName(this.cfg.exec), cli_version: CLI_VERSION, ...body,
+      }, { fetchImpl: this.fetchImpl });
+    } catch { /* an older platform has no report route; never stop for it */ }
+  }
+
+  pause(reason, detail) {
+    const now = this.nowMs();
+    this.state.paused = { reason, at: now, detail: detail || null };
+    this.queue.clearWaiting();
+    this.save();
+    this.logLine(`paused reason=${reason}${detail ? ` detail=${detail}` : ''}`);
+    if (reason === 'fail' || reason === 'cap') {
+      this.report({
+        state: 'paused', reason, fails: this.state.fails, last_error: detail || undefined,
+        runs_today: runsToday(this.state, now),
+      });
+    }
+  }
+
+  resume(how) {
+    this.state.paused = null;
+    this.state.fails = 0;
+    this.save();
+    this.logLine(`resumed by=${how}`);
+    this.report({ state: 'running', runs_today: runsToday(this.state, this.nowMs()) });
+  }
+
+  // ---- waking ----------------------------------------------------------------------------------------
+  /** Turn the events of one poll answer into queue entries; everything but wb.wake is ignored. */
+  handleEvents(events) {
+    for (const e of events || []) {
+      if (!e || e.event_type !== 'wb.wake') continue;
+      const p = e.payload || {};
+      const sid = p.session && p.session.id;
+      if (!UUID.test(String(sid || ''))) { this.logLine(`ignored id=${e.id} why=bad_session`); continue; }
+      if (this.isPaused()) continue;
+      const now = this.nowMs();
+      if (runsToday(this.state, now) >= this.cfg.dailyMax) { this.pause('cap'); return; }
+      const wakeId = String(p.wake_id != null ? p.wake_id : (e.id != null ? e.id : ''));
+      const fromAgent = (p.from && p.from.type === 'agent') || p.reason === 'agent_mention';
+      const msg = Number(p.last_msg_id != null ? p.last_msg_id : (p.msg_id != null ? p.msg_id : p.first_msg_id));
+      const r = this.queue.add({
+        sid,
+        groupId: isSafeId(String(p.group && p.group.id || '')) ? String(p.group.id) : '',
+        wakeId: isSafeId(wakeId) ? wakeId : '',
+        reason: /^[a-z_]{1,32}$/.test(String(p.reason || '')) ? p.reason : '',
+        hireId: isSafeId(String(p.hire_id || '')) ? String(p.hire_id) : '',
+        human: !fromAgent,
+        rewake: p.rewake === true,
+        msgId: Number.isFinite(msg) ? msg : null,
+        payload: p,
+      });
+      this.logLine(`wake id=${wakeId} sid=${String(sid).slice(0, 8)} ${r.result}${r.dropped ? ' dropped_oldest' : ''}`);
+    }
+    this.pump();
+  }
+
+  /** Start whatever may start now, and arm a timer for what must wait. */
+  pump() {
+    if (this.isPaused()) return;
+    for (;;) {
+      const now = this.nowMs();
+      if (this.queue.size && runsToday(this.state, now) >= this.cfg.dailyMax) { this.pause('cap'); return; }
+      const job = this.queue.take();
+      if (!job) break;
+      countRun(this.state, now);
+      this.save();
+      const pr = this.runJob(job).catch(() => {}).finally(() => this.active.delete(pr));
+      this.active.add(pr);
+    }
+    if (this.timer) { clearTimeout(this.timer); this.timer = null; }
+    const wait = this.queue.nextDelayMs();
+    if (wait != null && wait > 0) {
+      this.timer = setTimeout(() => { this.timer = null; this.pump(); }, wait);
+      if (this.timer.unref) this.timer.unref();
+    }
+  }
+
+  async runJob(job) {
+    const now0 = this.nowMs();
+    let ranFile = null;
+    try {
+      // A wake that waited in the queue: if the Agent has read the conversation meanwhile, skip it.
+      if (job.waited && job.msgId != null) {
+        try {
+          const rs = await getWbReadState(this.baseUrl, this.credOpts, job.sid, { fetchImpl: this.fetchImpl });
+          if (rs && Number(rs.last_read_msg_id) >= job.msgId) {
+            this.state.runsToday = Math.max(0, this.state.runsToday - 1);
+            this.logLine(`skip id=${job.wakeId} sid=${job.sid.slice(0, 8)} already_read`);
+            return;
+          }
+        } catch { /* cannot tell: run it */ }
+      }
+      const promptFile = path.join(promptsDir(this.credOpts), `${job.wakeId || job.sid.slice(0, 8)}-${now0}.txt`);
+      const prompt = buildPrompt(job.payload, this.env);
+      try {
+        fs.mkdirSync(path.dirname(promptFile), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(promptFile, prompt, { mode: 0o600 });
+        ranFile = promptFile;
+      } catch { /* the prompt still goes on standard input */ }
+      const vals = {
+        sid: job.sid, sessionKey: `anytowork-${job.sid.slice(0, 8)}`, groupId: job.groupId, wakeId: job.wakeId,
+        reason: job.reason, hireId: job.hireId, promptFile,
+      };
+      const command = expandCommand(this.cfg.exec, vals);
+      const env = buildRunEnv({ base: this.env, cfg: this.cfg, vals, credDir: this.credDir });
+      const res = await this.execCommand({ command, input: `${prompt}\n`, env, cwd: this.cfg.cwd, timeoutMs: this.cfg.timeoutMs });
+      const ok = res && res.code === 0 && !res.timedOut && !res.error;
+      const ms = this.nowMs() - now0;
+      const why = !res ? 'spawn' : (res.timedOut ? 'timeout' : (res.error ? 'spawn' : `exit_${res.code}`));
+      this.state.last = { at: this.nowMs(), ok, code: res ? res.code : null, ms, why: ok ? null : why };
+      this.logLine(`run id=${job.wakeId} sid=${job.sid.slice(0, 8)} ${ok ? 'ok' : `fail:${why}`} ms=${ms}`);
+      if (ok) {
+        this.state.fails = 0;
+      } else {
+        this.state.fails += 1;
+        if (this.state.fails >= this.cfg.failPauseAfter) this.pause('fail', why);
+      }
+    } finally {
+      if (ranFile) { try { fs.unlinkSync(ranFile); } catch { /* already gone */ } }
+      this.queue.done(job.sid);
+      this.save();
+      this.pump();
+    }
+  }
+
+  // ---- the loop --------------------------------------------------------------------------------------
+  /** One step while paused: maybe resume. */
+  async pausedStep() {
+    const fileState = readState(this.credOpts);
+    if (!fileState.paused) { this.state = fileState; this.logLine('resumed by=test'); return; }   // `listen test` cleared it
+    const p = this.state.paused;
+    const now = this.nowMs();
+    if (p.reason === 'cap' && now >= nextLocalMidnight(p.at)) return this.resume('midnight');
+    if (p.reason === 'fail' && now - p.at >= this.cfg.autoRetryMs) return this.resume('auto_retry');
+    if (p.reason === 'platform' && now - this.lastPlatformCheck >= this.cfg.pausedCheckMs) {
+      this.lastPlatformCheck = now;
+      try {
+        const info = await getListenerInfo(this.baseUrl, this.credOpts, { fetchImpl: this.fetchImpl });
+        if (!info || info.allowed !== false) return this.resume('platform');
+      } catch (e) {
+        if (this.classify && ['upgrade', 'auth'].includes(this.classify(e))) throw e;
+      }
+    }
+    this.state.seenAt = now;
+    this.save();
+    await this.sleep(PAUSED_TICK_MS);
+  }
+
+  /** @returns {Promise<number>} exit code: 0 stopped on request, 2 login lost / refused */
+  async loop() {
+    this.state.startedAt = this.nowMs();
+    this.save();
+    this.report({ state: 'running', runs_today: runsToday(this.state, this.nowMs()) });
+    let reconnectMs = RECONNECT_FIRST_MS;
+    let broken = false;
+    let cursor = readListenerCursor(this.credOpts, readCursor);
+    while (!this.shouldStop()) {
+      if (this.isPaused()) {
+        try { await this.pausedStep(); } catch (e) {
+          if (this.classify && this.classify(e) === 'upgrade') throw e;
+          if (this.classify && this.classify(e) === 'auth') { this.err(lt('run.auth', {}, this.env)); return 2; }
+        }
+        continue;
+      }
+      const started = this.nowMs();
+      let data;
+      try {
+        data = await getPoll(this.baseUrl, this.credOpts, { cursor, mode: 'listen', fetchImpl: this.fetchImpl, headers: LISTENER_HEADER });
+      } catch (e) {
+        const kind = this.classify ? this.classify(e) : 'transient';
+        if (kind === 'upgrade') throw e;
+        if (kind === 'auth') { this.err(lt('run.auth', {}, this.env)); return 2; }
+        if (kind === 'fatal') {
+          const msg = (e.body && (e.body.message || (e.body.detail && e.body.detail.message))) || e.message || String(e);
+          this.err(`平台拒绝了监听请求，已停止 / The platform refused the request, stopped: ${msg}`);
+          return 2;
+        }
+        if (kind === 'busy') { await this.sleep(BUSY_MIN_MS + Math.floor(this.random() * BUSY_SPAN_MS)); continue; }
+        if (!broken) this.err(`和平台的连接断了（${e && e.message ? e.message : '没有回应'}），正在自动重连，不用处理。 / Connection lost, reconnecting by itself.`);
+        broken = true;
+        await this.sleep(reconnectMs + Math.floor(this.random() * reconnectMs * 0.2));
+        reconnectMs = Math.min(reconnectMs * 2, RECONNECT_MAX_MS);
+        continue;
+      }
+      if (broken) this.err('已重新连上平台，继续监听。 / Connected again.');
+      broken = false;
+      reconnectMs = RECONNECT_FIRST_MS;
+      if (data && data.next_cursor != null) { cursor = data.next_cursor; writeListenerCursor(cursor, this.credOpts); }
+      this.state.seenAt = this.nowMs();
+      const lis = data && data.listener;
+      if (lis && lis.allowed === false) {
+        // The platform asks to stop waking for now (for example the wake-ups are not being read). Check back later.
+        this.lastPlatformCheck = this.nowMs();
+        this.pause('platform', typeof lis.reason === 'string' ? lis.reason : 'platform');
+        continue;
+      }
+      this.handleEvents((data && data.events) || []);
+      if (!(data && data.events && data.events.length) && this.nowMs() - started < QUICK_REPLY_MS) await this.sleep(QUICK_PAUSE_MS);
+    }
+    await Promise.allSettled([...this.active]);
+    return 0;
+  }
+}
+
+/** `listen test`: start the command once with a fixed prompt; does not touch any platform message. */
+export async function runStartTest({ cfg, credOpts, deps = {}, env = process.env }) {
+  const sid = '00000000-0000-4000-8000-000000000000';
+  const execCommand = deps.execCommand || defaultExec;
+  const credDir = resolveCredDir(credOpts);
+  const promptFile = path.join(promptsDir(credOpts), `test-${Date.now()}.txt`);
+  const prompt = testPrompt(env);
+  let wrote = false;
+  try {
+    fs.mkdirSync(path.dirname(promptFile), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(promptFile, prompt, { mode: 0o600 });
+    wrote = true;
+  } catch { /* standard input still works */ }
+  const vals = { sid, sessionKey: 'anytowork-test0000', groupId: '', wakeId: 'test', reason: 'test', hireId: '', promptFile };
+  const res = await execCommand({
+    command: expandCommand(cfg.exec, vals), input: prompt,
+    env: buildRunEnv({ base: env, cfg, vals, credDir }), cwd: cfg.cwd, timeoutMs: cfg.timeoutMs,
+  });
+  if (wrote) { try { fs.unlinkSync(promptFile); } catch { /* gone */ } }
+  const ok = !!res && res.code === 0 && !res.timedOut && !res.error;
+  const why = !res || res.error ? 'spawn' : (res.timedOut ? 'timeout' : `exit_${res.code}`);
+  const st = readState(credOpts);
+  st.last = { at: Date.now(), ok, code: res ? res.code : null, ms: 0, why: ok ? null : why };
+  if (ok && st.paused && st.paused.reason === 'fail') { st.paused = null; st.fails = 0; }
+  writeState(st, credOpts);
+  appendLog(credOpts, `test ${ok ? 'ok' : `fail:${why}`}`);
+  return { ok, why, code: res ? res.code : null };
+}

package/src/listener/text.js

@@ -0,0 +1,87 @@
+// Always-on listener: words printed by `anytowork listen install|run|test|status|uninstall` (zh and en).
+// They talk to the Agent that runs the command (and through it to the owner): plain words, no product names.
+
+import { pickLang } from '../model-pledge.js';
+
+const TEXT = {
+  'exec.missing': {
+    zh: '还差一条启动命令：anytowork listen install --exec "<启动你自己的一条命令>"。平台会把要做的事从标准输入交给这条命令。',
+    en: 'A start command is missing: anytowork listen install --exec "<the one command that starts you>". The platform hands the task to that command on standard input.',
+  },
+  'exec.notinstalled': {
+    zh: '这个身份还没有装常驻监听。先运行：anytowork listen install --exec "<启动你自己的一条命令>"',
+    en: 'No always-on listener is set up for this identity yet. Run first: anytowork listen install --exec "<the one command that starts you>"',
+  },
+  'install.done': {
+    zh: '常驻监听已装好并开始运行。收到消息会立刻叫醒你。接下来运行 anytowork listen test 试一次，把结果告诉主人。',
+    en: 'The always-on listener is set up and running. You will be woken as soon as a message arrives. Next run anytowork listen test once and tell your owner the result.',
+  },
+  'install.noautostart': {
+    zh: '配置已保存，没有设开机自启。需要时运行 anytowork listen run（保持它一直开着）。',
+    en: 'Settings saved, no start at login. Run anytowork listen run when needed (keep it running).',
+  },
+  'install.nosupervisor': {
+    zh: '这台电脑没有可用的开机自启方式（没有 systemd，也没有 crontab）。改为每 1 分钟运行一次 anytowork poll。',
+    en: 'This computer has no way to start things at login (no systemd, no crontab). Run anytowork poll once a minute instead.',
+  },
+  'install.linger': {
+    zh: '想让它在电脑开机后、没人登录时也运行：loginctl enable-linger',
+    en: 'To keep it running at boot even when nobody is logged in: loginctl enable-linger',
+  },
+  'install.failed': {
+    zh: '装自启失败：{err}。配置已保存，可以先用 anytowork listen run 前台运行。',
+    en: 'Setting up start at login failed: {err}. Settings are saved; you can run anytowork listen run in the foreground for now.',
+  },
+  'uninstall.done': {
+    zh: '常驻监听已停用，开机自启和配置都删了。',
+    en: 'The always-on listener is removed, with its start at login and settings.',
+  },
+  'test.start': {
+    zh: '正在用一条测试提示词试着启动你的命令……',
+    en: 'Trying your start command with a test prompt...',
+  },
+  'test.ok': {
+    zh: '启动成功（退出码 0）。常驻监听可以用了。',
+    en: 'Started fine (exit code 0). The always-on listener is ready.',
+  },
+  'test.fail': {
+    zh: '启动命令没跑通：{why}。请修好命令后重新运行 anytowork listen install，再 listen test。',
+    en: 'The start command did not work: {why}. Fix the command, run anytowork listen install again, then listen test.',
+  },
+  'why.exit': { zh: '退出码 {code}', en: 'exit code {code}' },
+  'why.timeout': { zh: '超时没结束', en: 'did not finish in time' },
+  'why.spawn': { zh: '启动不了', en: 'could not start' },
+  'run.started': {
+    zh: '常驻监听已启动，等待叫醒。',
+    en: 'The always-on listener is running and waiting for calls.',
+  },
+  'run.auth': {
+    zh: '登录状态已失效，平台不再认这个 Agent，常驻监听已停止（退出码 2）。请告诉主人：到「我的团队」里给这个 Agent 重新接入。不要自己运行 auth login（那样会变成一个新的 Agent）。',
+    en: 'The login is no longer valid, so the always-on listener stopped (exit code 2). Tell your owner to reconnect this Agent in My Team. Do not run auth login yourself (that would create a new Agent).',
+  },
+  'status.title': { zh: '常驻监听状态', en: 'Always-on listener' },
+  'status.installed.yes': { zh: '已装：是（{kind}）', en: 'Set up: yes ({kind})' },
+  'status.installed.noauto': { zh: '已装：是（没有设开机自启，需要保持 anytowork listen run 开着）', en: 'Set up: yes (no start at login; keep anytowork listen run open)' },
+  'status.installed.no': { zh: '已装：否', en: 'Set up: no' },
+  'status.running.yes': { zh: '在跑：是', en: 'Running: yes' },
+  'status.running.no': { zh: '在跑：否', en: 'Running: no' },
+  'status.today': { zh: '今天叫醒：{n} 次（每天最多 {max} 次）', en: 'Woken today: {n} (at most {max} a day)' },
+  'status.last.ok': { zh: '最近一次：成功（{time}，用时 {sec} 秒）', en: 'Latest run: ok ({time}, {sec} s)' },
+  'status.last.fail': { zh: '最近一次：失败（{time}，{why}）', en: 'Latest run: failed ({time}, {why})' },
+  'status.last.none': { zh: '最近一次：还没有', en: 'Latest run: none yet' },
+  'status.paused': { zh: '已暂停：{why}', en: 'Paused: {why}' },
+  'status.paused.fail': { zh: '连续 {n} 次启动失败，修好命令后运行 anytowork listen test 即可恢复，24 小时后也会自动再试', en: '{n} start failures in a row; fix the command and run anytowork listen test to resume, or it tries again by itself after 24 hours' },
+  'status.paused.cap': { zh: '今天的叫醒次数到上限了，明天 0 点自动恢复', en: 'Today\'s limit is reached; it resumes at midnight' },
+  'status.paused.platform': { zh: '平台暂时不叫醒（{why}），会自动再看，恢复后继续', en: 'The platform is not waking for now ({why}); it checks again by itself and resumes' },
+  'status.node.stale': { zh: '提醒：装的时候用的 node 路径已经不在了（{path}），请重新运行 anytowork listen install。', en: 'Note: the node path used at install no longer exists ({path}). Run anytowork listen install again.' },
+  'exec.sh.notice': { zh: '前台运行中（没有设开机自启），关掉这个窗口就停止。', en: 'Running in the foreground (no start at login); closing this window stops it.' },
+};
+
+export function lt(key, vars = {}, env = process.env) {
+  const e = TEXT[key];
+  let s = e ? e[pickLang(env)] : key;
+  for (const [k, v] of Object.entries(vars)) s = s.split(`{${k}}`).join(String(v));
+  return s;
+}
+
+export const LISTEN_SUBS = new Set(['install', 'run', 'test', 'status', 'uninstall']);

package/src/wb-rules-text.js

@@ -1,28 +1,65 @@
-// Workbench rules hint (v0.33.2). The server only sends {key, params:{sid}}; the words live here, in zh and en.
-// Wording must stay identical to PRD 26 section 7.3 and the docs site (agent-setup).
+// Workbench rules hint (v0.33.2, rewritten in v0.35.3).
+// Since v0.35.3 the platform sends the finished words in `rules.text` (already in the owner's language, with the
+// extra paragraphs attached); this file only holds the same words as a fallback for an old server that sends just
+// {key, params:{sid}}. Wording must stay identical to PRD 26 section 7.3, connect.json, llms.txt and the docs site
+// (agent-setup); the platform's copy (WB_RULES_REV = 2) is the reference.
 import { pickLang } from "./model-pledge.js";
 
+export const WB_RULES_REV = 2;
+
 export const WB_RULES_TEXT = {
   "wb.rules.full": {
-    zh: "主人在工作台等你的回话。先把消息读一遍（anytowork chat read {sid}），马上先回主人一句，让他知道你收到了、打算怎么做（anytowork chat send {sid} \"……\" --wip，还要接着做就带 --wip）。做的过程中隔一会儿说一两句进展（anytowork chat progress {sid} \"……\"），主人看不到动静，就分不清你是在忙还是没收到。做完了交成果（anytowork chat result {sid}）。能一直保持监听（anytowork listen），主人的消息会来得更快。",
-    en: "Your owner is waiting for your reply in the workbench. Read the message first (anytowork chat read {sid}), then answer right away so they know you got it and what you plan to do (anytowork chat send {sid} \"...\" --wip; keep --wip while you are still working). While you work, say a line or two now and then (anytowork chat progress {sid} \"...\"); if they hear nothing they cannot tell whether you are busy or never got it. When it is done, hand in the result (anytowork chat result {sid}). If you can keep listening (anytowork listen), their messages reach you faster.",
+    zh: "主人在工作台等你的回话，照这几步做：\n1. 先读消息：anytowork chat read {sid}\n2. 马上回一句，说你收到了、打算怎么做：anytowork chat send {sid} \"……\" --wip（还要接着做就带 --wip）\n3. 做的过程中隔一会儿说一两句进展：anytowork chat progress {sid} \"……\"。主人看不到动静，就分不清你是在忙还是没收到。\n4. 做完交成果：anytowork chat result {sid}",
+    en: "Your owner is waiting for your reply in the workbench. Do this:\n1. Read the message first: anytowork chat read {sid}\n2. Reply right away to say you got it and what you plan to do: anytowork chat send {sid} \"...\" --wip (keep --wip while you are still working)\n3. While you work, say a line or two now and then: anytowork chat progress {sid} \"...\". If they hear nothing, they cannot tell whether you are busy or never got it.\n4. When it is done, hand in the result: anytowork chat result {sid}",
   },
   "wb.rules.short": {
     zh: "主人在等你：先读消息，先回一句收到，边做边说一两句，做完交成果。",
     en: "Your owner is waiting: read first, reply with a quick \"got it\", say a line as you go, hand in the result when done.",
   },
+  // Extra paragraph for an Agent that has no listener running (the platform decides when to add it).
+  "wb.rules.listen": {
+    zh: "想让主人的消息一到就叫醒你：在这台电脑上装好常驻监听（anytowork listen install，用法看 anytowork listen --help），装好后运行 anytowork listen test。",
+    en: "To be woken the moment a message arrives, set up the always-on listener on this computer (anytowork listen install, see anytowork listen --help), then run anytowork listen test.",
+  },
+  // Extra paragraph for a hired Agent: full once per session, short afterwards.
+  "wb.rules.hire": {
+    zh: "你是被聘来的：每做完一件事，附一行用量报上来（anytowork hire usage {hire_id} …，用法看 --help）。没报用量的时间不算干活。",
+    en: "You were hired: after each piece of work, report one line of usage (anytowork hire usage {hire_id} ..., see --help). Time without reported usage does not count as work.",
+  },
+  "wb.rules.hire.short": {
+    zh: "做完报用量。",
+    en: "Report usage when done.",
+  },
+  // Put first when the rules changed since this Agent last saw them.
+  "wb.rules.changed": {
+    zh: "工作台规则更新了，以下面这段为准。",
+    en: "The workbench rules have changed. Follow the text below.",
+  },
 };
 
 /**
- * Turn a server `rules` field ({key, params:{sid}}) into text in the CLI language.
+ * Turn a server `rules` field into text in the CLI language.
+ *  - the platform's own words win: `rules.text` is printed as it is (so changing the rules never needs a new CLI);
+ *  - otherwise (old server: just {key, params:{sid}}) build the same words from the local table.
  * Returns null when there is nothing to print (old server, bad shape). Unknown keys fall back to the short line.
  */
 export function renderWbRules(rules, env = process.env) {
-  if (!rules || typeof rules !== "object" || typeof rules.key !== "string") return null;
+  if (!rules || typeof rules !== "object") return null;
+  if (typeof rules.text === "string" && rules.text.trim()) return rules.text.trim();
+  if (typeof rules.key !== "string") return null;
+  const lang = pickLang(env);
+  const isFull = rules.key !== "wb.rules.short";
   const entry = WB_RULES_TEXT[rules.key] || WB_RULES_TEXT["wb.rules.short"];
   const params = rules.params && typeof rules.params === "object" ? rules.params : {};
   const sid = params.sid != null && params.sid !== "" ? String(params.sid) : "<会话>";
-  return entry[pickLang(env)].split("{sid}").join(sid);
+  const parts = [];
+  if (rules.changed === true) parts.push(WB_RULES_TEXT["wb.rules.changed"][lang]);
+  parts.push(entry[lang].split("{sid}").join(sid));
+  if (params.hire_id) {
+    const h = WB_RULES_TEXT[isFull ? "wb.rules.hire" : "wb.rules.hire.short"][lang];
+    parts.push(h.split("{hire_id}").join(String(params.hire_id)));
+  }
+  return parts.join("\n");
 }
 
 // ---------------------------------------------------------------------------------------------------
@@ -98,10 +135,14 @@ export function boundaryLines({ rules = null, boundary = null, source = null, wa
   const out = [];
   const issued = rules && typeof rules === "object" && rules.boundary && typeof rules.boundary.key === "string" ? rules.boundary : null;
   const first = issued || (boundary && typeof boundary === "object" && typeof boundary.key === "string" ? boundary : null);
+  // v0.35.3: the platform may send the finished words (`text`); then print them as they are.
+  const serverText = (issued && typeof issued.text === "string" && issued.text.trim())
+    || (boundary && typeof boundary === "object" && typeof boundary.text === "string" && boundary.text.trim()) || null;
   if (source && typeof source === "object" && source.kind === "other_agent") {
     out.push(boundaryLine("agent.boundary.source", lang, { name: source.agent_name || (lang === "en" ? "another Agent" : "另一个 Agent") }));
   }
-  if (first) out.push(boundaryLine(AGENT_BOUNDARY_TEXT[first.key] ? first.key : "agent.boundary.short", lang));
+  if (serverText) out.push(serverText.trim());
+  else if (first) out.push(boundaryLine(AGENT_BOUNDARY_TEXT[first.key] ? first.key : "agent.boundary.short", lang));
   const warnOn = warn === true || (boundary && typeof boundary === "object" && boundary.warn === true);
   if (warnOn) out.push(boundaryLine("agent.boundary.warn", lang));
   return out.filter(Boolean);