@sleep2agi/commhub-server 0.9.0-preview.134 → 0.9.0-preview.136

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.134",
-  "description": "CommHub Server \u2014 AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
+  "version": "0.9.0-preview.136",
+  "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",
   "bin": {

package/src/auth-password-change-cli-tokens-http.test.ts

@@ -6,7 +6,7 @@
 //   · 默认(旧 app、dashboard 代理不带字段):撤销全部不绑网络的令牌 —— 客户端自报的 cli 也活不下来;
 //   · keep_cli_tokens=true(anet passwd 默认带):只撤其他 kind='login' 会话,保留的 cli 令牌列在响应里、不含令牌值;
 //   · 当前会话(换发后的新令牌)永远可用,而且沿用当前令牌的种类;
-//   · 节点 / 网络令牌永远不动;
+//   · 节点令牌不动;具名网络令牌默认保留,可显式revoke_network_tokens;
 //   · 启动迁移按 client_label / scope 回填存量令牌的 kind(夹具库,跑两遍幂等)。
 // SQLite 由 test798 自动收进;PostgreSQL 由 tests/test2123-hub-postgres-ladder 的 run_pg_tests_rc 跑同一个文件。
 
@@ -15,7 +15,7 @@ import { mkdtempSync, rmSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 import { spawnSync } from "child_process";
-import { register, createNetworkTokenForNode, createToken, changePassword } from "./auth.js";
+import { register, createNetworkTokenForNode, createToken, createNetwork, changePassword } from "./auth.js";
 import { db, hashToken } from "./db.js";
 
 const DIR = mkdtempSync(join(tmpdir(), "anet-pwchange-kind-"));
@@ -292,3 +292,132 @@ describe("startup migration backfills api_tokens.kind on a fixture DB", () => {
     expect(Number(db.get<any>("SELECT COUNT(*) AS n FROM api_tokens WHERE token_id = ?1", id("node")).n)).toBe(1);
   }, 120_000);
 });
