@agentoryhq/node 0.1.1

package/README.md

@@ -0,0 +1,5 @@
+# @agentoryhq/node
+
+CLI `agentory-node` for Agentory: register with a control plane, discover local Agents, apply confirmed align patches, run the daemon.
+
+Open-source Host lives in [agentory-node](https://github.com/tunsuy/agentory-node). Control plane is separate/product.

package/dist/align.d.ts

@@ -0,0 +1,28 @@
+import type { AlignPatch } from "@agentoryhq/shared";
+export type ApplyAlignOpts = {
+    /** Project root for the runtime (Cursor: `.cursor/`; Claude: `.mcp.json` root). */
+    cursorRoot: string;
+    patch: AlignPatch;
+    confirmed: boolean;
+    runtime?: string;
+};
+export type ApplyAlignResult = {
+    ok: boolean;
+    error?: string;
+    mcpPath: string;
+    skillsPath: string;
+    snapshotPath?: string;
+};
+/** Host facade — routes to the matching RuntimeAdapter.applyAlign. */
+export declare function applyAlignPatch(opts: ApplyAlignOpts): ApplyAlignResult;
+/** @deprecated Prefer applyAlignPatch({ runtime }) — kept for explicit cursor tests. */
+export declare function applyCursorAlignPatch(opts: {
+    cursorRoot: string;
+    patch: AlignPatch;
+    confirmed: boolean;
+}): ApplyAlignResult;
+export declare function applyClaudeAlignPatch(opts: {
+    projectRoot: string;
+    patch: AlignPatch;
+    confirmed: boolean;
+}): ApplyAlignResult;

package/dist/align.js

@@ -0,0 +1,32 @@
+import { applyAlignPatch as cursorApplyAlign } from "@agentoryhq/adapter-cursor";
+import { applyAlignPatch as claudeApplyAlign } from "@agentoryhq/adapter-claude-code";
+import { adapterForRuntime } from "./registry.js";
+/** Host facade — routes to the matching RuntimeAdapter.applyAlign. */
+export function applyAlignPatch(opts) {
+    const runtime = opts.runtime ?? "cursor";
+    const adapter = adapterForRuntime(runtime);
+    if (!adapter?.applyAlign) {
+        return {
+            ok: false,
+            error: `no applyAlign adapter for runtime ${runtime}`,
+            mcpPath: "",
+            skillsPath: "",
+        };
+    }
+    return adapter.applyAlign({
+        projectRoot: opts.cursorRoot,
+        patch: opts.patch,
+        confirmed: opts.confirmed,
+    });
+}
+/** @deprecated Prefer applyAlignPatch({ runtime }) — kept for explicit cursor tests. */
+export function applyCursorAlignPatch(opts) {
+    return cursorApplyAlign({
+        projectRoot: opts.cursorRoot,
+        patch: opts.patch,
+        confirmed: opts.confirmed,
+    });
+}
+export function applyClaudeAlignPatch(opts) {
+    return claudeApplyAlign(opts);
+}

package/dist/align.test.d.ts

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

package/dist/align.test.js

@@ -0,0 +1,63 @@
+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 { applyAlignPatch } from "./align.js";
+test("applyAlignPatch refuses unconfirmed write", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-aln-"));
+    fs.mkdirSync(path.join(root, ".cursor"), { recursive: true });
+    const mcpPath = path.join(root, ".cursor", "mcp.json");
+    fs.writeFileSync(mcpPath, JSON.stringify({ mcpServers: { a: { command: "old" } } }));
+    const r = applyAlignPatch({
+        cursorRoot: root,
+        patch: { mcp: [{ name: "a", command: "npx new" }], skills: [] },
+        confirmed: false,
+    });
+    assert.equal(r.ok, false);
+    assert.match(fs.readFileSync(mcpPath, "utf8"), /old/);
+});
+test("applyAlignPatch writes mcp+skills with snapshot", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-aln-"));
+    fs.mkdirSync(path.join(root, ".cursor"), { recursive: true });
+    const mcpPath = path.join(root, ".cursor", "mcp.json");
+    fs.writeFileSync(mcpPath, JSON.stringify({ mcpServers: { github: { command: "npx", args: ["live"] } } }));
+    const r = applyAlignPatch({
+        cursorRoot: root,
+        patch: {
+            mcp: [
+                { name: "github", command: "npx desired" },
+                { name: "extra", command: "npx extra" },
+            ],
+            skills: ["brief"],
+        },
+        confirmed: true,
+    });
+    assert.equal(r.ok, true);
+    assert.ok(r.snapshotPath && fs.existsSync(r.snapshotPath));
+    const after = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+    assert.equal(after.mcpServers.github.command, "npx");
+    assert.deepEqual(after.mcpServers.github.args, ["desired"]);
+    assert.ok(after.mcpServers.extra);
+    const skills = JSON.parse(fs.readFileSync(path.join(root, ".cursor", "agentory-skills.json"), "utf8"));
+    assert.deepEqual(skills.skills, ["brief"]);
+});
+test("applyAlignPatch routes claude-code to .mcp.json not .cursor/", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agy-aln-claude-"));
+    fs.mkdirSync(path.join(root, ".cursor"), { recursive: true });
+    fs.writeFileSync(path.join(root, ".cursor", "mcp.json"), JSON.stringify({ mcpServers: { keep: { command: "cursor-only" } } }));
+    fs.writeFileSync(path.join(root, ".mcp.json"), JSON.stringify({ mcpServers: { a: { command: "old" } } }));
+    const r = applyAlignPatch({
+        cursorRoot: root,
+        runtime: "claude-code",
+        patch: { mcp: [{ name: "a", command: "npx claude" }], skills: ["s"] },
+        confirmed: true,
+    });
+    assert.equal(r.ok, true);
+    const claudeMcp = JSON.parse(fs.readFileSync(path.join(root, ".mcp.json"), "utf8"));
+    assert.equal(claudeMcp.mcpServers.a.command, "npx");
+    assert.deepEqual(claudeMcp.mcpServers.a.args, ["claude"]);
+    const cursorMcp = JSON.parse(fs.readFileSync(path.join(root, ".cursor", "mcp.json"), "utf8"));
+    assert.equal(cursorMcp.mcpServers.keep?.command, "cursor-only");
+    assert.ok(fs.existsSync(path.join(root, ".claude", "agentory-skills.json")));
+});

