@bolloon/bolloon-agent 0.4.32 → 0.5.0

package/dist/cli/identity-command.js

@@ -0,0 +1,177 @@
+/**
+ * identity-command.ts — `bolloon identity init|show` (2026-09-24)
+ *
+ * 补的真缺口: 建本机身份以前**只有** `bolloon setup` —— 一个 readline 交互向导。
+ * 没有 TTY 的环境 (CI / 容器 / ssh 管道 / 第二实例的自动化) 跑它会
+ * `readline was closed` (ERR_USE_AFTER_CLOSE), 于是"新机器/第二个身份"根本建不出来,
+ * 而群/任务/签名这条链全靠 `~/.bolloon/identity.json`。
+ *
+ * 本模块只做薄包装 (不重实现任何密钥学):
+ *   · `init` — 幂等建 `~/.bolloon/identity.json` (复用 `setup-wizard.initLocalIdentity`,
+ *     它内部走 `KeyManager.generate/saveToFile`, 与 `src/index.ts:bootstrapIdentity` 同一条路径);
+ *     已存在 → **一个字不改** + `action:'reused'` + exit 0; 损坏 → **拒绝覆盖** (要 --force)。
+ *   · `show` — 只出 did / 公钥指纹 / 文件权限; **绝不打印私钥**。
+ *
+ * 红线: 本模块任何路径都不把 `privateKey` 写进 stdout / data / human。
+ * 兜底还有 `finalizeEnvelope` 的 `redactSecrets` (AUDIT_FORBIDDEN_KEYS 含 `privateKey`)。
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import { okEnvelope, failEnvelope, line, title, hint, plain, has, } from './protocol-envelope.js';
+import { getLocalIdentityFile, initLocalIdentity } from './setup-wizard.js';
+import { AUDIT_FORBIDDEN_KEYS } from '../agents/task-contract.js';
+export const IDENTITY_USAGE = `
+${title('bolloon identity')}
+  bolloon identity init [--force] [--json]
+      非交互建本机身份 → ~/.bolloon/identity.json (文件模式 0600)
+      字段与既有完全一致: keyType='Ed25519' · privateKey · publicKey · did · createdAt · version
+      幂等: 已存在 → 一个字不改 (action=reused), 仍然 exit 0
+      损坏 (读不出 did) → 拒绝覆盖 (exit 1); 确认重来加 --force (会先备份成 .bak-<时间戳>)
+      **绝不打印私钥** (输出只有 did / 文件路径 / 文件权限)
+  bolloon identity show [--json]
+      看本机身份: did · 公钥指纹(sha256 前 16 位) · 文件权限 · 创建时间 (不含私钥)
+
+选项: --json · --quiet · --force (只对 init 有效)
+说明: 只建 identity.json; 供应商/API key 仍走 bolloon setup (或 bolloon setup --provider … --api-key …);
+      用户称呼/归属身份在 ~/.bolloon/identity/user.json (bolloon setup --name 写它)
+`;
+/** 公钥指纹 (sha256 前 16 位 hex) —— 不可逆, 不含密钥材料 */
+function fingerprint(pub) {
+    return `sha256:${crypto.createHash('sha256').update(String(pub || '')).digest('hex').slice(0, 16)}`;
+}
+/** 读现有身份文件 (只取**非私密**字段; privateKey 连读都不读出来) */
+async function readIdentityPublicFacts(home) {
+    const file = getLocalIdentityFile(home);
+    try {
+        const j = JSON.parse(await fs.readFile(file, 'utf-8'));
+        const pub = typeof j?.publicKey === 'string' ? j.publicKey : null;
+        return {
+            exists: true,
+            did: typeof j?.did === 'string' && j.did ? j.did : null,
+            keyType: typeof j?.keyType === 'string' ? j.keyType : null,
+            createdAt: typeof j?.createdAt === 'string' ? j.createdAt : null,
+            version: typeof j?.version === 'string' ? j.version : null,
+            fingerprint: pub ? fingerprint(pub) : null,
+            // 只报**非私密**字段名 (schema 一致性的证据落在测试里: 那边直接读文件比对 6 个键)。
+            // 私钥类字段名 (AUDIT_FORBIDDEN_KEYS: privateKey/…) 连名字都不出现在输出里 ——
+            // 免得"输出里有个 privateKey 字样"被当成可疑, 也让 `grep privateKey` 这种粗检查能直接过。
+            keys: Object.keys(j ?? {}).filter((k) => !AUDIT_FORBIDDEN_KEYS.includes(k)).sort(),
+        };
+    }
+    catch {
+        return { exists: false };
+    }
+}
+/** `bolloon identity init` —— 幂等建本机身份 */
+async function identityInit(flags) {
+    const head = 'bolloon identity init';
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    const force = has(flags, '--force');
+    let r;
+    try {
+        r = await initLocalIdentity(home, { force });
+    }
+    catch (e) {
+        return {
+            envelope: failEnvelope('INTERNAL_ERROR', `建身份失败: ${String(e?.message || e).slice(0, 200)}`, { file: getLocalIdentityFile(home), created: false }, [], 'needs_human'),
+            human: `${title(head)}\n  建身份失败: ${String(e?.message || e).slice(0, 200)}`,
+        };
+    }
+    if (!r.ok) {
+        // 拒绝覆盖 (损坏 / force 下备份失败): 如实失败, 不静默重建
+        return {
+            envelope: failEnvelope('POLICY_DENIED', r.reason || '拒绝覆盖既有身份文件', { file: r.file, action: r.action, created: false, overwritten: false }, [], 'needs_human'),
+            human: `${title(head)}\n  ${r.reason || '拒绝覆盖'}\n\n${hint('静默盖掉一个可能还能救的身份 = 丢钥匙: 本命令宁可失败')}`,
+        };
+    }
+    const reused = r.action === 'reused';
+    const facts = await readIdentityPublicFacts(home);
+    const payload = {
+        action: r.action,
+        did: r.did ?? null,
+        file: r.file,
+        mode: r.mode ?? null,
+        created: !reused,
+        changed: false,
+        keyMaterialInOutput: false,
+        publicFields: facts.exists ? facts.keys : null,
+        fingerprint: facts.exists ? facts.fingerprint : null,
+        keyType: facts.exists ? facts.keyType : null,
+        createdAt: facts.exists ? facts.createdAt : null,
+        version: facts.exists ? facts.version : null,
+        nextSteps: reused
+            ? ['身份已存在, 未改动 (幂等); 直接用即可']
+            : ['跑任务/建群/签名现在有身份可用: bolloon task group create --name <群名>', '要配模型供应商/API key: bolloon setup'],
+    };
+    return {
+        envelope: okEnvelope('OK', reused
+            ? `本机身份已存在, 未改动 (${String(r.did).slice(0, 24)}…)`
+            : `已建本机身份 (${String(r.did).slice(0, 24)}…), 文件模式 ${r.mode}`, payload, [], null),
+        human: [
+            title(head),
+            line('动作', reused ? 'reused (已存在, 一个字没改 — 幂等)' : 'created (新建)'),
+            line('DID', r.did ?? '(无)'),
+            line('身份文件', r.file),
+            line('文件模式', r.mode ?? '(读不到)'),
+            line('字段', facts.exists ? facts.keys.join(' · ') : '(无)'),
+            line('公钥指纹', facts.exists ? facts.fingerprint : '(无)'),
+            '',
+            `  ${hint(reused ? '幂等: 第二个身份请换一个 HOME (HOME=/tmp/x bolloon identity init)' : '下一步')}`,
+            ...(reused
+                ? ['  要用第二个身份: `HOME=/tmp/second bolloon identity init` (每个 HOME 一对自己的密钥)']
+                : ['  建群: bolloon task group create --name <群名>', '  模型/API key: bolloon setup (交互向导)']),
+        ].join('\n'),
+    };
+}
+/** `bolloon identity show` —— 看本机身份 (不含私钥) */
+async function identityShow(flags) {
+    const head = 'bolloon identity show';
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    const facts = await readIdentityPublicFacts(home);
+    const file = getLocalIdentityFile(home);
+    if (!facts.exists) {
+        return {
+            envelope: failEnvelope('NOT_FOUND', `本机还没有身份文件: ${file}`, { file, exists: false, howTo: 'bolloon identity init', keyMaterialInOutput: false }, [], 'needs_human'),
+            human: `${title(head)}\n  本机还没有身份文件: ${file}\n\n${hint('建一个: bolloon identity init (非交互, 0600, 幂等)')}`,
+        };
+    }
+    const payload = {
+        file,
+        exists: true,
+        did: facts.did,
+        keyType: facts.keyType,
+        createdAt: facts.createdAt,
+        version: facts.version,
+        fingerprint: facts.fingerprint,
+        publicFields: facts.keys,
+        keyMaterialInOutput: false,
+    };
+    return {
+        envelope: okEnvelope('OK', `本机身份: ${String(facts.did).slice(0, 24)}…`, payload, [], null),
+        human: [
+            title(head),
+            line('DID', facts.did ?? '(缺 did — 文件可能损坏)'),
+            line('身份文件', file),
+            line('keyType', facts.keyType ?? '(无)'),
+            line('version', facts.version ?? '(无)'),
+            line('createdAt', facts.createdAt ?? '(无)'),
+            line('公钥指纹', facts.fingerprint ?? '(无)'),
+            line('非私密字段', facts.keys.join(' · ')),
+            '',
+            '  私钥只在本机文件里 (0600), 不进任何输出/日志',
+        ].join('\n'),
+    };
+}
+/** 命令入口 (cli-entry 用 runCommand 包它: 统一 --json/--quiet/--timeout/异常兜底) */
+export async function identityCommand(flags) {
+    const sub = String(flags.positionals[0] ?? '').trim().toLowerCase();
+    if (sub === 'init')
+        return identityInit(flags);
+    if (sub === 'show' || sub === 'status')
+        return identityShow(flags);
+    return {
+        envelope: failEnvelope('INVALID_ARGUMENT', sub ? `未知 identity 子命令: ${sub}` : '缺少 identity 子命令 (init | show)', { usage: plain(IDENTITY_USAGE.trim()), accepted: ['bolloon identity init', 'bolloon identity show'] }, [], 'needs_human'),
+        human: IDENTITY_USAGE,
+    };
+}