+
+
+describe("network password opt-in", () => {
+  const id = (token: string) => db.get<any>("SELECT token_id FROM api_tokens WHERE token_hash=?1", hashToken(token)).token_id;
+
+  test("default lists only the caller's active named network tokens across networks, without credentials", async () => {
+    const f = await fleet();
+    const second = createNetwork(f.userId, `pwk-second-${seq}`);
+    expect(second.ok).toBe(true);
+    const extra = createToken(f.userId, "second-network-script", second.network_id);
+    const other = await fleet();
+    const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2 });
+    expect(r.status).toBe(200);
+    expect(r.body.revoked_network).toBe(0);
+    expect(r.body.revoked).toBe(5);
+    expect(r.body.kept_network_tokens.map((x: any) => x.token_id).sort()).toEqual([id(f.netToken), id(extra.token!)].sort());
+    for (const row of r.body.kept_network_tokens) {
+      expect(Object.keys(row).sort()).toEqual(["created_at", "last_used_at", "name", "network_id", "token_id"]);
+    }
+    const body = JSON.stringify(r.body);
+    expect(body.includes("token_hash")).toBe(false);
+    for (const t of [f.netToken, extra.token!, f.nodeToken, other.netToken]) expect(body.includes(t)).toBe(false);
+    expect(await works(f.netToken)).toBe(true);
+    expect(await works(extra.token!)).toBe(true);
+    expect(await works(other.netToken)).toBe(true);
+    expect(await works(r.body.token)).toBe(true);
+  });
+
+  test("explicit boolean opt-in revokes only own named network tokens, independently of keep_cli_tokens", async () => {
+    const f = await fleet();
+    const other = await fleet();
+    const second = createNetwork(f.userId, `pwk-revoke-second-${seq}`);
+    const extra = createToken(f.userId, "second-network-script", second.network_id);
+    const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, keep_cli_tokens: true, revoke_network_tokens: true });
+    expect(r.status).toBe(200);
+    expect(r.body.revoked_network).toBe(2);
+    expect(r.body.revoked_login).toBe(2);
+    expect(r.body.revoked_cli).toBe(0);
+    expect(r.body.revoked).toBe(4);
+    expect(r.body.kept_network_tokens).toEqual([]);
+    expect(await works(f.netToken)).toBe(false);
+    expect(await works(extra.token!)).toBe(false);
+    expect(await works(other.netToken)).toBe(true);
+    expect(await works(other.app)).toBe(true);
+    expect(await works(f.nodeToken)).toBe(true);
+    expect(await works(f.apiToken)).toBe(true);
+    expect(await works(r.body.token)).toBe(true);
+    expect(await works(f.app)).toBe(false);
+  });
+
+  for (const value of [false, "true", 1, null, {}]) {
+    test(`non-true option ${JSON.stringify(value)} cannot revoke network tokens`, async () => {
+      const f = await fleet();
+      const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: value });
+      expect(r.status).toBe(200);
+      expect(r.body.revoked_network).toBe(0);
+      expect(r.body.kept_network_tokens).toHaveLength(1);
+      expect(await works(f.netToken)).toBe(true);
+    });
+  }
+
+  test("scope and binding protect node credentials; inactive rows are neither listed nor counted", async () => {
+    const f = await fleet();
+    const legacy = createNetworkTokenForNode(f.userId, f.net, `legacy-pwk-${seq}`);
+    expect(legacy.ok).toBe(true);
+    const bound = createToken(f.userId, "mislabelled-bound-node", f.net);
+    db.run("UPDATE api_tokens SET bound_node_id=?1 WHERE token_id=?2", ["n-protected717", bound.token_id]);
+    const expired = createToken(f.userId, "expired-script", f.net);
+    db.run("UPDATE api_tokens SET expires_at=datetime('now','-1 day') WHERE token_id=?1", [expired.token_id]);
+    const revoked = createToken(f.userId, "revoked-script", f.net);
+    db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1", [revoked.token_id]);
+    const r = await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: true });
+    expect(r.status).toBe(200);
+    expect(r.body.revoked_network).toBe(1);
+    expect(await works(f.nodeToken)).toBe(true);
+    expect(await works(bound.token!)).toBe(true);
+    for (const t of [bound, expired, revoked, legacy]) expect(db.get("SELECT token_id FROM api_tokens WHERE token_id=?1", t.token_id)).not.toBeNull();
+  });
+
+  test("bad old password or weak new password has no token side effects", async () => {
+    for (const body of [{ old_password: "wrong", new_password: PW2 }, { old_password: PW, new_password: "123" }]) {
+      const f = await fleet();
+      const r = await call(f.app, "POST", "/api/auth/password", { ...body, revoke_network_tokens: true });
+      expect(r.status).toBe(400);
+      for (const t of [f.app, f.netToken, f.apiToken, f.nodeToken]) expect(await works(t)).toBe(true);
+      expect((await call("", "POST", "/api/auth/login", { username: f.user, password: PW })).status).toBe(200);
+    }
+  });
+
+  test("network-scoped and unauthenticated credentials cannot invoke password change", async () => {
+    const f = await fleet();
+    for (const t of [f.netToken, f.nodeToken, ""]) {
+      expect((await call(t, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: true })).status).toBe(t ? 403 : 401);
+    }
+    expect(await works(f.netToken)).toBe(true);
+    expect(await works(f.app)).toBe(true);
+  });
+
+  test("a failed network revoke rolls back the password and earlier session deletions", async () => {
+    const f = await fleet();
+    const victim = id(f.netToken);
+    const fn = `pw717_failure_${seq}`;
+    const trigger = `pw717_trigger_${seq}`;
+    if (db.dialect === "postgres") db.exec(`CREATE FUNCTION ${fn}() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF OLD.token_id='${victim}' THEN RAISE EXCEPTION 'fixture717_delete_failure'; END IF; RETURN OLD; END; $$; CREATE TRIGGER ${trigger} BEFORE DELETE ON api_tokens FOR EACH ROW EXECUTE FUNCTION ${fn}()`);
+    else db.exec(`CREATE TRIGGER ${trigger} BEFORE DELETE ON api_tokens WHEN OLD.token_id='${victim}' BEGIN SELECT RAISE(ABORT,'fixture717_delete_failure'); END`);
+    try {
+      expect((await call(f.app, "POST", "/api/auth/password", { old_password: PW, new_password: PW2, revoke_network_tokens: true })).status).toBe(400);
+      for (const t of [f.app, f.appB, f.apiToken, f.netToken, f.nodeToken]) expect(await works(t)).toBe(true);
+      expect((await call("", "POST", "/api/auth/login", { username: f.user, password: PW })).status).toBe(200);
+      expect((await call("", "POST", "/api/auth/login", { username: f.user, password: PW2 })).status).toBe(401);
+    } finally {
+      db.exec(db.dialect === "postgres" ? `DROP TRIGGER ${trigger} ON api_tokens; DROP FUNCTION ${fn}()` : `DROP TRIGGER ${trigger}`);
+    }
+  });
+
+  test("direct changePassword keeps its current row and defaults to listing network tokens", async () => {
+    const f = await fleet();
+    const cur = id(f.app);
+    const r = changePassword(f.userId, PW, PW2, cur);
+    expect(r.ok).toBe(true);
+    expect(r.kept_network_tokens).toHaveLength(1);
+    expect(await works(f.app)).toBe(true);
+    const r2 = changePassword(f.userId, PW2, PW, cur, { revokeNetworkTokens: true, keepCliTokens: true });
+    expect(r2.ok).toBe(true);
+    expect(r2.revoked_network).toBe(1);
+    expect(await works(f.app)).toBe(true);
+    expect(await works(f.nodeToken)).toBe(true);
+  });
+});

package/src/auth.ts

@@ -2,7 +2,7 @@
  * V3 Auth module — user registration, login, token management
  */
 import { db, generateId, hashPassword, verifyPassword, hashToken, generateToken, generateUserToken, generateNetworkToken, uuidv4 } from "./db.js"; import { deleteDepartmentsForNetwork, groupTx, removeMemberFromChatGroups } from "./departments.js"; // #419: also ensures network_members.department_id exists (same line on purpose: docs pin auth.ts line numbers)