package/dist/asset-index.d.ts

@@ -0,0 +1,15 @@
+import type { MemoryIndexReportItem, SessionIndexReportItem } from "@agentoryhq/shared";
+export type AssetIndexDiscoverOpts = {
+    homeDir?: string;
+    cwd?: string;
+    /** JSON fixture: { sessions?, memories? } or AGENTORY_ASSET_INDEX_FIXTURE */
+    fixturePath?: string;
+};
+/**
+ * Aggregate asset index: Host fixtures/drop-in + each adapter with `indexSessions`.
+ */
+export declare function discoverAssetIndex(opts?: AssetIndexDiscoverOpts): {
+    sessions: SessionIndexReportItem[];
+    memories: MemoryIndexReportItem[];
+};
+export { buildCursorProjectPathMap, titleFromTranscriptJsonl, } from "@agentoryhq/adapter-cursor";

package/dist/asset-index.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { builtinAdapters } from "./registry.js";
+function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Aggregate asset index: Host fixtures/drop-in + each adapter with `indexSessions`.
+ */
+export function discoverAssetIndex(opts = {}) {
+    const fixture = opts.fixturePath ?? process.env.AGENTORY_ASSET_INDEX_FIXTURE;
+    if (fixture) {
+        const raw = readJsonFile(fixture);
+        if (raw && typeof raw === "object") {
+            const o = raw;
+            return {
+                sessions: Array.isArray(o.sessions) ? o.sessions : [],
+                memories: Array.isArray(o.memories) ? o.memories : [],
+            };
+        }
+    }
+    const cwd = opts.cwd ?? process.cwd();
+    const homeDir = opts.homeDir ?? os.homedir();
+    const sessions = [];
+    const memories = [];
+    const seen = new Set();
+    const pushSession = (s) => {
+        if (seen.has(s.sourceKey))
+            return;
+        seen.add(s.sourceKey);
+        sessions.push(s);
+    };
+    const dropIn = path.join(cwd, ".agentory", "session-index.json");
+    const drop = readJsonFile(dropIn);
+    if (drop && typeof drop === "object") {
+        const o = drop;
+        if (Array.isArray(o.sessions)) {
+            for (const s of o.sessions)
+                pushSession(s);
+        }
+    }
+    const ctx = { homeDir, cwd };
+    for (const adapter of builtinAdapters) {
+        if (!adapter.indexSessions)
+            continue;
+        const part = adapter.indexSessions(ctx);
+        for (const s of part.sessions)
+            pushSession(s);
+        memories.push(...part.memories);
+    }
+    sessions.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0));
+    return { sessions, memories };
+}
+export { buildCursorProjectPathMap, titleFromTranscriptJsonl, } from "@agentoryhq/adapter-cursor";

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

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

