@agentoryhq/adapter-claude-code 0.1.1 → 0.1.3

package/dist/align.d.ts

@@ -3,6 +3,8 @@ import type { ApplyAlignOpts, ApplyAlignResult } from "@agentoryhq/runtime-contr
  * Write confirmed align patch to Claude Code project files.
  * - MCP → project root `.mcp.json`
  * - Skills name list → `.claude/agentory-skills.json` (tracking; does not install skill bodies)
+ * - patch.rules 显式忽略（rules-desired-config Q1 裁决：一期规则载体只有 cursor，
+ *   claude-code 诚实提示暂不支持；API 侧对 claude-code 恒下发空 rules patch，双保险）
  * Snapshots prior `.mcp.json` under `.claude/agentory-snapshots/`.
  */
 export declare function applyAlignPatch(opts: ApplyAlignOpts): ApplyAlignResult;

package/dist/align.js

@@ -4,6 +4,8 @@ import path from "node:path";
  * Write confirmed align patch to Claude Code project files.
  * - MCP → project root `.mcp.json`
  * - Skills name list → `.claude/agentory-skills.json` (tracking; does not install skill bodies)
+ * - patch.rules 显式忽略（rules-desired-config Q1 裁决：一期规则载体只有 cursor，
+ *   claude-code 诚实提示暂不支持；API 侧对 claude-code 恒下发空 rules patch，双保险）
  * Snapshots prior `.mcp.json` under `.claude/agentory-snapshots/`.
  */
 export function applyAlignPatch(opts) {

package/dist/asset-index.d.ts

@@ -0,0 +1,15 @@
+import type { AdapterContext, AssetIndexResult } from "@agentoryhq/runtime-contract";
+/**
+ * Read only enough of the session jsonl (16KB) to derive a short title —
+ * never the full body. Falls back to "" when no human row is in range.
+ */
+export declare function titleFromClaudeSessionJsonl(file: string): string;
+/** cwd field on rows is the authoritative projectPath (first row wins, 16KB-peek). */
+export declare function projectPathFromClaudeSessionJsonl(file: string): string | undefined;
+/**
+ * Claude Code asset index (metadata only).
+ * - Sessions: ~/.claude/projects/<slug>/<uuid>.jsonl (top-level .jsonl only;
+ *   <uuid>/ subdirs hold subagent/tool data and are excluded).
+ * - Memory: ~/.claude/projects/<slug>/memory/*.md (kind=memory, Q1 随行).
+ */
+export declare function indexClaudeSessions(ctx: AdapterContext): AssetIndexResult;

package/dist/asset-index.js

@@ -0,0 +1,221 @@
+import fs from "node:fs";
+import path from "node:path";
+const TITLE_MAX = 80;
+const PEEK_BYTES = 16 * 1024;
+function isHumanOrigin(row) {
+    const origin = row.origin;
+    return !!origin && typeof origin === "object" &&
+        origin.kind === "human";
+}
+/** Human gate: user row + non-tool_result content shape + origin.kind==="human". */
+function humanTextFromUserRow(row) {
+    if (row.type !== "user" || row.isSidechain === true)
+        return "";
+    if (!isHumanOrigin(row))
+        return "";
+    const msg = row.message;
+    if (!msg || typeof msg !== "object")
+        return "";
+    const content = msg.content;
+    // tool_result arrays are tool echoes wearing a "user" type — reject.
+    if (Array.isArray(content) &&
+        content.some((b) => b && typeof b === "object" && b.type === "tool_result")) {
+        return "";
+    }
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const b of content) {
+            if (typeof b === "string")
+                parts.push(b);
+            else if (b && typeof b === "object" && typeof b.text === "string") {
+                parts.push(b.text);
+            }
+        }
+        return parts.join(" ");
+    }
+    return "";
+}
+function cleanTitleText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+/**
+ * Read only enough of the session jsonl (16KB) to derive a short title —
+ * never the full body. Falls back to "" when no human row is in range.
+ */
+export function titleFromClaudeSessionJsonl(file) {
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(PEEK_BYTES);
+            const n = fs.readSync(fd, buf, 0, buf.length, 0);
+            const chunk = buf.slice(0, n).toString("utf8");
+            for (const line of chunk.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let o;
+                try {
+                    o = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!o || typeof o !== "object")
+                    continue;
+                const text = cleanTitleText(humanTextFromUserRow(o));
+                if (!text)
+                    continue;
+                return text.length > TITLE_MAX ? `${text.slice(0, TITLE_MAX)}…` : text;
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        /* ignore unreadable file */
+    }
+    return "";
+}
+/** cwd field on rows is the authoritative projectPath (first row wins, 16KB-peek). */
+export function projectPathFromClaudeSessionJsonl(file) {
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(PEEK_BYTES);
+            const n = fs.readSync(fd, buf, 0, buf.length, 0);
+            const chunk = buf.slice(0, n).toString("utf8");
+            for (const line of chunk.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let o;
+                try {
+                    o = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!o || typeof o !== "object")
+                    continue;
+                const cwd = o.cwd;
+                if (typeof cwd === "string" && cwd.trim())
+                    return cwd;
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        /* ignore unreadable file */
+    }
+    return undefined;
+}
+function mtimeIso(file) {
+    try {
+        return fs.statSync(file).mtime.toISOString();
+    }
+    catch {
+        return new Date(0).toISOString();
+    }
+}
+/**
+ * Claude Code asset index (metadata only).
+ * - Sessions: ~/.claude/projects/<slug>/<uuid>.jsonl (top-level .jsonl only;
+ *   <uuid>/ subdirs hold subagent/tool data and are excluded).
+ * - Memory: ~/.claude/projects/<slug>/memory/*.md (kind=memory, Q1 随行).
+ */
+export function indexClaudeSessions(ctx) {
+    const home = ctx.homeDir;
+    const projectsRoot = path.join(home, ".claude", "projects");
+    const sessions = [];
+    const memories = [];
+    let slugs = [];
+    try {
+        slugs = fs.readdirSync(projectsRoot);
+    }
+    catch {
+        return { sessions, memories };
+    }
+    for (const slug of slugs) {
+        const projectDir = path.join(projectsRoot, slug);
+        try {
+            if (!fs.statSync(projectDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        let names = [];
+        try {
+            names = fs.readdirSync(projectDir);
+        }
+        catch {
+            continue;
+        }
+        // Prefer cwd from the first indexed session in this slug as the memory projectPath
+        // (memory/*.md has no cwd of its own; never invent a fake <name>.jsonl path).
+        let slugProjectPath;
+        for (const name of names) {
+            // Top-level .jsonl files only — <uuid>/ subdirs and stray files skipped.
+            if (!name.endsWith(".jsonl"))
+                continue;
+            const file = path.join(projectDir, name);
+            try {
+                if (!fs.statSync(file).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const title = titleFromClaudeSessionJsonl(file);
+            if (!title)
+                continue; // no human row in peek range — not an indexable conversation
+            const projectPath = projectPathFromClaudeSessionJsonl(file);
+            if (!slugProjectPath && projectPath)
+                slugProjectPath = projectPath;
+            sessions.push({
+                sourceKey: `claude-session:${file}`,
+                displayName: title,
+                projectPath,
+                updatedAt: mtimeIso(file),
+                runtime: "claude-code",
+            });
+        }
+        // Memory dimension (Q1 随行): <slug>/memory/*.md, path label keeps the slug visible.
+        const memoryDir = path.join(projectDir, "memory");
+        if (fs.existsSync(memoryDir)) {
+            let memNames = [];
+            try {
+                memNames = fs.readdirSync(memoryDir);
+            }
+            catch {
+                continue;
+            }
+            for (const name of memNames) {
+                if (!name.endsWith(".md"))
+                    continue;
+                const file = path.join(memoryDir, name);
+                try {
+                    if (!fs.statSync(file).isFile())
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                memories.push({
+                    sourceKey: `claude-memory:${file}`,
+                    kind: "memory",
+                    pathLabel: `${slug}/memory/${name}`,
+                    projectPath: slugProjectPath,
+                    updatedAt: mtimeIso(file),
+                    runtime: "claude-code",
+                });
+            }
+        }
+    }
+    sessions.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0));
+    memories.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0));
+    return { sessions, memories };
+}

package/dist/asset-index.test.d.ts

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

package/dist/asset-index.test.js

@@ -0,0 +1,261 @@
+import assert from "node:assert/strict";
+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, indexClaudeSessions, maskSecrets, projectPathFromClaudeSessionJsonl, titleFromClaudeSessionJsonl, transcriptFileForSourceKey, } from "./index.js";
+function makeHome() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "agy-claude-idx-"));
+}
+/** Real-shape claude rows (verified schema; bodies are fixture-only). */
+function row(partial) {
+    return {
+        cwd: "/Users/demo/work/app",
+        isSidechain: false,
+        timestamp: "2026-10-30T10:00:00.000Z",
+        version: "2.1.0",
+        ...partial,
+    };
+}
+function humanRow(text) {
+    return row({
+        type: "user",
+        origin: { kind: "human" },
+        message: { role: "user", content: text },
+    });
+}
+function writeSession(home, slug, file, rows) {
+    const target = path.join(home, ".claude", "projects", slug, file);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, rows.map((r) => JSON.stringify(r)).join("\n"));
+    return target;
+}
+test("indexClaudeSessions discovers sessions + memory, excludes subdirs and non-dialog files (AC-3)", () => {
+    const home = makeHome();
+    try {
+        const jsonl = writeSession(home, "Users-demo-work-app", "11111111-2222-3333-4444-555555555555.jsonl", [
+            { type: "mode", mode: "default" },
+            { type: "permission-mode", permissionMode: "default" },
+            { type: "system", subtype: "init", content: "system noise" },
+            humanRow("Fix the flaky test in ci"),
+            row({
+                type: "user",
+                message: { role: "user", content: [{ type: "tool_result", content: "tool echo" }] },
+            }),
+            row({
+                type: "assistant",
+                message: { role: "assistant", content: [{ type: "text", text: "On it" }] },
+            }),
+        ]);
+        // <uuid>/ subdir (subagent data) — must NOT be indexed even if it holds .jsonl-like files
+        const sub = path.join(home, ".claude", "projects", "Users-demo-work-app", "11111111-2222-3333-4444-555555555555", "sub.jsonl");
+        fs.mkdirSync(path.dirname(sub), { recursive: true });
+        fs.writeFileSync(sub, "garbage");
+        // non-jsonl stray file
+        fs.writeFileSync(path.join(home, ".claude", "projects", "Users-demo-work-app", "notes.txt"), "x");
+        // memory dimension (Q1 随行)
+        const memDir = path.join(home, ".claude", "projects", "Users-demo-work-app", "memory");
+        fs.mkdirSync(memDir, { recursive: true });
+        fs.writeFileSync(path.join(memDir, "MEMORY.md"), "# index\n");
+        const out = indexClaudeSessions({ homeDir: home, cwd: home });
+        assert.equal(out.sessions.length, 1);
+        const s = out.sessions[0];
+        assert.equal(s.sourceKey, `claude-session:${jsonl}`);
+        assert.equal(s.runtime, "claude-code");
+        // title = first human row text, NOT the tool_result echo or system rows
+        assert.equal(s.displayName, "Fix the flaky test in ci");
+        // cwd field is the authoritative projectPath
+        assert.equal(s.projectPath, "/Users/demo/work/app");
+        assert.ok(s.updatedAt);
+        assert.equal(out.memories.length, 1);
+        const m = out.memories[0];
+        assert.equal(m.kind, "memory");
+        assert.equal(m.sourceKey, `claude-memory:${path.join(memDir, "MEMORY.md")}`);
+        assert.equal(m.runtime, "claude-code");
+        assert.match(m.pathLabel, /Users-demo-work-app\/memory\/MEMORY\.md/);
+        // memory projectPath inherits cwd from a sibling session in the same slug
+        assert.equal(m.projectPath, "/Users/demo/work/app");
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("indexClaudeSessions excludes sidechain rows from the title (AC-3)", () => {
+    const home = makeHome();
+    try {
+        const jsonl = writeSession(home, "Users-demo-work-app", "99999999-8888-7777-6666-555555555555.jsonl", [
+            // sidechain human row comes first in file order — must be skipped for title
+            row({
+                type: "user",
+                isSidechain: true,
+                origin: { kind: "human" },
+                message: { role: "user", content: "subagent internal prompt" },
+            }),
+            humanRow("Main thread request"),
+        ]);
+        const title = titleFromClaudeSessionJsonl(jsonl);
+        assert.equal(title, "Main thread request");
+        const out = indexClaudeSessions({ homeDir: home, cwd: home });
+        assert.equal(out.sessions.length, 1);
+        assert.equal(out.sessions[0].displayName, "Main thread request");
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("titleFromClaudeSessionJsonl truncates to 80 chars (AC-3)", () => {
+    const home = makeHome();
+    try {
+        const jsonl = writeSession(home, "Users-demo-work-app", "aaaa1111-bbbb-cccc-dddd-eeeeeeeeeeee.jsonl", [
+            humanRow("y".repeat(200)),
+        ]);
+        const title = titleFromClaudeSessionJsonl(jsonl);
+        assert.ok(title.length <= 80 + 1); // 80 chars + …
+        assert.ok(title.endsWith("…"));
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("indexClaudeSessions skips jsonl without any human row (not an indexable conversation)", () => {
+    const home = makeHome();
+    try {
+        writeSession(home, "Users-demo-work-app", "00000000-0000-0000-0000-000000000000.jsonl", [
+            { type: "mode", mode: "default" },
+            row({ type: "assistant", message: { role: "assistant", content: [{ type: "text", text: "orphan reply" }] } }),
+        ]);
+        const out = indexClaudeSessions({ homeDir: home, cwd: home });
+        assert.equal(out.sessions.length, 0);
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("projectPathFromClaudeSessionJsonl reads cwd from first row", () => {
+    const home = makeHome();
+    try {
+        const jsonl = writeSession(home, "Users-demo-work-app", "12345678-1234-1234-1234-123456789012.jsonl", [
+            row({ type: "system", cwd: "/Users/demo/work/app" }),
+            humanRow("hi"),
+        ]);
+        assert.equal(projectPathFromClaudeSessionJsonl(jsonl), "/Users/demo/work/app");
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("maskSecrets masks common token shapes (AC-4)", () => {
+    const cases = [
+        ["sk-abcdef0123456789abcdef", "sk-••••••••"],
+        ["ghp_0123456789abcdefghijklmnopqrstuvwxyz", "ghp_••••••••"],
+        ["xoxb-0123456789abcdefGHI", "xox•-••••••••"],
+    ];
+    for (const [raw, masked] of cases) {
+        assert.equal(maskSecrets(raw).includes(masked), true);
+        assert.equal(maskSecrets(raw).includes(raw), false);
+    }
+    const kv = maskSecrets("deploy with password=hunter2-secret now");
+    assert.equal(kv.includes("hunter2"), false);
+    assert.equal(maskSecrets("fix the login bug please"), "fix the login bug please");
+});
+test("captureTranscriptSnapshot: human gate, sidechain/tool_result exclusion, masking (AC-4)", () => {
+    const home = makeHome();
+    try {
+        const long = "x".repeat(TRANSCRIPT_MESSAGE_MAX_CHARS + 500);
+        const jsonl = writeSession(home, "Users-demo-work-app", "abcdefab-cdef-abcd-efab-cdefabcdefab.jsonl", [
+            { type: "mode", mode: "default" },
+            { type: "permission-mode", permissionMode: "acceptEdits" },
+            { type: "file-history-snapshot", snapshot: "x" },
+            { type: "attachment", attachment: { path: "x" } },
+            humanRow("Fix login with sk-abcdef0123456789abcdef"),
+            // tool_result row (type user) — NOT human input, excluded
+            row({
+                type: "user",
+                message: { role: "user", content: [{ type: "tool_result", content: "tool echo body" }] },
+            }),
+            // user row without human origin — excluded
+            row({
+                type: "user",
+                message: { role: "user", content: "no-origin text" },
+            }),
+            // sidechain assistant — excluded
+            row({
+                type: "assistant",
+                isSidechain: true,
+                message: { role: "assistant", content: [{ type: "text", text: "subagent text" }] },
+            }),
+            row({
+                type: "assistant",
+                message: {
+                    role: "assistant",
+                    content: [
+                        { type: "thinking", thinking: "internal" },
+                        { type: "text", text: long },
+                    ],
+                },
+            }),
+            "not-json",
+        ]);
+        const snap = captureTranscriptSnapshot(jsonl, new Date("2026-10-30T12:00:00.000Z"));
+        assert.ok(snap);
+        assert.equal(snap.sourceKey, `claude-session:${jsonl}`);
+        assert.equal(snap.messages.length, 2);
+        assert.equal(snap.messages[0].role, "user");
+        assert.equal(snap.messages[0].text.includes("sk-abcdef"), false);
+        assert.ok(snap.messages[0].text.includes("sk-••••••••"));
+        assert.equal(snap.messages[1].role, "assistant");
+        assert.ok(snap.messages[1].text.length <= TRANSCRIPT_MESSAGE_MAX_CHARS + 1);
+        assert.ok(snap.messages[1].text.endsWith("…"));
+        // tool echo / non-human / sidechain / non-dialog rows never appear
+        const joined = snap.messages.map((m) => m.text).join(" ");
+        assert.ok(!joined.includes("tool echo"));
+        assert.ok(!joined.includes("no-origin"));
+        assert.ok(!joined.includes("subagent"));
+        assert.equal(snap.truncated, false);
+        assert.equal(snap.capturedAt, "2026-10-30T12:00:00.000Z");
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("captureTranscriptSnapshot keeps near-end window + truncated flag (AC-4)", () => {
+    const home = makeHome();
+    try {
+        const rows = Array.from({ length: TRANSCRIPT_WINDOW_MESSAGES + 27 }, (_, i) => humanRow(`msg-${i}`));
+        const jsonl = writeSession(home, "p-slug", "ffffffff-eeee-dddd-cccc-bbbbbbbbbbbb.jsonl", rows);
+        const snap = captureTranscriptSnapshot(jsonl);
+        assert.ok(snap);
+        assert.equal(snap.messages.length, TRANSCRIPT_WINDOW_MESSAGES);
+        assert.equal(snap.truncated, true);
+        assert.ok(snap.windowTotal);
+        assert.match(snap.windowTotal, new RegExp(`${TRANSCRIPT_WINDOW_MESSAGES} / ${rows.length}`));
+        assert.equal(snap.messages[0].text, `msg-${rows.length - TRANSCRIPT_WINDOW_MESSAGES}`);
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("captureTranscriptSnapshot missing file → undefined (AC-4)", () => {
+    const home = makeHome();
+    try {
+        assert.equal(captureTranscriptSnapshot(path.join(home, "nope.jsonl")), undefined);
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});
+test("transcriptFileForSourceKey enforces ~/.claude/projects containment (invariants §4, AC-4)", () => {
+    const home = makeHome();
+    try {
+        const inside = path.join(home, ".claude", "projects", "slug", "session.jsonl");
+        assert.equal(transcriptFileForSourceKey(`claude-session:${inside}`, home), inside);
+        const outside = path.join(home, ".ssh", "id_ed25519");
+        assert.equal(transcriptFileForSourceKey(`claude-session:${outside}`, home), undefined);
+        // cursor-prefixed keys are not ours — must not resolve
+        assert.equal(transcriptFileForSourceKey(`cursor-transcript:${inside}`, home), undefined);
+        assert.equal(transcriptFileForSourceKey("claude-session:", home), undefined);
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});

package/dist/discover.js

@@ -83,5 +83,8 @@ export function discoverClaudeCodeConfig(ctx) {
         displayName: `Claude Code · ${path.basename(ctx.cwd) || "workspace"}`,
         mcp,
         skills: [...skillNames],
+        // 诚实边界（rules-desired-config Q1 裁决）：一期规则载体只有 cursor（.cursor/rules/*.mdc），
+        // claude-code 恒报空——CLAUDE.md 类载体联动属二期，另开 Brief。
+        rules: [],
     };
 }

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 import type { RuntimeAdapter } from "@agentoryhq/runtime-contract";
 export { applyAlignPatch } from "./align.js";
 export { detectClaudeCode, discoverClaudeCodeConfig, mcpFromClaudeConfig } from "./discover.js";
+export { invokeClaudeCode, runHeadless } from "./invoke.js";
+export { indexClaudeSessions, titleFromClaudeSessionJsonl, projectPathFromClaudeSessionJsonl, } from "./asset-index.js";
+export { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "./transcript.js";
 export declare const claudeCodeAdapter: RuntimeAdapter;

package/dist/index.js

@@ -1,16 +1,26 @@
 import { ADAPTER_API_VERSION } from "@agentoryhq/runtime-contract";
 import { applyAlignPatch } from "./align.js";
 import { detectClaudeCode, discoverClaudeCodeConfig } from "./discover.js";
+import { invokeClaudeCode } from "./invoke.js";
+import { indexClaudeSessions } from "./asset-index.js";
+import { captureTranscriptSnapshot, transcriptFileForSourceKey } from "./transcript.js";
 export { applyAlignPatch } from "./align.js";
 export { detectClaudeCode, discoverClaudeCodeConfig, mcpFromClaudeConfig } from "./discover.js";
+export { invokeClaudeCode, runHeadless } from "./invoke.js";
+export { indexClaudeSessions, titleFromClaudeSessionJsonl, projectPathFromClaudeSessionJsonl, } from "./asset-index.js";
+export { TRANSCRIPT_MESSAGE_MAX_CHARS, TRANSCRIPT_WINDOW_MESSAGES, captureTranscriptSnapshot, maskSecrets, transcriptFileForSourceKey, } from "./transcript.js";
 export const claudeCodeAdapter = {
     manifest: {
         runtime: "claude-code",
         adapterApi: ADAPTER_API_VERSION,
         displayName: "Claude Code",
-        capabilities: ["detect", "discoverConfig", "applyAlign"],
+        capabilities: ["detect", "discoverConfig", "applyAlign", "indexSessions", "readTranscript", "invoke"],
     },
     detect: detectClaudeCode,
     discoverConfig: discoverClaudeCodeConfig,
     applyAlign: applyAlignPatch,
+    indexSessions: indexClaudeSessions,
+    transcriptFileForSourceKey,
+    captureTranscriptSnapshot,
+    invoke: invokeClaudeCode,
 };

package/dist/invoke.d.ts

@@ -0,0 +1,32 @@
+import type { AdapterContext, InvokeRequest, InvokeResult } from "@agentoryhq/runtime-contract";
+/**
+ * Headless 执行 runner（agent-messaging 切片 2）。
+ *
+ * 红线（ADR-005）：
+ * - 只以 runtime 默认权限模型执行——本文件不得出现任何权限放宽 flag
+ *   （`--dangerously-skip-permissions` / `--permission-mode` 类，AC-12 grep 钉死）。
+ * - 纯本地 spawn，零入站端口、零反连。
+ * - 超时 kill 整个进程组（detached + kill(-pid)），不留僵尸。
+ * - 输出按 maxOutputBytes 截断（字节口径），truncated 标记。
+ */
+export type HeadlessRunOpts = {
+    command: string;
+    args: string[];
+    cwd: string;
+    timeoutMs: number;
+    maxOutputBytes: number;
+    env?: NodeJS.ProcessEnv;
+    /** 若进程成功 spawn，则以此值回填 InvokeResult.runtimeSessionId。 */
+    sessionId?: string;
+};
+export declare function runHeadless(opts: HeadlessRunOpts): Promise<InvokeResult>;
+/**
+ * Claude Code headless 单发执行（一期：单发单执行，不带上文）。
+ *
+ * `--session-id <uuid>`：自生成会话标识传给 runtime，从而确定性回填
+ * runtimeSessionId（二期 thread resume 走 `--resume <id>`，契约已预留
+ * resumeSessionId——一期调用方不得设置，此处忽略）。
+ *
+ * 二进制解析：`CLAUDE_CODE_BIN` env 覆盖（测试/非标准安装），默认 PATH 中 `claude`。
+ */
+export declare function invokeClaudeCode(ctx: AdapterContext, req: InvokeRequest): Promise<InvokeResult>;

package/dist/invoke.js

@@ -0,0 +1,142 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+export function runHeadless(opts) {
+    return new Promise((resolve) => {
+        const started = Date.now();
+        const chunks = [];
+        let outputBytes = 0;
+        let truncated = false;
+        let timedOut = false;
+        let spawned = false;
+        let spawnError;
+        let child;
+        try {
+            child = spawn(opts.command, opts.args, {
+                cwd: opts.cwd,
+                env: opts.env ?? process.env,
+                detached: true,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (err) {
+            resolve({
+                outcome: "failed",
+                output: "",
+                truncated: false,
+                exitCode: null,
+                durationMs: Date.now() - started,
+                errorText: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        const append = (buf) => {
+            const remaining = opts.maxOutputBytes - outputBytes;
+            if (remaining <= 0) {
+                if (buf.length > 0)
+                    truncated = true;
+                return;
+            }
+            if (buf.length > remaining) {
+                chunks.push(buf.subarray(0, remaining));
+                outputBytes = opts.maxOutputBytes;
+                truncated = true;
+            }
+            else {
+                chunks.push(buf);
+                outputBytes += buf.length;
+            }
+        };
+        const finish = (exitCode, signal) => {
+            clearTimeout(timer);
+            const durationMs = Date.now() - started;
+            const output = Buffer.concat(chunks).toString("utf8");
+            const base = { output, truncated, durationMs };
+            if (spawnError) {
+                resolve({
+                    ...base,
+                    outcome: "failed",
+                    exitCode: null,
+                    errorText: spawnError.message,
+                });
+                return;
+            }
+            if (spawned && opts.sessionId) {
+                base.runtimeSessionId = opts.sessionId;
+            }
+            if (timedOut) {
+                resolve({
+                    ...base,
+                    outcome: "timeout",
+                    exitCode,
+                    errorText: `执行超时（超过 ${opts.timeoutMs}ms 上限）`,
+                });
+                return;
+            }
+            if (exitCode === 0) {
+                resolve({ ...base, outcome: "done", exitCode: 0 });
+                return;
+            }
+            resolve({
+                ...base,
+                outcome: "failed",
+                exitCode,
+                errorText: exitCode === null
+                    ? `runtime 被信号终止（${signal ?? "unknown"}）`
+                    : `runtime 退出码 ${exitCode}`,
+            });
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            // 进程组终止：detached spawn 的负 pid = 整组（含 runtime 再派生的子进程）。
+            try {
+                if (child.pid !== undefined)
+                    process.kill(-child.pid, "SIGKILL");
+                else
+                    child.kill("SIGKILL");
+            }
+            catch {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    /* already gone */
+                }
+            }
+        }, opts.timeoutMs);
+        child.on("spawn", () => {
+            spawned = true;
+        });
+        child.on("error", (err) => {
+            // spawn 失败（如 ENOENT）：'close' 可能不再触发，这里直接收口。
+            // 重复 resolve 无副作用（Promise 只认第一次）。
+            spawnError = err;
+            finish(null, null);
+        });
+        child.stdout?.on("data", (buf) => append(buf));
+        child.stderr?.on("data", (buf) => append(buf));
+        child.on("close", (code, signal) => finish(code, signal));
+    });
+}
+/**
+ * Claude Code headless 单发执行（一期：单发单执行，不带上文）。
+ *
+ * `--session-id <uuid>`：自生成会话标识传给 runtime，从而确定性回填
+ * runtimeSessionId（二期 thread resume 走 `--resume <id>`，契约已预留
+ * resumeSessionId——一期调用方不得设置，此处忽略）。
+ *
+ * 二进制解析：`CLAUDE_CODE_BIN` env 覆盖（测试/非标准安装），默认 PATH 中 `claude`。
+ */
+export async function invokeClaudeCode(ctx, req) {
+    const sessionId = randomUUID();
+    const bin = process.env.CLAUDE_CODE_BIN?.trim() || "claude";
+    const args = ["-p", req.prompt, "--session-id", sessionId];
+    // req.resumeSessionId：二期预留，一期忽略（见 playbook 禁止清单「多轮接续二期」）。
+    return runHeadless({
+        command: bin,
+        args,
+        cwd: req.cwd || ctx.cwd,
+        timeoutMs: req.timeoutMs,
+        maxOutputBytes: req.maxOutputBytes,
+        sessionId,
+    });
+}

package/dist/invoke.test.d.ts

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

package/dist/invoke.test.js

@@ -0,0 +1,145 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { invokeClaudeCode, runHeadless } from "./invoke.js";
+const baseOpts = { timeoutMs: 10_000, maxOutputBytes: 64 * 1024 };
+test("runHeadless: done captures stdout+stderr and exit code 0", async () => {
+    const res = await runHeadless({
+        command: "/bin/sh",
+        args: ["-c", "echo out-line; echo err-line >&2"],
+        cwd: os.tmpdir(),
+        ...baseOpts,
+    });
+    assert.equal(res.outcome, "done");
+    assert.equal(res.exitCode, 0);
+    assert.match(res.output, /out-line/);
+    assert.match(res.output, /err-line/);
+    assert.equal(res.truncated, false);
+    assert.ok(res.durationMs >= 0);
+});
+test("runHeadless: non-zero exit → failed with 退出码 errorText", async () => {
+    const res = await runHeadless({
+        command: "/bin/sh",
+        args: ["-c", "echo partial; exit 3"],
+        cwd: os.tmpdir(),
+        ...baseOpts,
+    });
+    assert.equal(res.outcome, "failed");
+    assert.equal(res.exitCode, 3);
+    assert.match(res.output, /partial/);
+    assert.match(res.errorText ?? "", /退出码 3/);
+});
+test("runHeadless: timeout kills the process group and keeps partial output (AC-7)", async () => {
+    const started = Date.now();
+    const res = await runHeadless({
+        // 子进程再派生孙进程——进程组 kill 必须一起收走。
+        // 时长用唯一标记 61.7（机器上有无关 watchdog 循环 sleep 60，全局断言会误伤）。
+        command: "/bin/sh",
+        args: ["-c", "echo before-hang; sleep 61.7 & sleep 61.7"],
+        cwd: os.tmpdir(),
+        timeoutMs: 400,
+        maxOutputBytes: 64 * 1024,
+    });
+    assert.equal(res.outcome, "timeout");
+    assert.match(res.output, /before-hang/);
+    assert.match(res.errorText ?? "", /执行超时/);
+    assert.ok(Date.now() - started < 10_000, "超时后应立即收口，不等 sleep");
+    // 进程组确实被收走（负 pid kill 不残留）。模式 61[.]7 防 pgrep 包装 sh 自匹配。
+    await new Promise((r) => setTimeout(r, 200));
+    const pgrep = await runHeadless({
+        command: "/bin/sh",
+        args: ["-c", "pgrep -f 'sleep 61[.]7' | head -1 || true"],
+        cwd: os.tmpdir(),
+        ...baseOpts,
+    });
+    assert.equal(pgrep.output.trim(), "", "timeout 后不应残留本测试的 sleep 进程");
+});
+test("runHeadless: output beyond maxOutputBytes is truncated with flag", async () => {
+    const res = await runHeadless({
+        command: "/bin/sh",
+        args: ["-c", "printf 'x%.0s' $(seq 1 5000)"],
+        cwd: os.tmpdir(),
+        timeoutMs: 10_000,
+        maxOutputBytes: 100,
+    });
+    assert.equal(res.outcome, "done");
+    assert.equal(res.truncated, true);
+    assert.equal(Buffer.byteLength(res.output, "utf8"), 100);
+});
+test("runHeadless: spawn failure (ENOENT) → failed, exitCode null", async () => {
+    const res = await runHeadless({
+        command: "/definitely/not/a/binary",
+        args: [],
+        cwd: os.tmpdir(),
+        ...baseOpts,
+    });
+    assert.equal(res.outcome, "failed");
+    assert.equal(res.exitCode, null);
+    assert.ok(res.errorText);
+    assert.equal(res.runtimeSessionId, undefined, "未 spawn 成功不得回填会话标识");
+});
+test("invokeClaudeCode: headless args + runtimeSessionId 回填 + 零权限放宽 flag (AC-12)", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-claude-i-"));
+    const argsFile = path.join(root, "args.txt");
+    const fakeBin = path.join(root, "fake-claude.sh");
+    fs.writeFileSync(fakeBin, [
+        "#!/bin/sh",
+        `printf '%s\\n' "$@" > ${JSON.stringify(argsFile)}`,
+        "echo fake-result-text",
+        "exit 0",
+    ].join("\n"), { mode: 0o755 });
+    const prev = process.env.CLAUDE_CODE_BIN;
+    process.env.CLAUDE_CODE_BIN = fakeBin;
+    try {
+        const res = await invokeClaudeCode({ homeDir: root, cwd: root }, { prompt: "总结最近一周构建失败原因", timeoutMs: 10_000, maxOutputBytes: 4096, cwd: root });
+        assert.equal(res.outcome, "done");
+        assert.match(res.output, /fake-result-text/);
+        assert.ok(res.runtimeSessionId, "spawn 成功应回填 runtimeSessionId");
+        assert.match(res.runtimeSessionId ?? "", /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/, "runtimeSessionId 应为 UUID（二期 --resume 可用）");
+        const sentArgs = fs.readFileSync(argsFile, "utf8").split("\n").filter(Boolean);
+        assert.deepEqual(sentArgs, [
+            "-p",
+            "总结最近一周构建失败原因",
+            "--session-id",
+            res.runtimeSessionId ?? "",
+        ]);
+        // AC-12 红线：参数面零权限放宽 flag
+        for (const arg of sentArgs) {
+            assert.ok(!/dangerously|skip-permissions|permission-mode|yolo|bypass/i.test(arg), `不得注入权限放宽 flag: ${arg}`);
+        }
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.CLAUDE_CODE_BIN;
+        else
+            process.env.CLAUDE_CODE_BIN = prev;
+    }
+});
+test("invokeClaudeCode: resumeSessionId 一期忽略（不产生 --resume 类参数）", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-claude-r-"));
+    const argsFile = path.join(root, "args.txt");
+    const fakeBin = path.join(root, "fake-claude.sh");
+    fs.writeFileSync(fakeBin, ["#!/bin/sh", `printf '%s\\n' "$@" > ${JSON.stringify(argsFile)}`, "exit 0"].join("\n"), { mode: 0o755 });
+    const prev = process.env.CLAUDE_CODE_BIN;
+    process.env.CLAUDE_CODE_BIN = fakeBin;
+    try {
+        await invokeClaudeCode({ homeDir: root, cwd: root }, {
+            prompt: "hi",
+            timeoutMs: 10_000,
+            maxOutputBytes: 4096,
+            cwd: root,
+            resumeSessionId: "should-be-ignored",
+        });
+        const sentArgs = fs.readFileSync(argsFile, "utf8");
+        assert.ok(!sentArgs.includes("should-be-ignored"));
+        assert.ok(!sentArgs.includes("--resume"));
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.CLAUDE_CODE_BIN;
+        else
+            process.env.CLAUDE_CODE_BIN = prev;
+    }
+});

package/dist/transcript.d.ts

@@ -0,0 +1,31 @@
+import type { TranscriptSnapshot } from "@agentoryhq/shared";
+/**
+ * Node-side Claude Code transcript capture (claude-session-index, AC-4).
+ * Same discipline as the cursor adapter: read jsonl locally → filter dialog
+ * rows (human gate for user rows, assistant text blocks) → mask secret-shaped
+ * strings → keep the near-end window. Only the masked, windowed snapshot ever
+ * leaves the machine; raw body is never logged.
+ */
+/** 近端窗口上限（与 cursor transcript.ts 同值钉死） */
+export declare const TRANSCRIPT_WINDOW_MESSAGES = 40;
+/** 单条消息字符上限（同上） */
+export declare const TRANSCRIPT_MESSAGE_MAX_CHARS = 2000;
+/** Mask secret-shaped substrings BEFORE anything leaves the node (AC-4). */
+export declare function maskSecrets(text: string): string;
+/**
+ * Read the Claude session jsonl at `file` and build a masked, windowed
+ * snapshot. Returns undefined when the file is missing/unreadable; an empty
+ * snapshot for a session with no extractable dialog rows.
+ */
+export declare function captureTranscriptSnapshot(file: string, now?: Date): TranscriptSnapshot | undefined;
+export type TranscriptFetchOpts = {
+    homeDir?: string;
+};
+/**
+ * Resolve a session jsonl path for a claude sourceKey
+ * (`claude-session:<abs path>` as emitted by asset-index.ts).
+ * Only files under `~/.claude/projects/` qualify — no arbitrary path
+ * scanning (invariants §4; brief §4 不做: no AGENTORY_CLAUDE_ROOT override,
+ * default scan face stays narrow).
+ */
+export declare function transcriptFileForSourceKey(sourceKey: string, homeDir?: string): string | undefined;

package/dist/transcript.js

@@ -0,0 +1,173 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Node-side Claude Code transcript capture (claude-session-index, AC-4).
+ * Same discipline as the cursor adapter: read jsonl locally → filter dialog
+ * rows (human gate for user rows, assistant text blocks) → mask secret-shaped
+ * strings → keep the near-end window. Only the masked, windowed snapshot ever
+ * leaves the machine; raw body is never logged.
+ */
+/** 近端窗口上限（与 cursor transcript.ts 同值钉死） */
+export const TRANSCRIPT_WINDOW_MESSAGES = 40;
+/** 单条消息字符上限（同上） */
+export const TRANSCRIPT_MESSAGE_MAX_CHARS = 2000;
+const SECRET_PATTERNS = [
+    { re: /\bsk-[A-Za-z0-9_\-]{16,}/g, mask: "sk-••••••••" },
+    { re: /\bghp_[A-Za-z0-9]{20,}/g, mask: "ghp_••••••••" },
+    { re: /\bgho_[A-Za-z0-9]{20,}/g, mask: "gho_••••••••" },
+    { re: /\bgithub_pat_[A-Za-z0-9_]{20,}/g, mask: "github_pat_••••••••" },
+    { re: /\bxox[baprs]-[A-Za-z0-9\-]{16,}/g, mask: "xox•-••••••••" },
+    { re: /\bAKIA[0-9A-Z]{16}\b/g, mask: "AKIA••••••••" },
+    { re: /(?:password|passwd|pwd|secret|token|api[_-]?key)\s*[:=]\s*\S+/gi, mask: "password=••••••••" },
+    // 长随机密钥形态（hex/base64 ≥ 32 字符，独立成词）
+    { re: /\b[A-Za-z0-9+/]{40,}={0,2}\b/g, mask: "••••••••" },
+    { re: /\b[0-9a-f]{32,}\b/gi, mask: "••••••••" },
+];
+/** Mask secret-shaped substrings BEFORE anything leaves the node (AC-4). */
+export function maskSecrets(text) {
+    let out = text;
+    for (const { re, mask } of SECRET_PATTERNS) {
+        out = out.replace(re, mask);
+    }
+    return out;
+}
+function isHumanOrigin(row) {
+    const origin = row.origin;
+    return !!origin && typeof origin === "object" &&
+        origin.kind === "human";
+}
+/** Human gate (brief §3 陷阱): user + non-tool_result content + origin.kind==="human". */
+function humanTextFromUserRow(row) {
+    if (row.type !== "user" || row.isSidechain === true)
+        return "";
+    if (!isHumanOrigin(row))
+        return "";
+    const msg = row.message;
+    if (!msg || typeof msg !== "object")
+        return "";
+    const content = msg.content;
+    if (Array.isArray(content) &&
+        content.some((b) => b && typeof b === "object" && b.type === "tool_result")) {
+        return "";
+    }
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const b of content) {
+            if (b && typeof b === "object" && typeof b.text === "string") {
+                parts.push(b.text);
+            }
+        }
+        return parts.join(" ");
+    }
+    return "";
+}
+/** Assistant rows: aggregate message.content text blocks (skip thinking/tool_use). */
+function assistantTextFromRow(row) {
+    if (row.type !== "assistant" || row.isSidechain === true)
+        return "";
+    const msg = row.message;
+    if (!msg || typeof msg !== "object")
+        return "";
+    const content = msg.content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const b of content) {
+        if (b && typeof b === "object" && b.type === "text" &&
+            typeof b.text === "string") {
+            parts.push(b.text);
+        }
+    }
+    return parts.join(" ");
+}
+/**
+ * Read the Claude session jsonl at `file` and build a masked, windowed
+ * snapshot. Returns undefined when the file is missing/unreadable; an empty
+ * snapshot for a session with no extractable dialog rows.
+ */
+export function captureTranscriptSnapshot(file, now = new Date()) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const sourceKey = `claude-session:${file}`;
+    const all = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!o || typeof o !== "object")
+            continue;
+        const row = o;
+        // Unknown row types (mode/system/snapshot/attachment/…) fall through both
+        // extractors as "" — silently skipped, never crash (brief §7 schema-drift guard).
+        let role;
+        let text = "";
+        const human = humanTextFromUserRow(row);
+        if (human) {
+            role = "user";
+            text = human;
+        }
+        else {
+            const assistant = assistantTextFromRow(row);
+            if (assistant) {
+                role = "assistant";
+                text = assistant;
+            }
+        }
+        if (!role || !text.trim())
+            continue;
+        if (text.length > TRANSCRIPT_MESSAGE_MAX_CHARS) {
+            text = `${text.slice(0, TRANSCRIPT_MESSAGE_MAX_CHARS)}…`;
+        }
+        const ts = typeof row.timestamp === "string" ? row.timestamp : "";
+        all.push({ role, ts, text });
+    }
+    const windowMessages = all.length > TRANSCRIPT_WINDOW_MESSAGES
+        ? all.slice(-TRANSCRIPT_WINDOW_MESSAGES)
+        : all;
+    const truncated = all.length > windowMessages.length;
+    return {
+        sourceKey,
+        messages: windowMessages.map((m) => ({ ...m, text: maskSecrets(m.text) })),
+        truncated,
+        windowTotal: truncated ? `${windowMessages.length} / ${all.length} 条` : undefined,
+        capturedAt: now.toISOString(),
+    };
+}
+/**
+ * Resolve a session jsonl path for a claude sourceKey
+ * (`claude-session:<abs path>` as emitted by asset-index.ts).
+ * Only files under `~/.claude/projects/` qualify — no arbitrary path
+ * scanning (invariants §4; brief §4 不做: no AGENTORY_CLAUDE_ROOT override,
+ * default scan face stays narrow).
+ */
+export function transcriptFileForSourceKey(sourceKey, homeDir) {
+    const prefix = "claude-session:";
+    if (!sourceKey.startsWith(prefix))
+        return undefined;
+    const file = sourceKey.slice(prefix.length);
+    const home = homeDir ?? os.homedir();
+    const root = path.join(home, ".claude", "projects");
+    try {
+        const rel = path.relative(root, file);
+        if (rel.startsWith("..") || path.isAbsolute(rel))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return file;
+}

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@agentoryhq/adapter-claude-code",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Agentory RuntimeAdapter for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -20,8 +22,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tunsuy/agentory-node.git",
-    "directory": "adapters/claude-code"
+    "url": "git+https://github.com/tunsuy/agentory-node.git"
   },
   "publishConfig": {
     "access": "public"