-import { WEAK_PASSWORDS } from "./password-dict.js";
+import { WEAK_PASSWORDS } from "./password-dict.js"; import { passwordNetworkTokens, type KeptNetworkToken } from "./password-network-tokens.js";
 import { checkNodeTokenClaim, legacyNodeHolder } from "./node-token-ownership.js";
 import { NETWORK_REST_COLUMNS, NETWORK_REST_SELECT, sqlColumns } from "./rest-projections.js";
 import { deleteAgentGrants, isAgentRestricted } from "./agent-access.js"; import { deleteTaskGrantsForMember, newMemberTaskAccess, type TaskAccessMode } from "./task-access.js"; // 一行两个 import:文档钉着 auth.ts 的行号
@@ -330,7 +330,7 @@ export type SessionClientInfo = { label?: unknown; userAgent?: unknown; kind?: u
 // 种类由客户端自报(client_kind / client_label),**只用于展示和「显式保留」那条路**:
 // 改密码默认仍撤销全部不绑网络的令牌(当前这条除外),调用方显式 keep_cli_tokens=true 才保留 'cli'。
 // 所以一个自称 cli 的令牌永远不能靠自报在默认改密码里活下来。
-// 节点 / 网络令牌(network_id 非空)不分类,改密码永远不碰。
+// 节点 / 网络令牌(network_id 非空)不按cli分类;具名网络令牌另有显式撤销选项。
 export type UserTokenKind = "login" | "cli";
 
 /** 登录 / 注册请求签发的令牌算哪一类:客户端显式报 kind='cli',或 client_label 是 anet 自报的「anet <版本> · …」。 */
@@ -642,14 +642,14 @@ export function revokeOtherSessions(userId: string, currentTokenId: string): num
   return db.run(`DELETE FROM api_tokens WHERE user_id = ?1 AND ${SESSION_TOKEN_SQL} AND token_id != ?2`, [userId, currentTokenId]).changes;
 }
 
-export type ChangePasswordResult = { ok: boolean; error?: string; revoked?: number; revoked_login?: number; revoked_cli?: number; kept_cli_tokens?: KeptCliToken[] };
+export type ChangePasswordResult = { ok: boolean; error?: string; revoked?: number; revoked_login?: number; revoked_cli?: number; kept_cli_tokens?: KeptCliToken[]; revoked_network?: number; kept_network_tokens?: KeptNetworkToken[] };
 
 /**
  * 改密码。默认撤销该用户全部不绑网络的令牌(改密码前的行为,旧 app 依赖它)。#711:opts.keepCliTokens=true
  * 时保留 kind='cli' 的(anet 命令行登录、具名脚本令牌),并在 kept_cli_tokens 里列出。当前会话和节点令牌永远保留。
- * revoked = 两类合计(旧字段,兼容旧客户端)。
+ * revokeNetworkTokens=true显式撤销具名网络令牌;默认列出保留清单。revoked含三类合计。
  */
