@agentoryhq/node 0.1.1 → 0.1.3

package/dist/align.d.ts

@@ -12,6 +12,10 @@ export type ApplyAlignResult = {
     mcpPath: string;
     skillsPath: string;
     snapshotPath?: string;
+    /** 规则写盘目录(rules-desired-config,cursor-only;未写规则时缺省) */
+    rulesDir?: string;
+    /** 被覆盖规则文件的快照目录(rules-<ts>/;无覆盖时缺省) */
+    rulesSnapshotDir?: string;
 };
 /** Host facade — routes to the matching RuntimeAdapter.applyAlign. */
 export declare function applyAlignPatch(opts: ApplyAlignOpts): ApplyAlignResult;

package/dist/align.test.js

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -61,3 +62,71 @@ test("applyAlignPatch routes claude-code to .mcp.json not .cursor/", () => {
     assert.equal(cursorMcp.mcpServers.keep?.command, "cursor-only");
     assert.ok(fs.existsSync(path.join(root, ".claude", "agentory-skills.json")));
 });
+// ── rules-desired-config 切片Ⅱ:cursor 规则写盘 + claude-code 诚实边界 ──
+test("applyAlignPatch cursor 规则:写 .cursor/rules/<名>.mdc(body 原样) + 覆盖前快照 + 越权名防御跳过", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-aln-rules-"));
+    fs.mkdirSync(path.join(root, ".cursor", "rules"), { recursive: true });
+    const existing = path.join(root, ".cursor", "rules", "code-style.mdc");
+    fs.writeFileSync(existing, "stale body");
+    const r = applyAlignPatch({
+        cursorRoot: root,
+        patch: {
+            mcp: [],
+            skills: [],
+            rules: [
+                { name: "code-style", body: "always X" },
+                { name: "new-rule", body: "# 标题\n正文" },
+                { name: "../evil", body: "x" },
+                { name: "a/b", body: "x" },
+            ],
+        },
+        confirmed: true,
+    });
+    assert.equal(r.ok, true);
+    // hash 契约:文件字节 = body 原样(不追加结尾换行) → sha256 与 API ruleBodyHash 同值
+    const bytes = fs.readFileSync(existing);
+    assert.equal(bytes.toString("utf8"), "always X");
+    assert.equal(createHash("sha256").update(bytes).digest("hex"), createHash("sha256").update("always X", "utf8").digest("hex"));
+    assert.equal(fs.readFileSync(path.join(root, ".cursor", "rules", "new-rule.mdc"), "utf8"), "# 标题\n正文");
+    // 越权名防御性跳过(第二闸):rules 目录之外零文件
+    assert.equal(fs.existsSync(path.join(root, ".cursor", "evil.mdc")), false);
+    assert.equal(fs.existsSync(path.join(root, "evil.mdc")), false);
+    assert.equal(fs.existsSync(path.join(root, ".cursor", "rules", "a")), false);
+    assert.equal(r.rulesDir, path.join(root, ".cursor", "rules"));
+    // 覆盖前快照既存文件
+    assert.ok(r.rulesSnapshotDir);
+    assert.equal(fs.readFileSync(path.join(r.rulesSnapshotDir, "code-style.mdc"), "utf8"), "stale body");
+});
+test("applyAlignPatch cursor 规则:无既存文件 = 零快照目录;空 patch.rules 不动 rules 目录", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-aln-rules2-"));
+    fs.mkdirSync(path.join(root, ".cursor"), { recursive: true });
+    const r1 = applyAlignPatch({
+        cursorRoot: root,
+        patch: { mcp: [], skills: [], rules: [{ name: "fresh", body: "b" }] },
+        confirmed: true,
+    });
+    assert.equal(r1.ok, true);
+    assert.equal(r1.rulesSnapshotDir, undefined);
+    assert.ok(fs.existsSync(path.join(root, ".cursor", "rules", "fresh.mdc")));
+    const r2 = applyAlignPatch({
+        cursorRoot: root,
+        patch: { mcp: [], skills: [] }, // 老形状 patch 无 rules 字段
+        confirmed: true,
+    });
+    assert.equal(r2.ok, true);
+    assert.equal(r2.rulesDir, undefined);
+    assert.equal(fs.readFileSync(path.join(root, ".cursor", "rules", "fresh.mdc"), "utf8"), "b");
+});
+test("applyAlignPatch claude-code 忽略 patch.rules(一期 cursor-only 诚实边界)", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-aln-cc-rules-"));
+    fs.mkdirSync(path.join(root, ".claude"), { recursive: true });
+    const r = applyAlignPatch({
+        cursorRoot: root,
+        runtime: "claude-code",
+        patch: { mcp: [], skills: [], rules: [{ name: "r", body: "b" }] },
+        confirmed: true,
+    });
+    assert.equal(r.ok, true);
+    assert.equal(fs.existsSync(path.join(root, ".claude", "rules")), false);
+    assert.equal(fs.existsSync(path.join(root, ".cursor", "rules", "r.mdc")), false);
+});

package/dist/client.d.ts

@@ -16,5 +16,20 @@ export declare function reportAssetIndex(): Promise<number>;
  * Called from the daemon index channel and `agentory-node transcript` CLI.
  */
 export declare function fulfillPendingTranscripts(): Promise<number>;
+/**
+ * 消息通道（ADR-005 拉模型第六通道 · agent-messaging 切片 4）：
+ * 拉取即锁定的 pending 消息 → adapter.invoke 逐条串行执行（一期单发单执行）→ 回流结果。
+ * 红线：不注入任何权限放宽 flag（invoke 实现内钉死）；纯 outbound 零反连；
+ * 消息正文/输出不落节点日志（只回计数与状态，transcript AC-9 同纪律）。
+ */
+export declare function fulfillPendingMessages(): Promise<number>;
+/**
+ * GitHub 任务通道（github-tasks 切片 3 · ADR-007 拉模型第七通道）：
+ * 拉取即锁定的 claimed 任务 → start（claimed→running）→ executeGithubTask
+ * （remote 校验 AC-4 / headless 执行 / commit+push 任务分支 AC-8）→ 回流结果。
+ * 红线：不注入任何权限放宽 flag（adapter.invoke 内钉死）；纯 outbound 零反连；
+ * issue 正文/输出不落节点日志（只回计数与状态，messaging AC-9 同纪律）。
+ */
+export declare function fulfillPendingGithubTasks(): Promise<number>;
 /** Pull confirmed plans and write Cursor files (AC-3). */
 export declare function applyPendingAligns(): Promise<number>;

package/dist/client.js

@@ -5,7 +5,9 @@ import { controlPlaneBaseUrl } from "@agentoryhq/shared";
 import { applyAlignPatch } from "./align.js";
 import { discoverAssetIndex } from "./asset-index.js";
 import { discoverAgentsWithHealth } from "./discover.js";
-import { captureTranscriptSnapshot, transcriptFileForSourceKey } from "./transcript.js";
+import { adapterForRuntime } from "./registry.js";
+import { captureTranscriptForSourceKey } from "./transcript.js";
+import { executeGithubTask } from "./github-task.js";
 function statePath() {
     return process.env.AGENTORY_NODE_STATE ?? path.join(os.homedir(), ".agentory", "node.json");
 }