package/dist/asset-index.test.js

@@ -0,0 +1,87 @@
+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 { discoverAssetIndex } from "./asset-index.js";
+test("discoverAssetIndex reads rules and session meta without bodies", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agentory-idx-"));
+    try {
+        const rules = path.join(root, ".cursor", "rules");
+        fs.mkdirSync(rules, { recursive: true });
+        fs.writeFileSync(path.join(rules, "harness.mdc"), "SECRET=should-not-appear-in-index\n");
+        const sessions = path.join(root, ".cursor", "sessions");
+        fs.mkdirSync(sessions, { recursive: true });
+        fs.writeFileSync(path.join(sessions, "a.meta.json"), JSON.stringify({
+            displayName: "Demo session",
+            projectPath: root,
+            updatedAt: "2026-09-16T10:00:00.000Z",
+        }));
+        const out = discoverAssetIndex({ cwd: root, homeDir: root });
+        assert.equal(out.sessions.length, 1);
+        assert.equal(out.sessions[0].displayName, "Demo session");
+        assert.ok(!JSON.stringify(out).includes("SECRET"));
+        assert.equal(out.memories.length, 1);
+        assert.equal(out.memories[0].kind, "rules");
+        assert.match(out.memories[0].pathLabel, /harness\.mdc/);
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+});
+test("discoverAssetIndex fixture path", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "agentory-fix-"));
+    try {
+        const file = path.join(root, "fixture.json");
+        fs.writeFileSync(file, JSON.stringify({
+            sessions: [
+                {
+                    sourceKey: "fx1",
+                    displayName: "From fixture",
+                    updatedAt: "2026-09-01T00:00:00.000Z",
+                },
+            ],
+            memories: [],
+        }));
+        const out = discoverAssetIndex({ fixturePath: file, cwd: root });
+        assert.equal(out.sessions.length, 1);
+        assert.equal(out.sessions[0].displayName, "From fixture");
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+});
+test("discoverAssetIndex reads native agent-transcripts metadata only", () => {
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), "agentory-home-"));
+    try {
+        const id = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+        const projSlug = "Users-demo-work-app";
+        const projectPath = "/Users/demo/work/app";
+        const jsonl = path.join(home, ".cursor", "projects", projSlug, "agent-transcripts", id, `${id}.jsonl`);
+        fs.mkdirSync(path.dirname(jsonl), { recursive: true });
+        const secret = "SUPER_SECRET_BODY_SHOULD_NOT_LEAK";
+        fs.writeFileSync(jsonl, [
+            JSON.stringify({
+                role: "user",
+                message: { content: [{ type: "text", text: "Fix the login bug please" }] },
+            }),
+            JSON.stringify({
+                role: "assistant",
+                message: { content: [{ type: "text", text: `I will help ${secret}` }] },
+            }),
+        ].join("\n"));
+        const ws = path.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage", "ws1");
+        fs.mkdirSync(ws, { recursive: true });
+        fs.writeFileSync(path.join(ws, "workspace.json"), JSON.stringify({ folder: `file://${projectPath}` }));
+        const out = discoverAssetIndex({ cwd: home, homeDir: home });
+        assert.equal(out.sessions.length, 1);
+        assert.equal(out.sessions[0].projectPath, projectPath);
+        assert.match(out.sessions[0].displayName, /Fix the login bug/);
+        assert.ok(!out.sessions[0].displayName.includes(secret));
+        assert.ok(!JSON.stringify(out).includes(secret));
+        assert.match(out.sessions[0].sourceKey, /cursor-transcript:/);
+    }
+    finally {
+        fs.rmSync(home, { recursive: true, force: true });
+    }
+});

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(argv: string[]): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { PKG_VERSION, controlPlaneBaseUrl, jsonHealth } from "@agentoryhq/shared";
+import { applyPendingAligns, fulfillPendingTranscripts, heartbeat, registerNode, reportAssetIndex, reportDiscovery } from "./client.js";
+import { discoverAssetIndex } from "./asset-index.js";
+import { discoverAgents } from "./discover.js";
+import { runDaemon } from "./daemon.js";
+function flag(argv, name) {
+    const i = argv.indexOf(name);
+    if (i < 0)
+        return undefined;
+    return argv[i + 1];
+}
+export async function runCli(argv) {
+    const cmd = argv[2] ?? "version";
+    if (cmd === "version" || cmd === "-v" || cmd === "--version") {
+        const body = jsonHealth("node");
+        console.log(`${body.service} ${PKG_VERSION}`);
+        return 0;
+    }
+    if (cmd === "ping") {
+        const base = controlPlaneBaseUrl();
+        try {
+            const res = await fetch(`${base}/health`);
+            const text = await res.text();
+            console.log(res.status, text);
+            return res.ok ? 0 : 1;
+        }
+        catch (err) {
+            console.error(`unreachable ${base}:`, err instanceof Error ? err.message : err);
+            return 2;
+        }
+    }
+    if (cmd === "register") {
+        const token = flag(argv, "--token") ?? process.env.AGENTORY_NODE_ROOT_TOKEN;
+        if (!token) {
+            console.error("usage: agentory-node register --token <node_root_token>");
+            return 2;
+        }
+        const name = flag(argv, "--name") ?? "local";
+        return registerNode(token, name);
+    }
+    if (cmd === "heartbeat")
+        return heartbeat();
+    if (cmd === "discover") {
+        if (argv.includes("--dry-run")) {
+            console.log(JSON.stringify({ agents: discoverAgents() }, null, 2));
+            return 0;
+        }
+        return reportDiscovery();
+    }
+    if (cmd === "asset-index") {
+        if (argv.includes("--dry-run")) {
+            console.log(JSON.stringify(discoverAssetIndex(), null, 2));
+            return 0;
+        }
+        return reportAssetIndex();
+    }
+    if (cmd === "align") {
+        return applyPendingAligns();
+    }
+    if (cmd === "transcript") {
+        return fulfillPendingTranscripts();
+    }
+    if (cmd === "daemon") {
+        return runDaemon({ once: argv.includes("--once") });
+    }
+    console.error("usage: agentory-node <version|ping|register|heartbeat|discover|asset-index|align|transcript|daemon [--once]>");
+    return 2;
+}
+const thisFile = fileURLToPath(import.meta.url);
+function isCliEntry(argv1) {
+    if (!argv1)
+        return false;
+    try {
+        const resolved = fileURLToPath(pathToFileURL(path.resolve(argv1)));
+        if (resolved === thisFile)
+            return true;
+    }
+    catch {
+        /* ignore */
+    }
+    const base = path.basename(argv1);
+    return base === "agentory-node" || base === "agentory-node.js";
+}
+if (isCliEntry(process.argv[1])) {
+    runCli(process.argv).then((code) => process.exit(code));
+}