-export function changePassword(userId: string, oldPassword: string, newPassword: string, currentTokenId?: string | null, opts: { keepCliTokens?: boolean } = {}): ChangePasswordResult {
+export function changePassword(userId: string, oldPassword: string, newPassword: string, currentTokenId?: string | null, opts: { keepCliTokens?: boolean; revokeNetworkTokens?: boolean } = {}): ChangePasswordResult {
   const passwordError = validatePasswordStrength(newPassword, "new password");
   if (passwordError) return { ok: false, error: passwordError };
   const user = db.get<any>("SELECT password_hash FROM users WHERE user_id = ?1", userId);
@@ -663,10 +663,14 @@ export function changePassword(userId: string, oldPassword: string, newPassword:
   // password change. If the user changes via `anet passwd`, the bootstrap
   // nudge goes away on next login. SET to 0 explicitly (rather than skip)
   // so a future flag flip can't drift the state.
-  db.run("UPDATE users SET password_hash = ?1, must_change_password = 0, updated_at = datetime('now') WHERE user_id = ?2", [hashPassword(newPassword), userId]);
-  const keep = opts.keepCliTokens === true;
-  const r = revokeTokensAfterPasswordChange(userId, currentTokenId, keep);
-  return { ok: true, revoked: r.login + r.cli, revoked_login: r.login, revoked_cli: r.cli, ...(keep ? { kept_cli_tokens: r.kept } : {}) };
+  const nextHash = hashPassword(newPassword);
+  return db.transaction(() => {
+    db.run("UPDATE users SET password_hash = ?1, must_change_password = 0, updated_at = datetime('now') WHERE user_id = ?2", [nextHash, userId]);
+    const keep = opts.keepCliTokens === true;
+    const r = revokeTokensAfterPasswordChange(userId, currentTokenId, keep);
+    const network = passwordNetworkTokens(userId, currentTokenId, opts.revokeNetworkTokens === true);
+    return { ok: true, revoked: r.login + r.cli + network.revoked, revoked_login: r.login, revoked_cli: r.cli, ...(keep ? { kept_cli_tokens: r.kept } : {}), revoked_network: network.revoked, kept_network_tokens: network.kept };
+  });
 }
 
 /**

package/src/db.ts

@@ -245,6 +245,7 @@ db.exec(`
     started_at        TEXT,
     runtime_submitted_at TEXT,
     consumed_at       TEXT,
+    last_activity_at  TEXT,
     thread_id         TEXT,
     turn_id           TEXT,
     completed_at      TEXT,
@@ -1557,6 +1558,8 @@ try { db.exec("ALTER TABLE tasks ADD COLUMN meta_json TEXT"); } catch {}
 // started_at (legacy report_status/content matching). Old binaries ignore them.
 try { db.exec("ALTER TABLE tasks ADD COLUMN runtime_submitted_at TEXT"); } catch {}
 try { db.exec("ALTER TABLE tasks ADD COLUMN consumed_at TEXT"); } catch {}
+// #1113: exact original-turn activity. NULL keeps the old execution-clock fallback.
+try { db.exec("ALTER TABLE tasks ADD COLUMN last_activity_at TEXT"); } catch {}
 // Exact vendor-runtime boundary for SideThread-capable clients. These values
 // are written only by the token-bound target node after attributable runtime
 // evidence; the Hub never derives them from task text or caller input.

package/src/node-caller-identity-http.test.ts

@@ -28,6 +28,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { addNetworkMember, createNetworkTokenForNode, register } from "./auth.js";
 import { db, generateNetworkToken, hashToken } from "./db.js";
+import { createTaskRuntimeEvidenceReporter, taskActivityPayload } from "../../agent-node/src/task-runtime-evidence";
 
 const dir = mkdtempSync(join(tmpdir(), "anet-caller-identity-"));
 const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
@@ -984,3 +985,99 @@ test("duplicate ownerless row keeps an unbound epoch 0 token online", async () =
   first.abort();
   second.abort();
 }, 15_000);
+
+
+const leaseAlias = `leasebase${stamp}`, leaseId = `n_leasebase_${stamp}`;
+let leaseTok: Tok;
+beforeAll(() => { seedNode(leaseId,leaseAlias,NET,ownerId);seedSession(leaseId,leaseAlias,NET);leaseTok=mint(ownerId,NET,leaseAlias,2,leaseId); });
+
+function activityTask(nodeId: string, alias: string, network = NET) {
+  const id = `task_activity_${crypto.randomUUID()}`;
+  db.run("INSERT INTO tasks (task_id, from_name, to_node_id, to_name, status, content, network_id) VALUES (?1, 'scheduler', ?2, ?3, 'running', 'activity fixture', ?4)", [id, nodeId, alias, network]);
+  return { task_id: id, thread_id: `thread_${id}`, turn_id: `turn_${id}` };
+}
+const activitySnap = (id: string) => db.get<any>("SELECT status, consumed_at, runtime_submitted_at, started_at, thread_id, turn_id, last_activity_at FROM tasks WHERE task_id = ?1", id);
+async function consumeActivityTask(context: {task_id: string; thread_id: string; turn_id: string}) {
+  expect((await tool(leaseTok.token, "mark_tasks_consumed", { task_ids: [context.task_id], task_contexts: [context] })).ok).toBe(true);
+}
+const renewActivity = (token: string, contexts: Array<{task_id: string; thread_id: string; turn_id: string}>) => tool(token, "mark_tasks_consumed", { task_ids: contexts.map(c => c.task_id), task_contexts: contexts, activity_only: true });
+
+test("activity lease: exact task renewal changes only the activity clock; duplicate consumption does not renew", async () => {
+  const c = activityTask(leaseId, leaseAlias); await consumeActivityTask(c);
+  db.run("UPDATE tasks SET last_activity_at = datetime('now', '-2 hours') WHERE task_id = ?1", [c.task_id]);
+  const before = activitySnap(c.task_id);
+  expect((await tool(leaseTok.token, "mark_tasks_consumed", { task_ids: [c.task_id], task_contexts: [c] })).ok).toBe(true);
+  expect(activitySnap(c.task_id)).toEqual(before);
+  const out = await renewActivity(leaseTok.token, [c]); expect(out.ok).toBe(true);
+  const after = activitySnap(c.task_id);
+  expect(after.last_activity_at).not.toBe(before.last_activity_at);
+  expect({...after, last_activity_at: before.last_activity_at}).toEqual(before);
+  expect(out.tasks[0].last_activity_at).toBe(after.last_activity_at);
+});
+
+test("activity lease: bound node wins over a same-name session and cannot renew the other node", async () => {
+  const alias = `leasebound${stamp}`, mine = `n_leasebound_${stamp}`, other = `n_leaseother_${stamp}`;
+  seedNode(mine, alias, NET, ownerId); seedSession(mine, alias, NET);
+  const tok = mint(ownerId, NET, leaseAlias, 2, mine), own = activityTask(mine, alias);
+  expect((await tool(tok.token, "mark_tasks_consumed", {task_ids: [own.task_id], task_contexts: [own]})).ok).toBe(true);
+  seedNode(other, alias, NET, ownerId); db.run("UPDATE sessions SET node_id=?1 WHERE alias=?2 AND network_id=?3",[other,alias,NET]);
+  expect((await renewActivity(tok.token, [own])).ok).toBe(true);
+  const foreign = activityTask(other, alias);
+  db.run("UPDATE tasks SET consumed_at=datetime('now'),thread_id=?1,turn_id=?2 WHERE task_id=?3", [foreign.thread_id,foreign.turn_id,foreign.task_id]);
+  expect((await renewActivity(tok.token,[foreign])).error).toBe("task_not_owned");
+  expect(activitySnap(foreign.task_id).last_activity_at).toBeNull();
+});
+
+for (const shape of ["wrong thread", "wrong turn", "foreign node", "foreign network", "legacy null node", "not consumed", "missing context", "user token"] as const) {
+  test(`activity lease: rejects ${shape} without changing the task`, async () => {
+    const c = activityTask(leaseId, leaseAlias); if(shape !== "not consumed") await consumeActivityTask(c);
+    if(shape === "foreign node") db.run("UPDATE tasks SET to_node_id=?1 WHERE task_id=?2", [otherId,c.task_id]);
+    if(shape === "foreign network") db.run("UPDATE tasks SET network_id=?1 WHERE task_id=?2", [NET2,c.task_id]);
+    if(shape === "legacy null node") db.run("UPDATE tasks SET to_node_id=NULL WHERE task_id=?1",[c.task_id]);
+    const before=activitySnap(c.task_id); const context={...c};
+    if(shape === "wrong thread") context.thread_id="sibling_thread";
+    if(shape === "wrong turn") context.turn_id="sibling_turn";
+    const out=await tool(shape === "user token" ? ownerToken : leaseTok.token,"mark_tasks_consumed",{task_ids:[c.task_id],task_contexts:shape === "missing context" ? [] : [context],activity_only:true});
+    expect(out.ok).toBe(false); expect(activitySnap(c.task_id)).toEqual(before);
+  });
+}
+for(const status of ["replied","failed","cancelled","expired"]){
+  test(`activity lease: ${status} terminal never receives activity or reopens`,async()=>{
+    const c=activityTask(leaseId,leaseAlias);await consumeActivityTask(c);db.run("UPDATE tasks SET status=?1 WHERE task_id=?2",[status,c.task_id]);const before=activitySnap(c.task_id);
+    expect((await renewActivity(leaseTok.token,[c])).error).toBe("task_activity_terminal");expect(activitySnap(c.task_id)).toEqual(before);
+  });
+}
+test("activity lease: conflicting batch is rejected with zero partial writes",async()=>{
+  const first=activityTask(leaseId,leaseAlias),second=activityTask(leaseId,leaseAlias);await consumeActivityTask(first);await consumeActivityTask(second);
+  const before=activitySnap(first.task_id),before2=activitySnap(second.task_id);
+  expect((await renewActivity(leaseTok.token,[first,{...second,turn_id:"old_turn"}])).ok).toBe(false);
+  expect(activitySnap(first.task_id)).toEqual(before);expect(activitySnap(second.task_id)).toEqual(before2);
+});
+
+test("activity lease: injected second-write failure rolls back the first write on the real backend",async()=>{
+ const first=activityTask(leaseId,leaseAlias),second=activityTask(leaseId,leaseAlias);await consumeActivityTask(first);await consumeActivityTask(second);
+ const trigger=`activity_fail_${stamp}`,fn=`activity_fn_${stamp}`;
+ if(db.dialect === "postgres")db.exec(`CREATE FUNCTION ${fn}() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.task_id='${second.task_id}' THEN RAISE EXCEPTION 'test1113_injected_activity_failure'; END IF; RETURN NEW; END; $$; CREATE TRIGGER ${trigger} BEFORE UPDATE OF last_activity_at ON tasks FOR EACH ROW EXECUTE FUNCTION ${fn}()`);
+ else db.exec(`CREATE TRIGGER ${trigger} BEFORE UPDATE OF last_activity_at ON tasks WHEN NEW.task_id='${second.task_id}' BEGIN SELECT RAISE(ABORT,'test1113_injected_activity_failure'); END`);
+ const before=activitySnap(first.task_id),before2=activitySnap(second.task_id);let failed=false;
+ try{await renewActivity(leaseTok.token,[first,second]);}catch(e){failed=String(e).includes("test1113_injected_activity_failure");}
+ finally{if(db.dialect === "postgres")db.exec(`DROP TRIGGER ${trigger} ON tasks; DROP FUNCTION ${fn}()`);else db.exec(`DROP TRIGGER ${trigger}`);}
+ expect(failed).toBe(true);expect(activitySnap(first.task_id)).toEqual(before);expect(activitySnap(second.task_id)).toEqual(before2);
+});
+test("activity lease: revoked credential cannot report activity",async()=>{
+ const tok=mint(ownerId,NET,leaseAlias,2,leaseId),c=activityTask(leaseId,leaseAlias);await consumeActivityTask(c);const before=activitySnap(c.task_id);
+ db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1",[tok.tokenId]);
+ const response=await fetch(`${base}/mcp`,{method:"POST",headers:{Authorization:`Bearer ${tok.token}`,"Content-Type":"application/json",Accept:"application/json, text/event-stream"},body:JSON.stringify({jsonrpc:"2.0",id:1,method:"tools/call",params:{name:"mark_tasks_consumed",arguments:{task_ids:[c.task_id],task_contexts:[c],activity_only:true}}})});
+ expect(response.status).toBe(401);expect(activitySnap(c.task_id)).toEqual(before);
+});
+
+test("activity lease: real runtime reporter payload traverses authenticated HTTP into the exact task clock",async()=>{
+ const c=activityTask(leaseId,leaseAlias);let clock=0;const errors:string[]=[];
+ const reporter=createTaskRuntimeEvidenceReporter({taskId:c.task_id,now:()=>clock,
+  report:(_level,id,context)=>tool(leaseTok.token,"mark_tasks_consumed",{task_ids:[id],task_contexts:[{task_id:id,thread_id:context!.threadId,turn_id:context!.turnId}]}),
+  reportActivity:(id,context)=>tool(leaseTok.token,"mark_tasks_consumed",taskActivityPayload(id,context)),debug:message=>errors.push(message)});
+ reporter.consumed({threadId:c.thread_id,turnId:c.turn_id});await until(()=>!!activitySnap(c.task_id).consumed_at,"consumption stamped");
+ const before=activitySnap(c.task_id);clock=30_000;reporter.activity({taskId:"other_task",threadId:c.thread_id,turnId:c.turn_id});await new Promise(resolve=>setTimeout(resolve,5));expect(activitySnap(c.task_id)).toEqual(before);
+ reporter.activity({taskId:c.task_id,threadId:c.thread_id,turnId:c.turn_id});await until(()=>!!activitySnap(c.task_id).last_activity_at,"runtime activity stamped");
+ expect(errors).toEqual([]);expect(activitySnap(c.task_id).consumed_at).toBe(before.consumed_at);expect(activitySnap(c.task_id).status).toBe("running");
+});

package/src/password-network-tokens.ts

@@ -0,0 +1,25 @@
+import { db } from "./db.js";
+
+export type KeptNetworkToken = {
+  token_id: string;
+  name: string;
+  network_id: string;
+  created_at: string;
+  last_used_at: string | null;
+};
+
+/** Only user-created named network tokens. Node credentials have a different scope or binding. */
+export function passwordNetworkTokens(userId: string, currentTokenId: string | null | undefined, revoke: boolean) {
+  const where = `user_id = ?1 AND network_id IS NOT NULL AND scope = 'full'
+    AND bound_node_id IS NULL AND revoked_at IS NULL
+    AND (expires_at IS NULL OR expires_at > datetime('now'))${currentTokenId ? " AND token_id != ?2" : ""}`;
+  const params = currentTokenId ? [userId, currentTokenId] : [userId];
+  if (revoke) {
+    return { revoked: db.run(`DELETE FROM api_tokens WHERE ${where}`, params).changes, kept: [] as KeptNetworkToken[] };
+  }
+  const kept = db.all<KeptNetworkToken>(
+    `SELECT token_id, name, network_id, created_at, last_used_at FROM api_tokens WHERE ${where} ORDER BY created_at DESC, token_id`,
+    ...params,
+  );
+  return { revoked: 0, kept };
+}

package/src/scheduled-stuck-http.test.ts

@@ -286,3 +286,27 @@ describe("#1112 execution clock", () => {
     expect(blockerTimedOut({ created_at: "2026-10-13 01:00:00", consumed_at: "2026-10-13 02:00:00" }, schedule, now)).toBe(true);
   });
 });