package/dist/cli/protocol-envelope.js

@@ -71,6 +71,10 @@ const OPTIONS_WITH_VALUE = new Set([
     '--confirmation-window', '--proof-version', '--from-block', '--gate',
     // 2026-09-22 (P6b): 链上**写**操作的**授权意图**声明 (MCP 写 tool 必填; 只可能收紧, 不可能放权)
     '--payment-mode',
+    // 2026-09-23 (C1): 任务公告板 `bolloon task publish|board|claim` 的显式公告号
+    '--announcement-id',
+    // 2026-09-23 (C7): 群聊通道 `bolloon task announce|trail|post` 的群链接/groupId + 极短事实字段
+    '--group', '--round', '--criteria', '--kind', '--hash', '--bytes', '--checks', '--verdict', '--limit', '--from',
 ]);
 export function parseFlags(args) {
     const flags = { json: false, quiet: false, positionals: [], options: new Map(), raw: args };

package/dist/cli/setup-wizard.js

@@ -109,6 +109,77 @@ export async function writeUserIdentity(name, home = os.homedir()) {
     await fs.writeFile(file, JSON.stringify(identity, null, 2), { encoding: 'utf-8', mode: 0o600 });
     return { identity, created, file };
 }
+// ---------------------------------------------------------------- 本机 DIAP 身份 (非交互)
+/** 本机 DIAP 身份文件 —— 与 index.ts `bootstrapIdentity()` / local-signer / network-pulse 同源 */
+export function getLocalIdentityFile(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'identity.json');
+}
+/**
+ * **非交互**建本机 DIAP 身份 (2026-09-24)。给新机器 / 第二实例用 ——
+ * `bolloon setup` 是 readline 交互向导, 在没有 TTY 的环境里会 `readline was closed`
+ * (ERR_USE_AFTER_CLOSE), 于是自动化流程根本建不出身份。
+ *
+ * 三条硬纪律:
+ *   ① **复用现有生成逻辑**, 不新写一套密钥学 —— 走 `KeyManager.generate()` +
+ *      `KeyManager.saveToFile()` (与 `src/index.ts:bootstrapIdentity` 完全同一条路径),
+ *      落盘字段因此天然一致: `{ keyType:'Ed25519', privateKey, publicKey, did, createdAt, version }`,
+ *      文件模式 `0600`。
+ *   ② **幂等**: 已存在且能解析出 did → 不动、`action:'reused'` (调用方 exit 0)。
+ *      文件存在但**读不出 did** (损坏) → `action:'refused'` 并**拒绝覆盖** ——
+ *      静默盖掉一个可能还能救的身份是丢钥匙, 比失败糟得多; 要重来必须显式 `force`
+ *      (覆盖前先把老文件备份成 `identity.json.bak-<时间戳>`)。
+ *   ③ **绝不打印/返回私钥**: 返回体里只有 did / 文件路径 / 权限。
+ */
+export async function initLocalIdentity(home = os.homedir(), opts = {}) {
+    const file = getLocalIdentityFile(home);
+    const readDid = async () => {
+        try {
+            const j = JSON.parse(await fs.readFile(file, 'utf-8'));
+            return j && typeof j.did === 'string' && j.did ? j.did : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const exists = await fs.stat(file).then(() => true).catch(() => false);
+    if (exists) {
+        const did = await readDid();
+        if (did && !opts.force) {
+            return { ok: true, action: 'reused', file, did, mode: await fileMode(file) };
+        }
+        if (!did && !opts.force) {
+            return {
+                ok: false, action: 'refused', file,
+                reason: `${file} 已存在但读不出 did (损坏?) → **不覆盖** (那可能是丢钥匙)。确认要重建再加 --force (会先备份成 .bak-<时间戳>)`,
+            };
+        }
+        // force: 先备份再重建 (备份失败 → 不重建)
+        try {
+            await fs.copyFile(file, `${file}.bak-${Date.now()}`);
+        }
+        catch (e) {
+            return { ok: false, action: 'refused', file, reason: `--force 下备份老文件失败, 拒绝重建: ${String(e?.message || e).slice(0, 160)}` };
+        }
+    }
+    const { KeyManager } = await import('@diap/sdk');
+    const kp = KeyManager.generate();
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await KeyManager.saveToFile(kp, file); // 同 bootstrapIdentity: 0600 + 6 字段
+    try {
+        await fs.chmod(file, 0o600);
+    }
+    catch { /* 某些平台/文件系统 no-op */ }
+    return { ok: true, action: 'created', file, did: String(kp.did || ''), mode: await fileMode(file) };
+}
+/** 文件权限 (八进制字符串; 读不到 → undefined) */
+async function fileMode(file) {
+    try {
+        return ((await fs.stat(file)).mode & 0o777).toString(8);
+    }
+    catch {
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------- 首次运行判断
 // providerUsable 只有一份实现 (setup-store)
 /** 首次运行: 没有可用供应商, 或还没有用户身份 */

package/dist/cli/update-commands.js

@@ -13,8 +13,9 @@
  *   2  检查不可用 (离线 / registry 不可用 / 读不到本地版本) —— 与"没有更新"区分开
  */
 import { resolveBolloonHome } from '../setup/setup-store.js';
-import { collectVersionInfo, renderVersionText, renderVersionJson, } from '../utils/version-info.js';
-import { checkForUpdate, buildUpdatePlan, renderUpdatePlan, applyUpdate, readUpdateStatus, readHistory, renderHistory, updateSummaryFor, compareVersions, } from '../utils/update-manager.js';
+import { collectVersionInfo, renderVersionText, renderVersionJson, DEV_CHANNEL_WARNING, DEV_BACK_TO_STABLE_HINT, channelKindOf, isDevIdentity, } from '../utils/version-info.js';
+import { checkForUpdate, buildUpdatePlan, renderUpdatePlan, applyUpdate, readUpdateStatus, readHistory, renderHistory, updateSummaryFor, compareVersions, checkExitCode, REFUSED_STATUSES, } from '../utils/update-manager.js';
+import { renderGithubReportLine } from '../utils/dual-source.js';
 import { runDoctor, renderDoctor } from '../utils/update-health.js';
 import { detectRuntimeReport, bootstrapRuntimes, renderRuntimeReport, renderBootstrapPlan, RUNTIME_MIN, readRuntimeConfigWithFallback, } from '../utils/runtime-bootstrap.js';
 const RESET = '\x1b[0m';
@@ -25,6 +26,45 @@ const YELLOW = '\x1b[38;2;245;158;11m';
 const RED = '\x1b[38;2;239;68;68m';
 const out = (s) => process.stdout.write(s + '\n');
 const err = (s) => process.stderr.write(s + '\n');
+// ── --channel (§12.2: 只覆盖本次进程, 不落盘) ───────────────────────────────
+/** 允许的通道字面量 (`--channel stable|dev`; beta 仍是"与 stable 同源"的老口径)。 */
+const CHANNEL_VALUES = ['stable', 'dev', 'beta'];
+/**
+ * 解析 `--channel <v>` / `--channel=<v>`。
+ * 给了不认识的值 → **拒绝并说清** (不静默落回 stable, 那会让人以为切成功了)。
+ */
+export function parseChannelArg(args) {
+    let raw = null;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--channel') {
+            raw = args[i + 1] ?? '';
+            break;
+        }
+        if (a.startsWith('--channel=')) {
+            raw = a.slice('--channel='.length);
+            break;
+        }
+        if (a === 'channel') {
+            raw = args[i + 1] ?? '';
+            break;
+        }
+    }
+    if (raw === null)
+        return { given: false };
+    const v = raw.trim().toLowerCase();
+    if (!CHANNEL_VALUES.includes(v)) {
+        return { given: true, error: `--channel 只接受 ${CHANNEL_VALUES.join('|')}, 收到 "${raw}" — 拒绝执行 (没有静默落回 stable)` };
+    }
+    return { channel: v, given: true };
+}
+/** dev 通道的三条硬约束 (§12.4) 在这里统一打印: 显式警告 + 记录 sha + 一键回 stable。 */
+function printDevNotice() {
+    out('');
+    out(DEV_CHANNEL_WARNING);
+    out(DEV_BACK_TO_STABLE_HINT);
+    out('');
+}
 // ── 版本 ────────────────────────────────────────────────────────────────────
 export async function runVersionCommand(args = []) {
     // 2026-09-19 (leo): 子命令一律**裸词**, 不再带 `--` 前缀 (只有 `--version` 本身保留 --)
@@ -78,22 +118,39 @@ function statusConclusion(status, latest, current) {
             const cmp = !latest ? '' : compareVersions(current, latest) < 0 ? ` — 已有更新版 ${latest}, 需按该安装方式手动升级` : ` — 本地 ${current} 已是 registry 上最新`;
             return `${YELLOW}当前安装方式不支持自动更新${RESET}${cmp}`;
         }
+        case 'github_unavailable': return `${RED}GitHub 源不可用${RESET} — ${BOLD}不能判定为最新${RESET}`;
+        case 'cross_check_mismatch': return `${RED}两个源不一致${RESET} — npm 与 GitHub 指向不同版本, ${BOLD}拒绝更新${RESET}`;
         default: return '尚未检查';
     }
 }
 export function renderCheckResult(r) {
+    const dev = r.channelKind === 'git-ref';
     const L = [];
-    L.push(`当前版本: ${r.currentVersion}`);
-    L.push(`最新版本: ${r.latestVersion || '未知'}`);
-    L.push(`更新通道: ${r.channel} (来源: ${r.source})`);
+    L.push(`当前版本: ${r.currentVersion}${r.installedDevSha ? ` (dev 快照 commit ${r.installedDevSha})` : ''}`);
+    L.push(`${dev ? '最新快照' : '最新版本'}: ${r.latestVersion || '未知'}`);
+    L.push(`更新通道: ${r.channel} (比较语义: ${r.channelKind || channelKindOf(r.channel)})`);
+    L.push(`当前来源: ${r.installedChannel === 'dev' ? `dev (GitHub master 快照 @ ${r.installedDevSha})` : 'stable (npm registry)'}`);
     L.push(`安装方式: ${r.installMethod}`);
+    if (dev)
+        L.push(renderGithubReportLine(r.github));
+    else {
+        L.push(renderGithubReportLine(r.github));
+        if (r.crossCheck)
+            L.push(`交叉校验: ${r.crossCheck.kind}${r.crossCheck.blocking ? ' (阻塞)' : ''} — ${r.crossCheck.detail}`);
+    }
+    if (r.dev)
+        L.push(`dev 判定: ${r.dev.detail}`);
+    if (r.switchableTo)
+        L.push(`能切回: ${r.switchableTo.channel} (${r.switchableTo.source}${r.switchableTo.target ? ` @ ${r.switchableTo.target}` : ''})`);
     L.push(`检查时间: ${r.checkedAt}${r.fromCache ? ' (缓存)' : ''}`);
     L.push(`结论: ${statusConclusion(r.status, r.latestVersion, r.currentVersion)}`);
     if (r.reason)
         L.push(`说明: ${r.reason}`);
     L.push('');
     if (r.status === 'update_available') {
-        L.push(`下一步: ${BOLD}bolloon update plan${RESET} 看计划, ${BOLD}bolloon update now${RESET} 执行更新`);
+        L.push(`下一步: ${BOLD}bolloon update plan --channel ${r.channel}${RESET} 看计划, ${BOLD}bolloon update now --channel ${r.channel}${RESET} 执行更新`);
+        if (dev)
+            L.push(DEV_CHANNEL_WARNING), L.push(DEV_BACK_TO_STABLE_HINT);
     }
     else if (r.status === 'unsupported_installation') {
         L.push('下一步: 按上面"说明"里对应安装方式更新 (源码目录: git pull && npm install && npm run build:all)');
@@ -101,6 +158,14 @@ export function renderCheckResult(r) {
     else if (r.status === 'offline' || r.status === 'registry_unavailable') {
         L.push('下一步: 检查网络/代理后重跑 `bolloon update`; 也可以 `bolloon update status` 看上次结论');
     }
+    else if (r.status === 'github_unavailable') {
+        L.push('下一步: 检查到 GitHub 的网络/代理/限流后重跑 `bolloon update --channel dev`;'
+            + `${BOLD}dev 通道不会退回 stable 装旧版${RESET} —— 要稳定版请显式 --channel stable`);
+    }
+    else if (r.status === 'cross_check_mismatch') {
+        L.push('下一步: 两个发布源不一致, 先查清哪个是对的 (npm: registry dist-tags / GitHub: Release 记录);'
+            + '本条不执行任何安装, 也不会按 GitHub 的 tag 去装。');
+    }
     else if (r.status === 'local_version_unknown') {
         L.push('下一步: 重新安装 (npm install -g @bolloon/bolloon-agent) 以恢复 package.json');
     }
@@ -109,32 +174,63 @@ export function renderCheckResult(r) {
 export function renderStatusReport(s) {
     const L = [];
     const lu = s.lastUpdate;
+    const dev = s.installedChannel === 'dev';
     L.push(`${BOLD}更新状态${RESET}`);
     L.push(`当前版本:   ${s.currentVersion}`);
+    // ── §12.5: 必须说清"当前装的是哪个源 + 哪个版本/commit sha + 能切回哪个源" ──
+    L.push(`安装来源:   ${dev
+        ? `dev (GitHub master 快照, ref ${s.devRef || 'refs/heads/master'}, commit ${s.installedDevSha || '未知'})`
+        : 'stable (npm registry)'}`);
+    L.push(`身份标识:   ${dev ? `commit ${s.installedDevSha || '未知'}` : s.currentVersion}`);
+    L.push(`能切回:     ${s.switchableTo
+        ? `${s.switchableTo.channel} (${s.switchableTo.source}${s.switchableTo.target ? ` @ ${s.switchableTo.target}` : ''}) — 一键切: bolloon update now --channel ${s.switchableTo.channel}`
+        : '无 (未知来源)'}`);
+    if (s.lastDevSha && !dev)
+        L.push(`上次 dev:   commit ${s.lastDevSha}${s.devCheckedAt ? ` @ ${s.devCheckedAt}` : ''} (已切回 stable)`);
     L.push(`最新版本:   ${s.latestVersion || (s.lastCheckStatus ? '未知' : '尚未检查')}`);
     L.push(`是否最新:   ${statusConclusion(s.lastCheckStatus, s.latestVersion, s.currentVersion)}`);
-    L.push(`更新通道:   ${s.channel}`);
+    L.push(`更新通道:   ${s.channel} (比较语义: ${s.channelKind})`);
     L.push(`安装方式:   ${s.installMethod}`);
     L.push(`安装目录:   ${s.installDir}`);
     L.push(`运行入口:   ${s.entryPath}`);
+    if (s.sourceFacts) {
+        const f = s.sourceFacts;
+        L.push(`源事实:     npm ${f.npm?.reachable ? `可达 (latest=${f.npm.latest || '未知'})` : `不可达${f.npm?.detail ? ` (${f.npm.detail})` : ''}`}`
+            + ` · GitHub ${f.github?.reachable
+                ? `可达 (HEAD ${f.github.headSha ? f.github.headSha.slice(0, 7) : '未知'}, Release ${f.github.releases ?? 0}, Tag ${f.github.tags ?? 0})`
+                : `不可达${f.github?.reason ? ` (github_unavailable(${f.github.reason}))` : ' (未查询)'}`}`);
+        if (f.crossCheck)
+            L.push(`交叉校验:   ${f.crossCheck.kind}${f.crossCheck.blocking ? ' (阻塞)' : ''} — ${f.crossCheck.detail}`);
+    }
     L.push(`最近检查:   ${s.lastCheckAt || '从未'}${s.lastCheckReason ? ` (${s.lastCheckReason})` : ''}`);
     L.push(`最近更新:   ${lu ? `${lu.at} ${lu.from} → ${lu.to} [${lu.status}]${lu.reason ? ` ${lu.reason}` : ''}` : '无记录'}`);
     L.push(`最近失败:   ${s.lastFailure ? `${s.lastFailure.at} @${s.lastFailure.stage}: ${s.lastFailure.reason}` : '无'}`);
     L.push(`需要重启:   ${s.needsRestart ? '是 (新版已就位, 重启后生效)' : '否'}`);
     L.push(`更新锁:     ${s.lock ? `有 (pid ${s.lock.pid}, ${s.lock.at}${s.lock.stale ? ', 已陈旧' : ''})` : '无'}`);
     L.push(`开关:       检查更新=${s.prefs.checkUpdates} (${s.prefs.sources.checkUpdates}) · 自动安装=${s.prefs.autoInstall} (${s.prefs.sources.autoInstall}) · 自动重启=${s.prefs.autoRestart} (${s.prefs.sources.autoRestart})`);
+    if (dev) {
+        L.push('');
+        L.push(DEV_CHANNEL_WARNING);
+        L.push(DEV_BACK_TO_STABLE_HINT);
+    }
     return L.join('\n');
 }
 // ── update 子命令 ───────────────────────────────────────────────────────────
 export async function runUpdateCommand(args = []) {
     const home = resolveBolloonHome();
-    // 裸词优先 (bolloon update plan / status / history / now / wait / force / json),
+    // 裸词优先 (bolloon update plan / status / history / now / wait / force / json / --channel dev),
     // 同时兼容旧的 --plan / --status / ... 写法 (已有脚本不断裂)。
     const has = (...f) => f.some((x) => args.includes(x));
     const json = has('json', '--json');
+    const ch = parseChannelArg(args);
+    if (ch.error) {
+        err(`${RED}✗ ${ch.error}${RESET}`);
+        return 2;
+    }
+    const channel = ch.channel;
     // ── 状态 ──
     if (has('status', '--status')) {
-        const s = await readUpdateStatus({ home });
+        const s = await readUpdateStatus({ home, channel });
         if (json) {
             out(JSON.stringify(s, null, 2));
             return 0;
@@ -156,21 +252,26 @@ export async function runUpdateCommand(args = []) {
     }
     // ── 计划 ──
     if (has('plan', '--plan')) {
-        const plan = await buildUpdatePlan({ home, force: true });
+        const plan = await buildUpdatePlan({ home, force: true, channel });
         if (json) {
             out(JSON.stringify(plan, null, 2));
             return 0;
         }
         out(renderUpdatePlan(plan));
+        if (plan.channelKind === 'git-ref')
+            printDevNotice();
         return 0;
     }
     // ── 执行 ──
     if (has('now', '--now')) {
         const wait = has('wait', '--wait');
         const force = has('force', '--force', '-f');
-        const plan = await buildUpdatePlan({ home, force: true });
-        if (!json)
+        const plan = await buildUpdatePlan({ home, force: true, channel });
+        if (!json) {
             out(renderUpdatePlan(plan));
+            if (plan.channelKind === 'git-ref')
+                printDevNotice();
+        }
         if (!plan.ok && plan.blockers.length > 0) {
             if (json)
                 out(JSON.stringify({ stage: 'blocked', reason: plan.blockers.join('; ') }, null, 2));
@@ -178,6 +279,17 @@ export async function runUpdateCommand(args = []) {
             return 1;
         }
         if (!plan.targetVersion) {
+            /**
+             * §12.5: 源不可达 / 版本不存在 → **拒绝并说清**, 退出码 2。
+             * 绝不打印"✅ 已是最新, 无需更新" (那正是这次要收敛掉的骗人行为)。
+             */
+            if (REFUSED_STATUSES.includes(plan.check.status)) {
+                if (json)
+                    out(JSON.stringify({ stage: 'blocked', refused: true, status: plan.check.status, reason: plan.check.reason }, null, 2));
+                err(`${RED}✗ 拒绝更新${RESET} (${plan.check.status}): ${plan.check.reason || '源不可达 / 版本不存在'}`);
+                err('  没有安装任何东西, 也没有静默退回旧版。');
+                return 2;
+            }
             if (json)
                 out(JSON.stringify({ stage: 'succeeded', ok: true, reason: '已是最新', from: plan.currentVersion, to: plan.currentVersion }, null, 2));
             out(`${GREEN}✓ 已是最新, 无需更新${RESET} (${plan.currentVersion})`);
@@ -185,27 +297,34 @@ export async function runUpdateCommand(args = []) {
         }
         const res = await applyUpdate({
             home,
+            channel,
             strategy: wait ? 'wait' : 'now',
             force,
             onStage: json ? undefined : (stage, detail) => out(`  [${stage}] ${detail}`),
         });
         if (json) {
             out(JSON.stringify(res, null, 2));
-            return res.ok ? 0 : 1;
+            return res.ok ? 0 : (res.stage === 'blocked' ? 2 : 1);
         }
         if (res.ok) {
             out(`${GREEN}✓ 更新成功${RESET}: ${res.from} → ${res.to} (${(res.durationMs / 1000).toFixed(1)}s)`);
+            if (isDevIdentity(res.to)) {
+                out(`  dev 快照已记录: commit ${res.to.split('+dev.')[1] || '未知'} (ref refs/heads/master) — bolloon update status 可查`);
+            }
             out('  正在做更新后健康检查...');
             const health = await runDoctor({ bolloonHome: home }).catch(() => null);
             if (health) {
                 out(renderDoctor(health));
             }
+            if (isDevIdentity(res.to))
+                printDevNotice();
             out(`${YELLOW}请重启 bolloon 以使用新版本${RESET}`);
             return 0;
         }
         if (res.stage === 'blocked') {
+            const refused = /拒绝更新|github_unavailable|cross_check_mismatch/.test(res.reason || '');
             err(`${YELLOW}! ${res.reason}${RESET}`);
-            return 1;
+            return refused ? 2 : 1;
         }
         err(`${RED}✗ 更新失败${RESET} (${res.stage}): ${res.reason}`);
         err(`  旧版本仍在: ${res.from} — 可继续使用; 详情: bolloon update status`);
@@ -214,21 +333,17 @@ export async function runUpdateCommand(args = []) {
         return 1;
     }
     // ── 默认: 只检查, 给清晰结论 (显式命令 = 忽略节流) ──
-    const r = await checkForUpdate({ home, force: true });
+    const r = await checkForUpdate({ home, force: true, channel });
     if (json) {
         out(JSON.stringify(r, null, 2));
-        return r.status === 'offline' || r.status === 'registry_unavailable' || r.status === 'local_version_unknown' ? 2 : 0;
+        return checkExitCode(r.status);
     }
     out(renderCheckResult(r));
     if (r.status !== 'up_to_date' && r.status !== 'check_skipped') {
         out('');
         out(`${YELLOW}提示${RESET}: 本次只检查, 没有安装任何东西。`);
     }
-    if (r.status === 'offline' || r.status === 'registry_unavailable' || r.status === 'local_version_unknown')
-        return 2;
-    if (r.status === 'update_available' && compareVersions(r.currentVersion, r.latestVersion || r.currentVersion) >= 0)
-        return 0;
-    return 0;
+    return checkExitCode(r.status);
 }
 // ── doctor ──────────────────────────────────────────────────────────────────
 export async function runDoctorCommand(args = []) {
@@ -323,12 +438,12 @@ export async function runRuntimeCommand(args = []) {
 }
 export const UPDATE_HELP = `
 ${BOLD}版本与更新:${RESET} (子命令一律裸词, 不带 -- 前缀)
-  bolloon --version                  版本 + 安装方式/目录/入口/通道/上游/是否最新
+  bolloon --version                  版本 + 安装方式/目录/入口/通道/来源身份/上游/是否最新
   bolloon --version verbose          诊断版 (构建时间/git/Node/npm/Python/配置目录/最近更新)
   bolloon --version json             机器版 (同一份 VersionInfo, 给脚本与问题报告)
   bolloon update                     只检查并给结论 (不安装任何东西)
   bolloon update plan                更新计划: 要更新什么 / 不会动什么 / 风险检查
-  bolloon update status              更新状态: 最近检查/最近更新/失败/是否需重启/开关
+  bolloon update status              更新状态: 装的哪个源+版本/commit+能切回哪/最近检查/失败/开关
   bolloon update history [N]         最近 N 次更新 (时间 · 版本变化 · 结果 · 耗时 · 原因)
   bolloon update now                 真正执行更新 (默认先看计划)
   bolloon update now wait            等当前 Run 结束后再更新 (有长期任务时的默认建议)
@@ -336,6 +451,15 @@ ${BOLD}版本与更新:${RESET} (子命令一律裸词, 不带 -- 前缀)
   bolloon doctor json                同上, 机器可读
   bolloon runtime [plan|install|json] 运行时 (Node/npm/Git/Python) 检查与安装 (install 需显式 yes)
 
+${BOLD}双源 (--channel):${RESET}
+  --channel stable  (默认) npm registry 是权威 (dist-tags.latest), GitHub Tag/Release 只做交叉校验;
+                           比较语义 = semver (npm 的 latest ↔ GitHub 同名 tag)
+  --channel dev     GitHub master HEAD 是唯一源; 比较语义 = git ref + commit sha (不用 semver);
+                           身份 = <版本>+dev.<sha7>; 未走发布门, 会打印警告并记录 sha
+  一键回稳定版:     bolloon update now --channel stable
+  --channel 只覆盖本次进程, 不落盘 (config 里的 updateChannel 仍是默认值)
+  源不可达 / 版本不存在 → 拒绝并说清 (退出码 2), 不会静默装回旧版
+
 ${BOLD}开关 (config.json):${RESET}
   checkUpdates (默认 true)   启动时后台检查
   autoInstall  (默认 false)  自动安装 —— 默认关, 需显式打开
@@ -344,6 +468,8 @@ ${BOLD}环境变量 (临时覆盖, 不落盘):${RESET}
   BOLLOON_SKIP_UPDATE=1      本次不检查
   BOLLOON_AUTO_UPDATE=1      本次允许自动安装
   BOLLOON_UPDATE_CHANNEL=stable|beta|dev
+  BOLLOON_GITHUB_API         覆盖 GitHub API 根 (镜像/受控验收用)
+  BOLLOON_DEV_SOURCE_DIR     dev 快照用本地源码树 (必须与该 sha 一致, 否则拒绝)
 
-${BOLD}退出码:${RESET} 0 正常 · 1 执行失败 · 2 检查不可用 (离线/registry 不可用/读不到本地版本)
+${BOLD}退出码:${RESET} 0 正常 · 1 执行失败 · 2 检查不可用 (离线/registry 不可用/GitHub 不可用/两源不一致/读不到本地版本)
 `;

package/dist/cli-entry.js

@@ -26,11 +26,12 @@ import { collectVersionInfo } from './utils/version-info.js';
 import { runServiceGroup, GROUPS_HELP } from './cli/commands/index.js';
 // 2026-09-21 (P4): MCP 适配层 (`bolloon mcp serve` = stdio, 只调 P3 服务层)
 import { runMcpCommand } from './cli/commands/mcp.js';
-import { legacyJson } from './cli/protocol-envelope.js';
+import { legacyJson, parseFlags, runCommand } from './cli/protocol-envelope.js';
+import { identityCommand } from './cli/identity-command.js';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 /** P3 `bolloon task <子命令>` 的已知子命令 —— 其它一律当 M1 任务正文 (既有体验不动) */
-const TASK_SUBCOMMANDS = new Set(['send', 'list', 'status', 'cancel', 'retry', 'result', 'inbox', 'accept', 'reject', 'run', 'complete']);
+const TASK_SUBCOMMANDS = new Set(['send', 'list', 'status', 'cancel', 'retry', 'result', 'inbox', 'accept', 'reject', 'run', 'complete', 'publish', 'board', 'claim', 'announce', 'trail', 'post', 'group']);
 const isWindows = process.platform === 'win32';
 // ANSI 颜色 — Bolloon Web UI 配色 truecolor
 function _fg(r, g, b) { return `\x1b[38;2;${r};${g};${b}m`; }
@@ -62,6 +63,8 @@ ${BOLD}选项:${RESET}
 
 ${BOLD}命令:${RESET}
   bolloon setup                     初始化向导 (你的称呼 + 模型供应商 + API key + 连通性测试)
+  bolloon identity init             非交互建本机身份 (~/.bolloon/identity.json, 0600, 幂等; 新机器/第二实例用)
+  bolloon identity show             看本机身份 (只出 DID/指纹, 绝不打印私钥)
   bolloon update [plan|status|history|now]   检查更新 / 计划 / 状态 / 历史 / 执行 (默认只检查)
   bolloon doctor                    安装入口 + 版本事实 + 更新状态自洽性诊断
   bolloon runtime [plan|install]    运行时 (Node/npm/Git/Python) 检查与安装
@@ -203,6 +206,9 @@ function parseArgs() {
         case 'setup':
         case 'init':
             return { mode: 'setup', args: args.slice(1) };
+        // 2026-09-24: 非交互建本机身份 (`bolloon identity init` → ~/.bolloon/identity.json)
+        case 'identity':
+            return { mode: 'identity', args: args.slice(1) };
         case 'read':
         case 'summarize':
         case 'improve':
@@ -890,6 +896,10 @@ async function main() {
         case 'setup':
             await handleSetupCommand(args);
             break;
+        // 2026-09-24: bolloon identity — 非交互建/看本机身份 (新机器/第二实例用; 幂等, 不打印私钥)
+        case 'identity':
+            process.exit(await runCommand(parseFlags(args), identityCommand));
+            break;
         case 'passthrough':
             // 传递所有参数给主程序
             try {