@@ -124,8 +126,9 @@ export async function fulfillPendingTranscripts() {
     const snapshots = [];
     const misses = [];
     for (const req of pending) {
-        const file = transcriptFileForSourceKey(req.sourceKey);
-        const snap = file ? captureTranscriptSnapshot(file) : undefined;
+        // 跨 adapter 路由（claude-session-index AC-5）：cursor/claude key 各自
+        // 找到归属 adapter 捕获；未知前缀无人认领 → miss 上报（既有语义）。
+        const snap = captureTranscriptForSourceKey(req.sourceKey);
         if (snap)
             snapshots.push(snap);
         else
@@ -147,6 +150,166 @@ export async function fulfillPendingTranscripts() {
     }, null, 2));
     return 0;
 }
+/**
+ * 消息通道（ADR-005 拉模型第六通道 · agent-messaging 切片 4）：
+ * 拉取即锁定的 pending 消息 → adapter.invoke 逐条串行执行（一期单发单执行）→ 回流结果。
+ * 红线：不注入任何权限放宽 flag（invoke 实现内钉死）；纯 outbound 零反连；
+ * 消息正文/输出不落节点日志（只回计数与状态，transcript AC-9 同纪律）。
+ */
+export async function fulfillPendingMessages() {
+    const st = loadState();
+    if (!st) {
+        console.error("not registered; run: agentory-node register --token <root>");
+        return 2;
+    }
+    const { status, body } = await api("GET", `/v1/nodes/${st.nodeId}/messages/pending`, {
+        token: st.nodeToken,
+    });
+    if (status !== 200) {
+        console.error(status, JSON.stringify(body));
+        return 1;
+    }
+    const pending = body.messages ?? [];
+    if (!pending.length) {
+        console.log(JSON.stringify({ executed: 0, reported: 0, outcomes: {} }, null, 2));
+        return 0;
+    }
+    const cwd = process.cwd();
+    const outcomes = {};
+    let reported = 0;
+    let reportFailed = 0;
+    for (const msg of pending) {
+        let result;
+        const adapter = adapterForRuntime(msg.runtime);
+        if (!adapter?.invoke) {
+            // 控制面已按诚实集拦 409；走到这里 = 节点侧无该 runtime adapter（版本偏差），
+            // 诚实回流 failed 而不是静默丢弃。
+            result = {
+                outcome: "failed",
+                output: "",
+                truncated: false,
+                exitCode: null,
+                durationMs: 0,
+                errorText: `no invoke adapter for runtime ${msg.runtime}`,
+            };
+        }
+        else {
+            try {
+                result = await adapter.invoke({ homeDir: os.homedir(), cwd }, {
+                    prompt: msg.body,
+                    timeoutMs: msg.timeoutMs,
+                    maxOutputBytes: msg.maxOutputBytes,
+                    cwd,
+                });
+            }
+            catch (err) {
+                result = {
+                    outcome: "failed",
+                    output: "",
+                    truncated: false,
+                    exitCode: null,
+                    durationMs: 0,
+                    errorText: err instanceof Error ? err.message : String(err),
+                };
+            }
+        }
+        outcomes[result.outcome] = (outcomes[result.outcome] ?? 0) + 1;
+        const report = await api("POST", `/v1/nodes/${st.nodeId}/messages/report`, {
+            token: st.nodeToken,
+            body: {
+                messageId: msg.id,
+                outcome: result.outcome,
+                output: result.output,
+                truncated: result.truncated,
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+                runtimeSessionId: result.runtimeSessionId,
+                errorText: result.errorText,
+            },
+        });
+        // 业务失败（failed/timeout）是正常回流结果，不算通道失败；只有回流本身报错才非 0。
+        if (report.status === 200)
+            reported += 1;
+        else
+            reportFailed += 1;
+    }
+    console.log(JSON.stringify({ executed: pending.length, reported, reportFailed, outcomes }, null, 2));
+    return reportFailed ? 1 : 0;
+}
+/**
+ * GitHub 任务通道（github-tasks 切片 3 · ADR-007 拉模型第七通道）：
+ * 拉取即锁定的 claimed 任务 → start（claimed→running）→ executeGithubTask
+ * （remote 校验 AC-4 / headless 执行 / commit+push 任务分支 AC-8）→ 回流结果。
+ * 红线：不注入任何权限放宽 flag（adapter.invoke 内钉死）；纯 outbound 零反连；
+ * issue 正文/输出不落节点日志（只回计数与状态，messaging AC-9 同纪律）。
+ */
+export async function fulfillPendingGithubTasks() {
+    const st = loadState();
+    if (!st) {
+        console.error("not registered; run: agentory-node register --token <root>");
+        return 2;
+    }
+    const { status, body } = await api("GET", `/v1/nodes/${st.nodeId}/github-tasks/pending`, {
+        token: st.nodeToken,
+    });
+    if (status !== 200) {
+        console.error(status, JSON.stringify(body));
+        return 1;
+    }
+    const pending = body.tasks ?? [];
+    if (!pending.length) {
+        console.log(JSON.stringify({ executed: 0, reported: 0, outcomes: {} }, null, 2));
+        return 0;
+    }
+    const adapter = adapterForRuntime("claude-code");
+    // 一期单仓库：仓库工作目录 env 指定（部署面文档化,切片 6）；缺省 = daemon 进程 cwd（messaging 同口径）。
+    const repoDir = process.env.AGENTORY_GITHUB_REPO_DIR?.trim() || process.cwd();
+    const outcomes = {};
+    let reported = 0;
+    let reportFailed = 0;
+    for (const task of pending) {
+        const startRes = await api("POST", `/v1/nodes/${st.nodeId}/github-tasks/start`, {
+            token: st.nodeToken,
+            body: { taskId: task.id },
+        });
+        if (startRes.status !== 200) {
+            // claimed 锁定被并发取走/版本偏差：诚实计数,不执行不上报。
+            reportFailed += 1;
+            continue;
+        }
+        let report;
+        if (!adapter?.invoke) {
+            // 节点侧无 claude-code adapter（版本偏差）：诚实回流 failed 而不是静默丢弃。
+            report = {
+                outcome: "failed",
+                output: "",
+                truncated: false,
+                exitCode: null,
+                durationMs: 0,
+                errorText: "no invoke adapter for runtime claude-code",
+            };
+        }
+        else {
+            const invoke = adapter.invoke;
+            report = await executeGithubTask(task, {
+                repoDir,
+                invoke: (req) => invoke({ homeDir: os.homedir(), cwd: req.cwd }, req),
+            });
+        }
+        outcomes[report.outcome] = (outcomes[report.outcome] ?? 0) + 1;
+        const res = await api("POST", `/v1/nodes/${st.nodeId}/github-tasks/report`, {
+            token: st.nodeToken,
+            body: { taskId: task.id, ...report },
+        });
+        // 业务失败（failed/timeout）是正常回流结果;只有回流本身报错才非 0（messaging 同口径）。
+        if (res.status === 200)
+            reported += 1;
+        else
+            reportFailed += 1;
+    }
+    console.log(JSON.stringify({ executed: pending.length, reported, reportFailed, outcomes }, null, 2));
+    return reportFailed ? 1 : 0;
+}
 /** Pull confirmed plans and write Cursor files (AC-3). */
 export async function applyPendingAligns() {
     const st = loadState();

package/dist/daemon.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { controlPlaneBaseUrl } from "@agentoryhq/shared";
-import { applyPendingAligns, fulfillPendingTranscripts, heartbeat, loadState, reportAssetIndex, reportDiscovery } from "./client.js";
+import { applyPendingAligns, fulfillPendingGithubTasks, fulfillPendingMessages, fulfillPendingTranscripts, heartbeat, loadState, reportAssetIndex, reportDiscovery } from "./client.js";
 import { discoverAssetIndex } from "./asset-index.js";
 const MIN_INTERVAL_SEC = 5;
 const DEFAULTS = {
@@ -118,6 +118,14 @@ export async function runFullRound() {
         if (c !== 0)
             code = c;
     });
+    await runChannel("message", fulfillPendingMessages, (c) => {
+        if (c !== 0)
+            code = c;
+    });
+    await runChannel("github-task", fulfillPendingGithubTasks, (c) => {
+        if (c !== 0)
+            code = c;
+    });
     await runChannel("discover", reportDiscovery, (c) => {
         if (c !== 0)
             code = c;
@@ -198,6 +206,8 @@ export async function runDaemon(opts = {}) {
             await runChannel("heartbeat", heartbeat);
             await runChannel("align", applyPendingAligns);
             await runChannel("transcript", fulfillPendingTranscripts);
+            await runChannel("message", fulfillPendingMessages);
+            await runChannel("github-task", fulfillPendingGithubTasks);
             nextDue.heartbeat += intervals.heartbeatSec * 1000;
         }
         if (now >= nextDue.index) {

package/dist/discover.test.js

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -77,3 +78,29 @@ test("fixture overrides filesystem", () => {
     assert.equal(agents.length, 1);
     assert.equal(agents[0]?.mcp.length, 0);
 });
+// rules-desired-config 切片Ⅱ:规则发现只报名字 + sha256(文件字节),正文不出节点。
+test("discover cursor rules:名字+hash 上报 · cwd 优先 · 非 .mdc 忽略 · claude 恒空", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-disc-rules-"));
+    const home = path.join(root, "home");
+    const cwd = path.join(root, "proj");
+    fs.mkdirSync(path.join(cwd, ".cursor", "rules"), { recursive: true });
+    fs.mkdirSync(path.join(home, ".cursor", "rules"), { recursive: true });
+    fs.writeFileSync(path.join(cwd, ".cursor", "rules", "code-style.mdc"), "cwd body");
+    fs.writeFileSync(path.join(home, ".cursor", "rules", "code-style.mdc"), "home body"); // 同名:cwd 优先
+    fs.writeFileSync(path.join(home, ".cursor", "rules", "global.mdc"), "g");
+    fs.writeFileSync(path.join(cwd, ".cursor", "rules", "notes.md"), "ignored"); // 非 .mdc 不进规则维
+    const agents = discoverAgents({ homeDir: home, cwd });
+    const cursor = agents.find((a) => a.runtime === "cursor");
+    assert.ok(cursor);
+    const byName = new Map((cursor.rules ?? []).map((r) => [r.name, r]));
+    assert.equal(byName.size, 2);
+    assert.equal(byName.get("code-style")?.contentHash, createHash("sha256").update("cwd body", "utf8").digest("hex"));
+    assert.equal(byName.get("global")?.contentHash, createHash("sha256").update("g", "utf8").digest("hex"));
+    assert.equal(byName.has("notes"), false);
+    // claude-code 诚实边界:恒报空 rules
+    fs.mkdirSync(path.join(cwd, ".claude"), { recursive: true });
+    const agents2 = discoverAgents({ homeDir: home, cwd });
+    const claude = agents2.find((a) => a.runtime === "claude-code");
+    assert.ok(claude);
+    assert.deepEqual(claude.rules, []);
+});

package/dist/github-task.d.ts

@@ -0,0 +1,62 @@
+import type { InvokeResult } from "@agentoryhq/runtime-contract";
+/** 控制面 pending 载荷（PendingGithubTask 同构；client.ts HTTP 面内联解析，messaging 判例）。 */
+export type GithubTaskPayload = {
+    id: string;
+    repoOwner: string;
+    repoName: string;
+    defaultBranch: string;
+    issueNumber: number;
+    issueTitle: string;
+    issueBody: string;
+    branch: string;
+    timeoutMs: number;
+    maxOutputBytes: number;
+};
+/** 上报形状（控制面 GithubTaskReport 同构：outcome=done 时 pushedBranch 必有，AC-5）。 */
+export type GithubTaskRunReport = {
+    outcome: "done" | "failed" | "timeout";
+    output: string;
+    truncated: boolean;
+    exitCode: number | null;
+    durationMs: number;
+    errorText?: string;
+    pushedBranch?: string;
+};
+/** 令牌样式串脱敏（AC-12）：GitHub PAT 前缀族 + URL 内嵌凭据形态,一律 [redacted]。 */
+export declare function maskSecrets(text: string): string;
+/** remote URL → owner/repo（https / ssh:// / git@ 三形态；非 github.com → undefined = 校验失败）。 */
+export declare function parseGithubRepo(remoteUrl: string): {
+    owner: string;
+    repo: string;
+} | undefined;
+export type GitRunner = (args: string[], cwd: string) => Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;
+/** 默认 git runner：execFile（零 shell 注入面）；输出封顶防爆、超时兜底防挂死。 */
+export declare const runGit: GitRunner;
+/** 任务 prompt（AC-4：输入 = issue 标题+正文入队快照）；git 收尾由宿主负责,agent 只改工作区。 */
+export declare function githubTaskPrompt(task: GithubTaskPayload): string;
+export type ExecuteDeps = {
+    /** 仓库工作目录（实例项目目录,AC-4；client.ts 解析 env/cwd 后注入）。 */
+    repoDir: string;
+    /** 测试可注入假 git；缺省 = 真 execFile runner。 */
+    git?: GitRunner;
+    /** 执行注入（client.ts 接 claude-code adapter.invoke;单元测试接假实现）。 */
+    invoke: (req: {
+        prompt: string;
+        timeoutMs: number;
+        maxOutputBytes: number;
+        cwd: string;
+    }) => Promise<InvokeResult>;
+};
+/**
+ * 执行单任务（纯函数面）：
+ * ① git 工作区校验 → ② origin remote 与绑定仓库一致（不一致 → failed 零执行,AC-4）
+ * → ③ fetch 默认分支 + checkout -B 任务分支（入队定型,PR-only AC-8）
+ * → ④ invoke（claude-code headless 默认权限；超时 kill/截断承 messaging 判例）
+ * → ⑤ done 且有改动 → commit + push 任务分支 → done + pushedBranch（AC-5）;
+ *    failed/timeout 原样回流（不 commit 不 push,AC-6）;无改动 → failed no_changes（诚实,不开空 PR）。
+ */
+export declare function executeGithubTask(task: GithubTaskPayload, deps: ExecuteDeps): Promise<GithubTaskRunReport>;

package/dist/github-task.js

@@ -0,0 +1,132 @@
+// GitHub 任务执行器（github-tasks 切片 3 · ADR-007 拉模型第七通道）。
+// 红线：纯出站零反连（只调控制面 API 与本地 git）；errorText 全脱敏（git 错误文本可能
+// 含 remote 凭据——AC-12 令牌零明文）；invoke 走 claude-code adapter 默认权限（ADR-005
+// 红线，adapter 内钉死不注入放宽 flag）；PR-only：push 目标恒为入队定型分支 task.branch
+// （agentory/task-<id>），任何路径不直推默认分支（AC-8）。
+import { execFile } from "node:child_process";
+const ERROR_TEXT_CHARS = 200;
+const GIT_OUTPUT_CAP = 16_384;
+/** 令牌样式串脱敏（AC-12）：GitHub PAT 前缀族 + URL 内嵌凭据形态,一律 [redacted]。 */
+export function maskSecrets(text) {
+    return text
+        .replace(/\bgh[pousr]_[A-Za-z0-9]{16,}\b/g, "[redacted]")
+        .replace(/\bgithub_pat_[A-Za-z0-9_]{16,}\b/g, "[redacted]")
+        .replace(/\/\/[^/\s@]*:[^/\s@]*@/g, "//[redacted]@");
+}
+/** remote URL → owner/repo（https / ssh:// / git@ 三形态；非 github.com → undefined = 校验失败）。 */
+export function parseGithubRepo(remoteUrl) {
+    const url = remoteUrl.trim();
+    const patterns = [
+        /^https:\/\/github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+        /^ssh:\/\/git@github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+        /^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/,
+    ];
+    for (const p of patterns) {
+        const m = p.exec(url);
+        if (m)
+            return { owner: m[1], repo: m[2] };
+    }
+    return undefined;
+}
+/** 失败原因文本：先脱敏、压空白、再截短（控制面 failureReason 200 字符同口径）。 */
+function errText(prefix, detail) {
+    return `${prefix}: ${maskSecrets(detail).replace(/\s+/g, " ").trim()}`.slice(0, ERROR_TEXT_CHARS);
+}
+/** 默认 git runner：execFile（零 shell 注入面）；输出封顶防爆、超时兜底防挂死。 */
+export const runGit = (args, cwd) => new Promise((resolve) => {
+    execFile("git", args, { cwd, maxBuffer: GIT_OUTPUT_CAP * 2, timeout: 120_000 }, (err, stdout, stderr) => {
+        const e = err;
+        const code = typeof e?.code === "number" ? e.code : e ? 1 : 0;
+        resolve({
+            code,
+            stdout: String(stdout ?? "").slice(0, GIT_OUTPUT_CAP),
+            stderr: String(stderr ?? "").slice(0, GIT_OUTPUT_CAP),
+        });
+    });
+});
+/** 任务 prompt（AC-4：输入 = issue 标题+正文入队快照）；git 收尾由宿主负责,agent 只改工作区。 */
+export function githubTaskPrompt(task) {
+    return [
+        `处理 GitHub issue #${task.issueNumber}：${task.issueTitle}`,
+        "",
+        task.issueBody,
+        "",
+        `直接在当前工作区（分支 ${task.branch}）完成此 issue；把改动留在工作区即可，git add/commit/push 由宿主负责。`,
+    ].join("\n");
+}
+/**
+ * 执行单任务（纯函数面）：
+ * ① git 工作区校验 → ② origin remote 与绑定仓库一致（不一致 → failed 零执行,AC-4）
+ * → ③ fetch 默认分支 + checkout -B 任务分支（入队定型,PR-only AC-8）
+ * → ④ invoke（claude-code headless 默认权限；超时 kill/截断承 messaging 判例）
+ * → ⑤ done 且有改动 → commit + push 任务分支 → done + pushedBranch（AC-5）;
+ *    failed/timeout 原样回流（不 commit 不 push,AC-6）;无改动 → failed no_changes（诚实,不开空 PR）。
+ */
+export async function executeGithubTask(task, deps) {
+    const git = deps.git ?? runGit;
+    const startedAt = Date.now();
+    const fail = (errorText) => ({
+        outcome: "failed",
+        output: "",
+        truncated: false,
+        exitCode: null,
+        durationMs: Date.now() - startedAt,
+        errorText,
+    });
+    const topLevel = await git(["rev-parse", "--show-toplevel"], deps.repoDir);
+    if (topLevel.code !== 0) {
+        return fail(errText("not_a_git_repo", topLevel.stderr || "rev-parse failed"));
+    }
+    // 读配置原值而非 `remote get-url`：后者会应用 url.insteadOf 传输层重写（代理/凭据
+    // 替换场景返回重写后 URL），身份校验必须看仓库声明的 origin（AC-4）。
+    const remote = await git(["config", "--get", "remote.origin.url"], deps.repoDir);
+    if (remote.code !== 0)
+        return fail(errText("no_origin_remote", remote.stderr));
+    const parsed = parseGithubRepo(remote.stdout);
+    if (!parsed || parsed.owner !== task.repoOwner || parsed.repo !== task.repoName) {
+        // 不回显 remote URL（可能含凭据）——只说与哪个绑定仓库不一致。
+        return fail(`repo_mismatch: origin does not match binding ${task.repoOwner}/${task.repoName}`);
+    }
+    const fetched = await git(["fetch", "origin", task.defaultBranch], deps.repoDir);
+    if (fetched.code !== 0)
+        return fail(errText("fetch_failed", fetched.stderr));
+    const checkout = await git(["checkout", "-B", task.branch, `origin/${task.defaultBranch}`], deps.repoDir);
+    if (checkout.code !== 0)
+        return fail(errText("checkout_failed", checkout.stderr));
+    const result = await deps.invoke({
+        prompt: githubTaskPrompt(task),
+        timeoutMs: task.timeoutMs,
+        maxOutputBytes: task.maxOutputBytes,
+        cwd: deps.repoDir,
+    });
+    if (result.outcome !== "done") {
+        return {
+            outcome: result.outcome,
+            output: result.output,
+            truncated: result.truncated,
+            exitCode: result.exitCode,
+            durationMs: result.durationMs,
+            ...(result.errorText ? { errorText: errText("execution", result.errorText) } : {}),
+        };
+    }
+    await git(["add", "-A"], deps.repoDir);
+    const status = await git(["status", "--porcelain"], deps.repoDir);
+    if (status.code !== 0)
+        return fail(errText("status_failed", status.stderr));
+    if (!status.stdout.trim())
+        return fail("no_changes: agent produced no workspace changes");
+    const commit = await git(["commit", "-m", `agentory: ${task.issueTitle} (#${task.issueNumber})`], deps.repoDir);
+    if (commit.code !== 0)
+        return fail(errText("commit_failed", commit.stderr));
+    const push = await git(["push", "-u", "origin", task.branch], deps.repoDir);
+    if (push.code !== 0)
+        return fail(errText("push_failed", push.stderr));
+    return {
+        outcome: "done",
+        output: result.output,
+        truncated: result.truncated,
+        exitCode: result.exitCode,
+        durationMs: result.durationMs,
+        pushedBranch: task.branch,
+    };
+}

package/dist/github-task.test.js

@@ -0,0 +1,166 @@
+// github-task 执行器单测（github-tasks 切片 3）：假 git + 假 invoke 注入面。
+// 覆盖：remote URL 解析矩阵 · 脱敏（AC-12）· remote 不一致 failed 零执行（AC-4）·
+// happy path 全序列（fetch→checkout -B 任务分支→invoke→add/status/commit/push→done+pushedBranch,
+// AC-5/8）· invoke failed/timeout 原样回流不 push（AC-6）· 无改动 no_changes 诚实失败 ·
+// git 步骤失败脱敏回流 · prompt = issue 标题+正文快照（AC-4 输入面）。
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { executeGithubTask, githubTaskPrompt, maskSecrets, parseGithubRepo, } from "./github-task.js";
+const TASK = {
+    id: "ght_1",
+    repoOwner: "tunsuy",
+    repoName: "agentory",
+    defaultBranch: "main",
+    issueNumber: 901,
+    issueTitle: "修复登录闪烁",
+    issueBody: "复现步骤 BODY",
+    branch: "agentory/task-ght_1",
+    timeoutMs: 60_000,
+    maxOutputBytes: 1024,
+};
+/** 假 git：按 args 前缀匹配计划表;全调用留痕供序列断言。 */
+function fakeGit(plan, calls) {
+    return async (args) => {
+        const key = args.join(" ");
+        calls.push(args);
+        for (const [prefix, out] of plan) {
+            if (key.startsWith(prefix)) {
+                return { code: out.code ?? 0, stdout: out.stdout ?? "", stderr: out.stderr ?? "" };
+            }
+        }
+        return { code: 0, stdout: "", stderr: "" };
+    };
+}
+const OK_REMOTE = [
+    "config --get remote.origin.url",
+    { stdout: "https://github.com/tunsuy/agentory.git\n" },
+];
+function fakeInvoke(result, seen) {
+    return async (req) => {
+        seen.push({ prompt: req.prompt, cwd: req.cwd });
+        return {
+            outcome: "done",
+            output: "mock ok",
+            truncated: false,
+            exitCode: 0,
+            durationMs: 5,
+            ...result,
+        };
+    };
+}
+test("parseGithubRepo：https/ssh/git@ 三形态 + .git 后缀 + 非 github 拒绝", () => {
+    assert.deepEqual(parseGithubRepo("https://github.com/tunsuy/agentory.git"), { owner: "tunsuy", repo: "agentory" });
+    assert.deepEqual(parseGithubRepo("https://github.com/tunsuy/agentory"), { owner: "tunsuy", repo: "agentory" });
+    assert.deepEqual(parseGithubRepo("ssh://git@github.com/tunsuy/agentory.git"), { owner: "tunsuy", repo: "agentory" });
+    assert.deepEqual(parseGithubRepo("git@github.com:tunsuy/agentory.git"), { owner: "tunsuy", repo: "agentory" });
+    assert.equal(parseGithubRepo("https://gitlab.com/tunsuy/agentory.git"), undefined, "非 github.com 拒绝");
+    assert.equal(parseGithubRepo("https://github.com.evil.com/tunsuy/agentory.git"), undefined, "域名后缀伪装拒绝");
+    assert.equal(parseGithubRepo("/srv/git/origin.git"), undefined, "本地路径拒绝");
+    assert.equal(parseGithubRepo(""), undefined);
+});
+test("maskSecrets：PAT 前缀族 + URL 内嵌凭据（AC-12）", () => {
+    assert.ok(!maskSecrets("token ghp_abcdefghijklmnop0123 leaked").includes("ghp_"));
+    assert.ok(maskSecrets("ghp_abcdefghijklmnop0123").includes("[redacted]"));
+    assert.ok(!maskSecrets("github_pat_11ABCDEFGH_abcdefghij0123").includes("github_pat_11"));
+    const masked = maskSecrets("https://x-access-token:ghs_secretvalue123456@github.com/o/r");
+    assert.ok(!masked.includes("ghs_secretvalue123456"), `URL 凭据应脱敏：${masked}`);
+});
+test("githubTaskPrompt：issue 标题+正文快照+任务分支（AC-4 输入面）", () => {
+    const p = githubTaskPrompt(TASK);
+    assert.ok(p.includes("#901"));
+    assert.ok(p.includes("修复登录闪烁"));
+    assert.ok(p.includes("复现步骤 BODY"));
+    assert.ok(p.includes(TASK.branch));
+});
+test("happy path：fetch→checkout -B→invoke→add/status/commit/push→done+pushedBranch（AC-5/8）", async () => {
+    const calls = [];
+    const seen = [];
+    const git = fakeGit([OK_REMOTE, ["status --porcelain", { stdout: "M fix.txt\n" }]], calls);
+    const report = await executeGithubTask(TASK, { repoDir: "/repo", git, invoke: fakeInvoke({}, seen) });
+    assert.equal(report.outcome, "done");
+    assert.equal(report.pushedBranch, TASK.branch, "push 目标 = 入队定型任务分支（PR-only AC-8）");
+    assert.equal(report.exitCode, 0);
+    const keys = calls.map((a) => a.join(" "));
+    const idx = (prefix) => keys.findIndex((k) => k.startsWith(prefix));
+    assert.ok(idx("fetch origin main") >= 0, "先 fetch 默认分支");
+    assert.ok(keys.includes(`checkout -B ${TASK.branch} origin/main`), "基于 origin/main 建任务分支");
+    assert.ok(idx("add -A") > idx("checkout"), "invoke 后 add");
+    assert.ok(idx("commit -m") > idx("add -A"));
+    assert.ok(keys.includes(`push -u origin ${TASK.branch}`), "push 任务分支");
+    assert.ok(!keys.some((k) => k.startsWith("push") && k.includes("main")), "绝不直推默认分支（AC-8）");
+    assert.equal(seen.length, 1);
+    assert.ok(seen[0].prompt.includes("复现步骤 BODY"), "prompt 携带 issue 快照");
+    assert.equal(seen[0].cwd, "/repo");
+});
+test("remote 不一致 → failed repo_mismatch，invoke/fetch 零调用（AC-4 零执行）", async () => {
+    const calls = [];
+    const seen = [];
+    const git = fakeGit([["config --get remote.origin.url", { stdout: "https://github.com/evil/other-repo.git\n" }]], calls);
+    const report = await executeGithubTask(TASK, { repoDir: "/repo", git, invoke: fakeInvoke({}, seen) });
+    assert.equal(report.outcome, "failed");
+    assert.match(report.errorText ?? "", /^repo_mismatch/);
+    assert.ok((report.errorText ?? "").includes("tunsuy/agentory"), "原因指明绑定仓库");
+    assert.equal(seen.length, 0, "零执行");
+    const keys = calls.map((a) => a.join(" "));
+    assert.ok(!keys.some((k) => k.startsWith("fetch")), "不一致时不 fetch");
+    assert.ok(!keys.some((k) => k.startsWith("checkout")), "不一致时不动工作区");
+    assert.ok(!report.errorText?.includes("evil/other-repo"), "不回显 remote URL（可能含凭据）");
+});
+test("非 git 目录 / 无 origin → failed 诚实回流", async () => {
+    const calls = [];
+    const git = fakeGit([["rev-parse --show-toplevel", { code: 128, stderr: "not a git repository" }]], calls);
+    const report = await executeGithubTask(TASK, {
+        repoDir: "/nope",
+        git,
+        invoke: fakeInvoke({}, []),
+    });
+    assert.equal(report.outcome, "failed");
+    assert.match(report.errorText ?? "", /^not_a_git_repo/);
+});
+test("invoke failed/timeout 原样回流：不 commit 不 push（AC-6）", async () => {
+    for (const outcome of ["failed", "timeout"]) {
+        const calls = [];
+        const git = fakeGit([OK_REMOTE], calls);
+        const report = await executeGithubTask(TASK, {
+            repoDir: "/repo",
+            git,
+            invoke: fakeInvoke({ outcome, output: "partial", truncated: false, exitCode: outcome === "failed" ? 7 : null, durationMs: 12, errorText: "boom" }, []),
+        });
+        assert.equal(report.outcome, outcome);
+        assert.equal(report.exitCode, outcome === "failed" ? 7 : null);
+        assert.match(report.errorText ?? "", /^execution: boom/);
+        const keys = calls.map((a) => a.join(" "));
+        assert.ok(!keys.some((k) => k.startsWith("push")), `${outcome} 不 push`);
+        assert.ok(!keys.some((k) => k.startsWith("commit")), `${outcome} 不 commit`);
+    }
+});
+test("无改动 → failed no_changes（诚实,不开空 PR）", async () => {
+    const calls = [];
+    const git = fakeGit([OK_REMOTE, ["status --porcelain", { stdout: "" }]], calls);
+    const report = await executeGithubTask(TASK, { repoDir: "/repo", git, invoke: fakeInvoke({}, []) });
+    assert.equal(report.outcome, "failed");
+    assert.match(report.errorText ?? "", /^no_changes/);
+    const keys = calls.map((a) => a.join(" "));
+    assert.ok(!keys.some((k) => k.startsWith("push")));
+});
+test("fetch/push 失败 → 脱敏 errorText 回流（AC-12）", async () => {
+    const fetchCalls = [];
+    const fetchFail = await executeGithubTask(TASK, {
+        repoDir: "/repo",
+        git: fakeGit([OK_REMOTE, ["fetch origin", { code: 1, stderr: "fatal: unable to access 'https://x-access-token:ghs_secretvalue123456@github.com/…'" }]], fetchCalls),
+        invoke: fakeInvoke({}, []),
+    });
+    assert.equal(fetchFail.outcome, "failed");
+    assert.match(fetchFail.errorText ?? "", /^fetch_failed/);
+    assert.ok(!(fetchFail.errorText ?? "").includes("ghs_secretvalue123456"), "凭据脱敏");
+    assert.ok((fetchFail.errorText ?? "").length <= 200, "截短同控制面口径");
+    const pushCalls = [];
+    const pushFail = await executeGithubTask(TASK, {
+        repoDir: "/repo",
+        git: fakeGit([OK_REMOTE, ["status --porcelain", { stdout: "M a\n" }], ["push -u origin", { code: 1, stderr: "remote: Invalid PAT ghp_abcdefghijklmnop0123" }]], pushCalls),
+        invoke: fakeInvoke({}, []),
+    });
+    assert.equal(pushFail.outcome, "failed");
+    assert.match(pushFail.errorText ?? "", /^push_failed/);
+    assert.ok(!(pushFail.errorText ?? "").includes("ghp_"), "PAT 脱敏");
+});

package/dist/mock-runtime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mock-runtime.test.js

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+import { runHeadless } from "@agentoryhq/adapter-claude-code";
+/**
+ * Mock 执行 runtime（scripts/mock-claude.mjs）确定性回放断言。
+ * 走 runHeadless 真 spawn 路径 = smoke 全链的同一机制（超时/截断/退出码全真）。
+ */
+const MOCK_BIN = fileURLToPath(new URL("../../../scripts/mock-claude.mjs", import.meta.url));
+function run(prompt, overrides = {}) {
+    return runHeadless({
+        command: process.execPath,
+        args: [MOCK_BIN, "-p", prompt, "--session-id", "11111111-2222-3333-4444-555555555555"],
+        cwd: process.cwd(),
+        timeoutMs: 10_000,
+        maxOutputBytes: 64 * 1024,
+        ...overrides,
+    });
+}
+test("mock: 默认回放 mock ok: <prompt>", async () => {
+    const res = await run("总结最近一周构建失败原因");
+    assert.equal(res.outcome, "done");
+    assert.equal(res.exitCode, 0);
+    assert.match(res.output, /mock ok: 总结最近一周构建失败原因/);
+});
+test("mock: mock:text 指令覆盖输出", async () => {
+    const res = await run("mock:text=P95-分析完成");
+    assert.equal(res.outcome, "done");
+    assert.match(res.output, /P95-分析完成/);
+});
+test("mock: outcome=failed + exit=7 → failed 退出码 7", async () => {
+    const res = await run("mock:outcome=failed mock:exit=7");
+    assert.equal(res.outcome, "failed");
+    assert.equal(res.exitCode, 7);
+    assert.match(res.errorText ?? "", /退出码 7/);
+});
+test("mock: bytes=5000 撑爆 maxOutputBytes=50 → 真截断", async () => {
+    const res = await run("mock:bytes=5000", { maxOutputBytes: 50 });
+    assert.equal(res.outcome, "done");
+    assert.equal(res.truncated, true);
+    assert.equal(Buffer.byteLength(res.output, "utf8"), 50);
+});
+test("mock: delay=300 → durationMs ≥ 250（可注入延迟）", async () => {
+    const res = await run("mock:delay=300");
+    assert.equal(res.outcome, "done");
+    assert.ok(res.durationMs >= 250, `durationMs=${res.durationMs}`);
+});
+test("mock: hang=1 → runner 真超时 kill + 部分输出回流（AC-7 全真路径）", async () => {
+    const started = Date.now();
+    const res = await run("mock:hang=1", { timeoutMs: 600 });
+    assert.equal(res.outcome, "timeout");
+    assert.match(res.output, /mock partial before hang/);
+    assert.match(res.errorText ?? "", /执行超时/);
+    assert.ok(Date.now() - started < 8_000, "超时即收口");
+});
+test("mock: 确定性——同输入两次结果一致（CI 可跑判据）", async () => {
+    const a = await run("mock:text=det");
+    const b = await run("mock:text=det");
+    assert.equal(a.output, b.output);
+    assert.equal(a.outcome, b.outcome);
+    assert.equal(a.exitCode, b.exitCode);
+});

package/dist/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/registry.test.js

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { ADAPTER_API_VERSION, hasCapability } from "@agentoryhq/runtime-contract";
+import { adapterForRuntime, builtinAdapters } from "./registry.js";
+/**
+ * capability ↔ 方法一致性（契约注释「Optional methods must match declared
+ * capabilities」的机械闸）。声明了 capability 就必须有对应方法；实现了可选
+ * 方法就必须声明对应 capability。
+ */
+const CAPABILITY_METHODS = {
+    detect: ["detect"],
+    discoverConfig: ["discoverConfig"],
+    applyAlign: ["applyAlign"],
+    indexSessions: ["indexSessions"],
+    readTranscript: ["transcriptFileForSourceKey", "captureTranscriptSnapshot"],
+    /** 控制面侧导出（handoff snapshot），无 adapter 方法。 */
+    handoffExport: [],
+    invoke: ["invoke"],
+};
+const METHOD_CAPABILITY = {
+    discoverConfig: "discoverConfig",
+    applyAlign: "applyAlign",
+    indexSessions: "indexSessions",
+    transcriptFileForSourceKey: "readTranscript",
+    captureTranscriptSnapshot: "readTranscript",
+    invoke: "invoke",
+};
+test("builtin adapters: manifest capabilities match implemented methods", () => {
+    assert.ok(builtinAdapters.length >= 2);
+    for (const adapter of builtinAdapters) {
+        const { runtime, adapterApi, capabilities } = adapter.manifest;
+        assert.equal(adapterApi, ADAPTER_API_VERSION, `${runtime}: adapter_api 保持 1（additive 契约）`);
+        assert.ok(capabilities.includes("detect"), `${runtime}: detect 必声明`);
+        for (const cap of capabilities) {
+            for (const method of CAPABILITY_METHODS[cap]) {
+                assert.equal(typeof adapter[method], "function", `${runtime}: 声明 capability "${cap}" 但缺方法 ${method}`);
+            }
+        }
+        for (const [method, cap] of Object.entries(METHOD_CAPABILITY)) {
+            if (typeof adapter[method] === "function") {
+                assert.ok(hasCapability(adapter.manifest, cap), `${runtime}: 实现了 ${method} 但未声明 capability "${cap}"`);
+            }
+        }
+    }
+});
+test("invoke capability 诚实边界（AC-4 契约面）：claude-code 声明并实现；cursor 不声明、不实现", () => {
+    const claude = adapterForRuntime("claude-code");
+    assert.ok(claude);
+    assert.ok(hasCapability(claude.manifest, "invoke"), "claude-code 有 headless 执行面，须声明 invoke");
+    assert.equal(typeof claude.invoke, "function");
+    const cursor = adapterForRuntime("cursor");
+    assert.ok(cursor);
+    assert.ok(!hasCapability(cursor.manifest, "invoke"), "cursor 无 headless 执行面，不得声明 invoke");
+    assert.equal(cursor.invoke, undefined);
+});
+test("adapterForRuntime resolves builtins; unknown runtime returns undefined", () => {
+    assert.equal(adapterForRuntime("claude-code")?.manifest.displayName, "Claude Code");
+    assert.equal(adapterForRuntime("cursor")?.manifest.displayName, "Cursor");
+    assert.equal(adapterForRuntime("nope-runtime"), undefined);
+});

package/dist/transcript.d.ts

@@ -1,6 +1,14 @@
+import type { TranscriptSnapshot } from "@agentoryhq/shared";
 /**
- * Host re-exports Cursor transcript capture (adapter owns paths / masking).
+ * Transcript routing (claude-session-index §3-4): resolve each pending
+ * sourceKey across builtin adapters — the adapter whose
+ * `transcriptFileForSourceKey` recognizes the key owns it, and its own
+ * `captureTranscriptSnapshot` captures it (cursor keys stay on the cursor
+ * adapter, claude-session: keys route to claude-code). Unknown prefixes
+ * resolve to undefined = miss, same semantics as before. Same iteration
+ * shape as discoverAssetIndex.
  */
+export declare function captureTranscriptForSourceKey(sourceKey: string, homeDir?: string): TranscriptSnapshot | undefined;
 export { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "@agentoryhq/adapter-cursor";
 export type TranscriptFetchOpts = {
     homeDir?: string;

package/dist/transcript.js

@@ -1,4 +1,24 @@
+import os from "node:os";
+import { builtinAdapters } from "./registry.js";
 /**
- * Host re-exports Cursor transcript capture (adapter owns paths / masking).
+ * Transcript routing (claude-session-index §3-4): resolve each pending
+ * sourceKey across builtin adapters — the adapter whose
+ * `transcriptFileForSourceKey` recognizes the key owns it, and its own
+ * `captureTranscriptSnapshot` captures it (cursor keys stay on the cursor
+ * adapter, claude-session: keys route to claude-code). Unknown prefixes
+ * resolve to undefined = miss, same semantics as before. Same iteration
+ * shape as discoverAssetIndex.
  */
+export function captureTranscriptForSourceKey(sourceKey, homeDir) {
+    const home = homeDir ?? os.homedir();
+    for (const adapter of builtinAdapters) {
+        if (!adapter.transcriptFileForSourceKey || !adapter.captureTranscriptSnapshot)
+            continue;
+        const file = adapter.transcriptFileForSourceKey(sourceKey, home);
+        if (file === undefined)
+            continue;
+        return adapter.captureTranscriptSnapshot(file);
+    }
+    return undefined;
+}
 export { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "@agentoryhq/adapter-cursor";

package/dist/transcript.test.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { test } from "node:test";
-import { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "./transcript.js";
+import { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptForSourceKey, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "./transcript.js";
 function makeHome() {
     return fs.mkdtempSync(path.join(os.tmpdir(), "agentory-tr-"));
 }
@@ -103,6 +103,41 @@ test("captureTranscriptSnapshot empty / missing files (AC-1 空态)", () => {
         fs.rmSync(home, { recursive: true, force: true });
     }
 });
+test("captureTranscriptForSourceKey routes cursor + claude keys to their adapters; unknown → undefined (AC-5)", () => {
+    const home = makeHome();
+    try {
+        // cursor session jsonl under ~/.cursor/projects/
+        const cursorFile = writeJsonl(home, "p/agent-transcripts/id1/id1.jsonl", [
+            { role: "user", message: "cursor question", ts: "2026-10-30T10:00:00.000Z" },
+            { role: "assistant", message: { content: [{ type: "text", text: "cursor answer" }] }, ts: "2026-10-30T10:00:05.000Z" },
+        ]);
+        // claude session jsonl under ~/.claude/projects/
+        const claudeFile = path.join(home, ".claude", "projects", "Users-demo-work-app", "11111111-2222-3333-4444-555555555555.jsonl");
+        fs.mkdirSync(path.dirname(claudeFile), { recursive: true });
+        fs.writeFileSync(claudeFile, [
+            JSON.stringify({ type: "user", origin: { kind: "human" }, message: { role: "user", content: "claude question" }, timestamp: "2026-10-30T10:00:00.000Z" }),
+            JSON.stringify({ type: "assistant", message: { role: "assistant", content: [{ type: "text", text: "claude answer" }] }, timestamp: "2026-10-30T10:00:05.000Z" }),
+        ].join("\n"));
+        // cursor key routes to the cursor adapter
+        const cursorSnap = captureTranscriptForSourceKey(`cursor-transcript:${cursorFile}`, home);
+        assert.ok(cursorSnap);
+        assert.equal(cursorSnap.sourceKey, `cursor-transcript:${cursorFile}`);
+        assert.equal(cursorSnap.messages.length, 2);
+        assert.equal(cursorSnap.messages[0].text, "cursor question");
+        // claude key routes to the claude-code adapter
+        const claudeSnap = captureTranscriptForSourceKey(`claude-session:${claudeFile}`, home);
+        assert.ok(claudeSnap);
+        assert.equal(claudeSnap.sourceKey, `claude-session:${claudeFile}`);
+        assert.equal(claudeSnap.messages.length, 2);
+        assert.equal(claudeSnap.messages[0].text, "claude question");
+        // unknown prefix / missing file → undefined (miss, 既有语义)
+        assert.equal(captureTranscriptForSourceKey("other-runtime:whatever", home), undefined);
+        assert.equal(captureTranscriptForSourceKey(`claude-session:${path.join(home, ".claude", "projects", "slug", "gone.jsonl")}`, home), undefined);
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
 test("transcriptFileForSourceKey enforces ~/.cursor/projects containment (invariants §4)", () => {
     const home = makeHome();
     try {

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@agentoryhq/node",
-  "version": "0.1.1",
-  "description": "Agentory Node CLI — register, discover, align, daemon",
+  "version": "0.1.3",
+  "description": "Agentory Node CLI \u2014 register, discover, align, daemon",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
     "agentory-node": "./dist/cli.js"
   },
-  "files": ["dist", "README.md"],
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "start": "node dist/cli.js"
@@ -20,8 +23,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tunsuy/agentory-node.git",
-    "directory": "apps/node"
+    "url": "git+https://github.com/tunsuy/agentory-node.git"
   },
   "publishConfig": {
     "access": "public"

package/dist/daemon.e2e.test.js

@@ -1,123 +0,0 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { once } from "node:events";
-import { test } from "node:test";
-/**
- * AC-1 / AC-3 integration: real API (dist server, MemoryStore) + daemon --once
- * through the real client path, fixture-driven asset index. Self-contained:
- * boots its own API on an ephemeral port with a temp state dir.
- */
-test("AC-1 + AC-3: daemon --once full round reports to server; second run skips unchanged index", async () => {
-    const { createApiServer } = await import("../../api/dist/server.js");
-    const { MemoryStore } = await import("../../api/dist/store.js");
-    const store = new MemoryStore();
-    const server = createApiServer(store);
-    server.listen(0, "127.0.0.1");
-    await once(server, "listening");
-    const port = server.address().port;
-    const base = `http://127.0.0.1:${port}`;
-    const bs = await fetch(`${base}/v1/bootstrap`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ email: "daemon-e2e@studio.dev" }),
-    });
-    const bsBody = (await bs.json());
-    const workspaceId = bsBody.workspace.id;
-    const reg = await fetch(`${base}/v1/nodes/register`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${bsBody.nodeRootToken}`, "content-type": "application/json" },
-        body: JSON.stringify({ name: "daemon-e2e", hostname: "e2e.local" }),
-    });
-    const regBody = (await reg.json());
-    const nodeId = regBody.node.id;
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agentory-daemon-e2e-"));
-    const fixture = path.join(dir, "asset-index.json");
-    fs.writeFileSync(fixture, JSON.stringify({
-        sessions: [
-            { sourceKey: "s1", displayName: "daemon-e2e-session", projectPath: "/p", updatedAt: "2026-09-24T10:00:00Z" },
-        ],
-        memories: [],
-    }));
-    const prev = {
-        state: process.env.AGENTORY_NODE_STATE,
-        fixtureEnv: process.env.AGENTORY_ASSET_INDEX_FIXTURE,
-        cursorRoot: process.env.AGENTORY_CURSOR_ROOT,
-        base: process.env.CONTROL_PLANE_BASE_URL,
-    };
-    process.env.AGENTORY_NODE_STATE = path.join(dir, "node.json");
-    // daemon 的去重 state 文件落在 state 同目录（daemon-state.json）
-    process.env.AGENTORY_ASSET_INDEX_FIXTURE = fixture;
-    process.env.AGENTORY_CURSOR_ROOT = dir;
-    process.env.CONTROL_PLANE_BASE_URL = base;
-    try {
-        const { runDaemon } = await import("./daemon.js");
-        fs.writeFileSync(path.join(dir, "node.json"), JSON.stringify({ workspaceId, nodeId, nodeToken: regBody.nodeToken, controlPlaneBaseUrl: base }));
-        const capture = () => {
-            const lines = [];
-            const orig = console.log;
-            console.log = (...args) => {
-                lines.push(args.map(String).join(" "));
-            };
-            return {
-                lines,
-                restore: () => {
-                    console.log = orig;
-                },
-            };
-        };
-        // Round 1: heartbeat + align + asset-index + discover all ok.
-        const c1 = capture();
-        let code1;
-        try {
-            code1 = await runDaemon({ once: true });
-        }
-        finally {
-            c1.restore();
-        }
-        assert.equal(code1, 0, "first --once should succeed");
-        assert.ok(c1.lines.some((l) => l.includes('"channel":"heartbeat"') && l.includes('"ok"')), "heartbeat ok");
-        assert.ok(c1.lines.some((l) => l.includes('"channel":"asset-index"') && l.includes('"ok"')), "asset-index posted");
-        // Server side: session index now contains the fixture session for this node.
-        const idx = await fetch(`${base}/v1/workspaces/${workspaceId}/session-index?q=daemon-e2e-session`, {
-            headers: { authorization: `Bearer ${bsBody.sessionToken}` },
-        });
-        const idxBody = (await idx.json());
-        assert.equal(idx.status, 200);
-        assert.ok(idxBody.sessions.some((s) => s.displayName === "daemon-e2e-session"), "fixture session visible in session-index");
-        // Round 2: index unchanged → skip; heartbeat still fires.
-        const c2 = capture();
-        let code2;
-        try {
-            code2 = await runDaemon({ once: true });
-        }
-        finally {
-            c2.restore();
-        }
-        assert.equal(code2, 0, "second --once should succeed (heartbeat goes, index skips)");
-        assert.ok(c2.lines.some((l) => l.includes("unchanged, skip")), "asset-index unchanged, skip");
-        assert.ok(c2.lines.some((l) => l.includes('"channel":"heartbeat"') && l.includes('"ok"')), "heartbeat still ok");
-    }
-    finally {
-        if (prev.state === undefined)
-            delete process.env.AGENTORY_NODE_STATE;
-        else
-            process.env.AGENTORY_NODE_STATE = prev.state;
-        if (prev.fixtureEnv === undefined)
-            delete process.env.AGENTORY_ASSET_INDEX_FIXTURE;
-        else
-            process.env.AGENTORY_ASSET_INDEX_FIXTURE = prev.fixtureEnv;
-        if (prev.cursorRoot === undefined)
-            delete process.env.AGENTORY_CURSOR_ROOT;
-        else
-            process.env.AGENTORY_CURSOR_ROOT = prev.cursorRoot;
-        if (prev.base === undefined)
-            delete process.env.CONTROL_PLANE_BASE_URL;
-        else
-            process.env.CONTROL_PLANE_BASE_URL = prev.base;
-        fs.rmSync(dir, { recursive: true, force: true });
-        server.close();
-        await once(server, "close");
-    }
-});