+
+
+describe("#1113 activity idle clock",()=>{
+ test("fresh exact-task activity protects a long consumed turn, silent activity still expires",()=>{
+  const s=seedSchedule(),first=fire(s),now=new Date(),at=(m:number)=>new Date(now.getTime()-m*60_000).toISOString();
+  db.run("UPDATE tasks SET status='running',created_at=?1,consumed_at=?2,last_activity_at=?3 WHERE task_id=?4",[at(180),at(120),at(1),first.taskId]);
+  expect(fire(s,now).status).toBe("skipped");expect(taskRow(first.taskId!).status).toBe("running");
+  db.run("UPDATE tasks SET last_activity_at=?1 WHERE task_id=?2",[at(61),first.taskId]);expect(fire(s,now).status).toBe("delivered");
+  expect(runRow(first.runId).error_message).toContain("since last_activity_at");
+ });
+ test("fresh activity cannot evade the absolute total cap",()=>{
+  const s=seedSchedule(),first=fire(s),now=new Date(),at=(m:number)=>new Date(now.getTime()-m*60_000).toISOString();
+  db.run("UPDATE tasks SET status='running',created_at=?1,consumed_at=?2,last_activity_at=?3 WHERE task_id=?4",[at(1441),at(1440),at(1),first.taskId]);
+  expect(fire(s,now).status).toBe("delivered");expect(runRow(first.runId).error_message).toContain("total cap");
+ });
+ test("activity without consumption, before consumption or in the future never renews",()=>{
+  const now=new Date("2026-10-13T04:00:00Z"),schedule=JSON.stringify({type:"interval",every_seconds:60});
+  for(const row of [
+   {created_at:"2026-10-13 01:00:00",last_activity_at:"2026-10-13 03:59:00"},
+   {created_at:"2026-10-13 01:00:00",consumed_at:"2026-10-13 02:00:00",last_activity_at:"2026-10-13 01:59:00"},
+   {created_at:"2026-10-13 01:00:00",consumed_at:"2026-10-13 02:00:00",last_activity_at:"2026-10-13 04:01:00"},
+  ])expect(blockerTimedOut(row,schedule,now)).toBe(true);
+ });
+});