package/dist/cli.test.d.ts

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

package/dist/cli.test.js

@@ -0,0 +1,7 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { runCli } from "./cli.js";
+test("version exits 0", async () => {
+    const code = await runCli(["node", "cli.js", "version"]);
+    assert.equal(code, 0);
+});

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+export type NodeState = {
+    workspaceId?: string;
+    nodeId: string;
+    nodeToken: string;
+    controlPlaneBaseUrl: string;
+};
+export declare function loadState(): NodeState | undefined;
+export declare function saveState(state: NodeState): void;
+export declare function registerNode(rootToken: string, name: string): Promise<number>;
+export declare function heartbeat(): Promise<number>;
+export declare function reportDiscovery(): Promise<number>;
+export declare function reportAssetIndex(): Promise<number>;
+/**
+ * Model B pull: fetch pending transcript requests, capture each session
+ * locally (mask + window, never logs the body — AC-9), POST snapshots back.
+ * Called from the daemon index channel and `agentory-node transcript` CLI.
+ */
+export declare function fulfillPendingTranscripts(): Promise<number>;
+/** Pull confirmed plans and write Cursor files (AC-3). */
+export declare function applyPendingAligns(): Promise<number>;

package/dist/client.js

@@ -0,0 +1,198 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+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";
+function statePath() {
+    return process.env.AGENTORY_NODE_STATE ?? path.join(os.homedir(), ".agentory", "node.json");
+}
+export function loadState() {
+    try {
+        return JSON.parse(fs.readFileSync(statePath(), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveState(state) {
+    const file = statePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+function cursorRoot() {
+    return process.env.AGENTORY_CURSOR_ROOT?.trim() || process.cwd();
+}
+async function api(method, urlPath, opts) {
+    const res = await fetch(`${controlPlaneBaseUrl()}${urlPath}`, {
+        method,
+        headers: {
+            authorization: `Bearer ${opts.token}`,
+            "content-type": "application/json",
+        },
+        body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+    });
+    const body = (await res.json());
+    return { status: res.status, body };
+}
+export async function registerNode(rootToken, name) {
+    const hostname = os.hostname();
+    const { status, body } = await api("POST", "/v1/nodes/register", {
+        token: rootToken,
+        body: { name, hostname },
+    });
+    if (status !== 200) {
+        console.error(status, body);
+        return 1;
+    }
+    const node = body.node;
+    const nodeToken = body.nodeToken;
+    saveState({
+        workspaceId: node.workspaceId,
+        nodeId: node.id,
+        nodeToken,
+        controlPlaneBaseUrl: controlPlaneBaseUrl(),
+    });
+    console.log(JSON.stringify({ nodeId: node.id, workspaceId: node.workspaceId }, null, 2));
+    return 0;
+}
+export async function heartbeat() {
+    const st = loadState();
+    if (!st) {
+        console.error("not registered; run: agentory-node register --token <root>");
+        return 2;
+    }
+    const { status, body } = await api("POST", `/v1/nodes/${st.nodeId}/heartbeat`, {
+        token: st.nodeToken,
+    });
+    console.log(status, JSON.stringify(body));
+    return status === 200 ? 0 : 1;
+}
+export async function reportDiscovery() {
+    const st = loadState();
+    if (!st) {
+        console.error("not registered; run: agentory-node register --token <root>");
+        return 2;
+    }
+    const agents = await discoverAgentsWithHealth();
+    const { status, body } = await api("POST", `/v1/nodes/${st.nodeId}/discovery`, {
+        token: st.nodeToken,
+        body: { agents },
+    });
+    console.log(status, JSON.stringify(body, null, 2));
+    return status === 200 ? 0 : 1;
+}
+export async function reportAssetIndex() {
+    const st = loadState();
+    if (!st) {
+        console.error("not registered; run: agentory-node register --token <root>");
+        return 2;
+    }
+    const index = discoverAssetIndex();
+    const { status, body } = await api("POST", `/v1/nodes/${st.nodeId}/asset-index`, {
+        token: st.nodeToken,
+        body: index,
+    });
+    console.log(status, JSON.stringify(body, null, 2));
+    return status === 200 ? 0 : 1;
+}
+/**
+ * Model B pull: fetch pending transcript requests, capture each session
+ * locally (mask + window, never logs the body — AC-9), POST snapshots back.
+ * Called from the daemon index channel and `agentory-node transcript` CLI.
+ */
+export async function fulfillPendingTranscripts() {
+    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}/transcript/pending`, {
+        token: st.nodeToken,
+    });
+    if (status !== 200) {
+        console.error(status, JSON.stringify(body));
+        return 1;
+    }
+    const pending = body.requests ?? [];
+    if (!pending.length) {
+        console.log(JSON.stringify({ fulfilled: 0, requests: [] }, null, 2));
+        return 0;
+    }
+    const snapshots = [];
+    const misses = [];
+    for (const req of pending) {
+        const file = transcriptFileForSourceKey(req.sourceKey);
+        const snap = file ? captureTranscriptSnapshot(file) : undefined;
+        if (snap)
+            snapshots.push(snap);
+        else
+            misses.push(req.sourceKey);
+    }
+    const { status: reportStatus, body: reportBody } = await api("POST", `/v1/nodes/${st.nodeId}/transcript/report`, {
+        token: st.nodeToken,
+        body: { snapshots, missing: misses },
+    });
+    if (reportStatus !== 200) {
+        console.error(reportStatus, JSON.stringify(reportBody));
+        return 1;
+    }
+    // 审计侧只回 count——快照正文不落节点日志（AC-9）。
+    console.log(JSON.stringify({
+        fulfilled: snapshots.length,
+        missing: misses.length,
+        reported: reportBody.snapshots,
+    }, null, 2));
+    return 0;
+}
+/** Pull confirmed plans and write Cursor files (AC-3). */
+export async function applyPendingAligns() {
+    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}/align/pending`, {
+        token: st.nodeToken,
+    });
+    if (status !== 200) {
+        console.error(status, body);
+        return 1;
+    }
+    const plans = body.plans ?? [];
+    if (!plans.length) {
+        console.log(JSON.stringify({ applied: 0, plans: [] }, null, 2));
+        return 0;
+    }
+    const root = cursorRoot();
+    const results = [];
+    let failed = 0;
+    for (const plan of plans) {
+        const local = applyAlignPatch({
+            cursorRoot: root,
+            patch: plan.patch,
+            confirmed: plan.status === "confirmed",
+            runtime: plan.runtime,
+        });
+        const report = await api("POST", `/v1/nodes/${st.nodeId}/align/${plan.id}/result`, {
+            token: st.nodeToken,
+            body: {
+                ok: local.ok,
+                error: local.error,
+                snapshotPath: local.snapshotPath,
+            },
+        });
+        if (!local.ok || report.status !== 200)
+            failed += 1;
+        results.push({
+            planId: plan.id,
+            local,
+            reportStatus: report.status,
+            plan: report.body.plan,
+        });
+    }
+    console.log(JSON.stringify({ applied: plans.length - failed, failed, results }, null, 2));
+    return failed ? 1 : 0;
+}

package/dist/daemon.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Resident daemon: periodic heartbeat (+ align pull), asset-index report
+ * (sha-deduped), discovery report. Pure outbound — the control plane never
+ * reaches back into the node (invariants §4/§5).
+ */
+export type DaemonIntervals = {
+    heartbeatSec: number;
+    indexSec: number;
+    discoverSec: number;
+};
+export type DaemonOpts = {
+    intervals?: Partial<DaemonIntervals>;
+    /** Run every channel once, then exit 0 (cron / testing entry). */
+    once?: boolean;
+    /** 测试注入：可控时钟与睡眠。 */
+    clock?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+    signalHandlers?: NodeJS.Signals[];
+    /** 提早注入信号（测试）。 */
+    registerSignal?: (onSignal: (sig: NodeJS.Signals) => void) => void;
+};
+/** Env override with hard clamp to MIN_INTERVAL_SEC (AC-6). */
+export declare function parseIntervalSec(envName: string, fallback: number): number;
+export declare function resolveIntervals(): DaemonIntervals;
+/** 0–10% of the period of jitter, so a fleet of nodes doesn't fire in unison. */
+export declare function jitterMs(periodSec: number, rand?: () => number): number;
+export declare function assetIndexSha(index: unknown): string;
+/** Report the index only when its content hash changed since last report (AC-3). */
+export declare function reportAssetIndexIfChanged(): Promise<number>;
+/** One full round: all channels (--once 与首轮同语义，AC-1）。失败通道 → 非 0。 */
+export declare function runFullRound(): Promise<number>;
+export declare function runDaemon(opts?: DaemonOpts): Promise<number>;

package/dist/daemon.e2e.test.d.ts

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