package/src/scheduled-stuck.ts

@@ -59,6 +59,7 @@ export function stuckTimeoutMs(scheduleJson: string): number {
 export type StuckBlockerClock = {
   created_at: string;
   consumed_at?: string | null;
+  last_activity_at?: string | null;
   started_at?: string | null;
 };
 
@@ -77,6 +78,12 @@ export function blockerTimeoutClock(blocker: StuckBlockerClock, scheduleJson: st
     if (!value) continue;
     const at = parseDbTimestampMs(value);
     if (Number.isFinite(at) && at <= nowMs && (!Number.isFinite(created) || at >= created)) {
+      if (source === "consumed_at" && blocker.last_activity_at) {
+        const activity = parseDbTimestampMs(blocker.last_activity_at);
+        if (Number.isFinite(activity) && activity >= at && activity <= nowMs) {
+          return { ageMs: nowMs - activity, limitMs: stuckTimeoutMs(scheduleJson), source: "last_activity_at" };
+        }
+      }
       return { ageMs: nowMs - at, limitMs: stuckTimeoutMs(scheduleJson), source };
     }
   }
@@ -153,7 +160,7 @@ export function stuckNoticeText(n: StuckNotice): { title: string; text: string }
     return {
       title: "定时任务被卡住",
       text: `定时任务「${n.scheduleName}」被上一次的执行卡住了:任务 ${n.taskId} 于 ${started} 派给节点 ${n.alias},到现在还没有完成,之后的 ${n.skips} 次执行都被跳过。\n\n`
-        + `从实际开始执行起超过 ${fmtDuration(n.timeoutMs)} 后会被自动按超时结束;尚未开始的任务从派发起计时,所有执行仍受总时限保护。下一次照常派发。等不及可以在任务列表里取消这条任务。`,
+        + `距上次任务活动或实际开始执行超过 ${fmtDuration(n.timeoutMs)} 后会被自动按超时结束;尚未开始的任务从派发起计时,所有执行仍受总时限保护。下一次照常派发。等不及可以在任务列表里取消这条任务。`,
     };
   }
   return {

package/src/scheduled-tasks.ts

@@ -412,8 +412,8 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       // received:节点那边有没有把这条任务取走过(inbox 行被 ack,或任务已进 acked/running)。
       // 跳过记录带上它,客户端才分得清「节点还没收到」和「节点在处理」—— 前者是投递故障,
       // 后者才是真的上一次还没做完。
-      const findOpen = () => db.get<{ task_id: string; received: number; created_at: string; consumed_at: string | null; started_at: string | null; status: string }>(
-        `SELECT r.task_id, t.created_at, t.consumed_at, t.started_at, t.status,
+      const findOpen = () => db.get<{ task_id: string; received: number; created_at: string; consumed_at: string | null; started_at: string | null; last_activity_at: string | null; status: string }>(
+        `SELECT r.task_id, t.created_at, t.consumed_at, t.started_at, t.last_activity_at, t.status,
                 CASE WHEN t.status IN ('acked', 'running')
                        OR EXISTS (SELECT 1 FROM inbox i WHERE (i.task_id = r.task_id OR i.id = r.task_id) AND i.acked = 1)
                      THEN 1 ELSE 0 END AS received

package/src/server.ts

@@ -1520,7 +1520,7 @@ return Bun.serve({
         // #711 不带 keep_cli_tokens 的请求(旧 app、dashboard 代理)= 改密码前的行为:撤销全部不绑网络的令牌。
         // keep_cli_tokens 必须是布尔 true 才保留命令行 / 脚本令牌。
         const meta = resolved.tokenId ? getUserTokenMeta(resolved.user.user_id, resolved.tokenId) : null;
-        const result = changePassword(resolved.user.user_id, body.old_password, body.new_password, resolved.tokenId, { keepCliTokens: body.keep_cli_tokens === true });
+        const result = changePassword(resolved.user.user_id, body.old_password, body.new_password, resolved.tokenId, { keepCliTokens: body.keep_cli_tokens === true, revokeNetworkTokens: body.revoke_network_tokens === true });
         if (result.ok) {
           // 换发的新令牌沿用当前这条的种类和设备标识:anet passwd 换完仍是命令行令牌。
           const issued = issueUserToken(resolved.user.user_id, "password-change", { kind: meta?.kind, clientLabel: meta?.client_label, userAgent: meta?.user_agent });

package/src/task-activity.ts

@@ -0,0 +1,60 @@
+import { db } from "./db.js";
+import { resolveNodeCaller } from "./create-node.js";
+
+type Context = { task_id: string; thread_id: string; turn_id: string };
+
+/** Renew only an already-consumed, exact original turn. No alias/content/heartbeat inference. */
+export function markTaskActivity(input: {
+  tokenId: string | null | undefined;
+  networkId: string | null | undefined;
+  nodeToken: boolean;
+  identityRejected: boolean;
+  taskIds: string[];
+  contexts: Context[];
+}) {
+  const deny = (error: string, task_id?: string) => ({ ok: false as const, error, ...(task_id ? { task_id } : {}) });
+  if (!input.nodeToken || !input.networkId || input.identityRejected) return deny("node_token_required");
+  if (db.transactionalFeaturesRefusal !== null) return deny("task_runtime_evidence_backend_unsupported");
+  if (new Set(input.taskIds).size !== input.taskIds.length) return deny("duplicate_task_id");
+  const contexts = new Map(input.contexts.map((c) => [c.task_id, c]));
+  if (contexts.size !== input.contexts.length) return deny("duplicate_task_context");
+  const foreign = input.contexts.find((c) => !input.taskIds.includes(c.task_id));
+  if (foreign) return deny("task_context_not_requested", foreign.task_id);
+  const missing = input.taskIds.find((id) => !contexts.has(id));
+  if (missing) return deny("task_activity_context_required", missing);
+
+  return db.transaction(() => {
+    // Resolve inside the transaction: renamed sessions and same-name rows cannot substitute for the token.
+    const caller = resolveNodeCaller(input.tokenId);
+    if (!caller.ok || caller.kind !== "node" || caller.networkId !== input.networkId) return deny("node_token_required");
+    const placeholders = input.taskIds.map((_, i) => `?${i + 2}`).join(", ");
+    const rows = db.all<{ task_id: string; to_node_id: string | null; status: string; consumed_at: string | null; thread_id: string | null; turn_id: string | null }>(
+      `SELECT task_id, to_node_id, status, consumed_at, thread_id, turn_id FROM tasks
+       WHERE network_id = ?1 AND task_id IN (${placeholders})`, input.networkId, ...input.taskIds,
+    );
+    const byId = new Map(rows.map((row) => [row.task_id, row]));
+    for (const id of input.taskIds) {
+      const row = byId.get(id);
+      if (!row || row.to_node_id !== caller.nodeId) return deny("task_not_owned", id);
+      if (!["created", "delivered", "acked", "running"].includes(row.status)) return deny("task_activity_terminal", id);
+      if (!row.consumed_at || !row.thread_id || !row.turn_id) return deny("task_activity_not_consumed", id);
+      const context = contexts.get(id)!;
+      if (row.thread_id !== context.thread_id || row.turn_id !== context.turn_id) return deny("task_runtime_context_conflict", id);
+    }
+    for (const id of input.taskIds) {
+      const context = contexts.get(id)!;
+      const changed = db.run(
+        `UPDATE tasks SET last_activity_at = datetime('now')
+         WHERE task_id = ?1 AND network_id = ?2 AND to_node_id = ?3
+           AND thread_id = ?4 AND turn_id = ?5 AND consumed_at IS NOT NULL
+           AND status IN ('created', 'delivered', 'acked', 'running')`,
+        [id, input.networkId, caller.nodeId, context.thread_id, context.turn_id],
+      );
+      if (changed.changes !== 1) throw new Error(`task_activity_write_race:${id}`);
+    }
+    return { ok: true as const, tasks: db.all<{ task_id: string; last_activity_at: string }>(
+      `SELECT task_id, last_activity_at FROM tasks WHERE network_id = ?1 AND task_id IN (${placeholders})`,
+      input.networkId, ...input.taskIds,
+    ) };
+  });
+}

package/src/tools.ts

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { markTaskActivity } from "./task-activity.js";
 import { requestProviderSnapshot, requestProviderWrite, requestProviderCollection, requestProviderApplication, requestProviderLogin, getProviderSnapshot, pullProviderSnapshots, ackProviderSnapshot } from "./daemon-provider-snapshots.js";
 import { readHubProviders, putHubProvider, bindHubProvider } from './hub-provider-config.js';
 import { requestScopedSecrets, getScopedSecrets, pullScopedSecrets, ackScopedSecrets, requestNodeSecrets, pullNodeSecrets, ackNodeSecrets } from './scoped-secrets.js';
@@ -1696,9 +1697,11 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
 
   server.tool(
     "mark_tasks_consumed",
-    "Internal agent-node signal: exact tasks produced attributable turn-start/activity evidence in this token-bound node's runtime.",
-    taskRuntimeEvidenceSchema,
-    async ({ task_ids, task_contexts }) => markTaskRuntimeEvidence(task_ids, "consumed", task_contexts),
+    "Internal token-bound task consumption; activity_only reports original-turn activity.",
+    { ...taskRuntimeEvidenceSchema, activity_only: z.boolean().optional() },
+    async ({ task_ids, task_contexts, activity_only }) => activity_only
+      ? { content: [{ type: "text" as const, text: JSON.stringify(markTaskActivity({ tokenId: callerTokenId, networkId: enforceNetworkId, nodeToken: callerTokenIsNetwork, identityRejected: callerIdentityRejected, taskIds: task_ids, contexts: task_contexts ?? [] })) }] }
+      : markTaskRuntimeEvidence(task_ids, "consumed", task_contexts),
   );
 
   // ═══════════════════════════════════════════