@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/test/openclaw-channel-routing.test.js

@@ -1,191 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert = __importStar(require("assert"));
-const openclaw_channel_routing_js_1 = require("../gateway/openclaw-channel-routing.js");
-suite('resolvePublishedGatewayChannelIds', () => {
-    const rows = [
-        { id: 'slack', label: 'Slack', connected: true, enabled: true, accounts: ['default'] },
-        // Configured but momentarily offline (e.g. Telegram polling stalled) — still bindable.
-        { id: 'telegram', label: 'Telegram', connected: false, enabled: true, accounts: ['default'] },
-        { id: 'whatsapp', label: 'WhatsApp', connected: false, enabled: false, accounts: ['default'] },
-    ];
-    test('default publish binds all enabled channels, including ones offline at publish time', () => {
-        const selected = (0, openclaw_channel_routing_js_1.resolvePublishedGatewayChannelIds)(rows, undefined);
-        assert.deepStrictEqual(selected, ['slack', 'telegram']);
-    });
-    test('peer publish binds only the preferred channel', () => {
-        const selected = (0, openclaw_channel_routing_js_1.resolvePublishedGatewayChannelIds)(rows, 'telegram');
-        assert.deepStrictEqual(selected, ['telegram']);
-    });
-});
-suite('mapChannelsStatusToMeetAgentRows', () => {
-    test('derives enabled/connected from running/configured (no `connected` field)', () => {
-        const rows = (0, openclaw_channel_routing_js_1.mapChannelsStatusToMeetAgentRows)({
-            channelOrder: ['telegram', 'slack'],
-            channelLabels: { telegram: 'Telegram', slack: 'Slack' },
-            channels: {
-                telegram: { configured: true, running: false },
-                slack: { configured: true, running: true },
-            },
-            channelAccounts: {
-                telegram: [{ accountId: 'default', enabled: true, configured: true, running: false }],
-                slack: [{ accountId: 'default', enabled: true, configured: true, running: true }],
-            },
-        });
-        const telegram = rows.find((r) => r.id === 'telegram');
-        const slack = rows.find((r) => r.id === 'slack');
-        // Telegram is configured but its poller is down: bindable, not live.
-        assert.strictEqual(telegram?.enabled, true);
-        assert.strictEqual(telegram?.connected, false);
-        assert.strictEqual(slack?.enabled, true);
-        assert.strictEqual(slack?.connected, true);
-    });
-    test('honors legacy `connected` field when present', () => {
-        const rows = (0, openclaw_channel_routing_js_1.mapChannelsStatusToMeetAgentRows)({
-            channelOrder: ['slack'],
-            channels: { slack: { connected: true } },
-        });
-        assert.strictEqual(rows[0]?.connected, true);
-        assert.strictEqual(rows[0]?.enabled, true);
-    });
-});
-suite('waitForChannelsLive', () => {
-    /** Build a `channels.status` payload from an id → connected map. */
-    function statusPayload(connected) {
-        const channels = {};
-        const channelAccounts = {};
-        for (const [id, isConn] of Object.entries(connected)) {
-            channels[id] = { configured: true, running: isConn };
-            channelAccounts[id] = [{ accountId: 'default', enabled: true, configured: true, running: isConn }];
-        }
-        return { channelOrder: Object.keys(connected), channels, channelAccounts };
-    }
-    /** Request stub that returns one scripted payload per call (last entry repeats); `'throw'` rejects. */
-    function seqRequest(seq) {
-        let i = 0;
-        const request = async (_method, _params) => {
-            const item = seq[Math.min(i, seq.length - 1)];
-            i++;
-            if (item === 'throw') {
-                throw new Error('channels.status failed');
-            }
-            return item;
-        };
-        return { request, calls: () => i };
-    }
-    /** Deterministic clock: each `sleep` advances `now` by the requested amount. */
-    function fakeClock() {
-        let t = 0;
-        return {
-            now: () => t,
-            sleep: async (ms) => {
-                t += ms;
-            },
-        };
-    }
-    test('returns ready immediately with no polls when no channels requested', async () => {
-        const { request, calls } = seqRequest([statusPayload({ slack: true })]);
-        const result = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, []);
-        assert.strictEqual(result.ready, true);
-        assert.strictEqual(result.polls, 0);
-        assert.strictEqual(calls(), 0);
-    });
-    test('resolves on the first poll when the channel is already live', async () => {
-        const { request, calls } = seqRequest([statusPayload({ slack: true })]);
-        const clock = fakeClock();
-        const result = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, ['slack'], { ...clock });
-        assert.strictEqual(result.ready, true);
-        assert.strictEqual(result.timedOut, false);
-        assert.deepStrictEqual(result.live, ['slack']);
-        assert.strictEqual(result.polls, 1);
-        assert.strictEqual(calls(), 1);
-    });
-    test('waits across the restart window, then resolves when the channel comes back', async () => {
-        // Slack is bouncing: down for two polls (mid-restart), then live.
-        const { request } = seqRequest([
-            statusPayload({ slack: false }),
-            statusPayload({ slack: false }),
-            statusPayload({ slack: true }),
-        ]);
-        const clock = fakeClock();
-        const result = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, ['slack'], { intervalMs: 100, timeoutMs: 5000, ...clock });
-        assert.strictEqual(result.ready, true);
-        assert.strictEqual(result.timedOut, false);
-        assert.strictEqual(result.polls, 3);
-    });
-    test('times out (best-effort) when the channel never returns', async () => {
-        const { request } = seqRequest([statusPayload({ slack: false })]);
-        const clock = fakeClock();
-        const result = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, ['slack'], { intervalMs: 400, timeoutMs: 1000, ...clock });
-        assert.strictEqual(result.ready, false);
-        assert.strictEqual(result.timedOut, true);
-        assert.deepStrictEqual(result.pending, ['slack']);
-    });
-    test('treats a failed channels.status poll as not-yet-live and keeps retrying', async () => {
-        const { request } = seqRequest(['throw', statusPayload({ slack: true })]);
-        const clock = fakeClock();
-        const result = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, ['slack'], { intervalMs: 100, timeoutMs: 5000, ...clock });
-        assert.strictEqual(result.ready, true);
-        assert.strictEqual(result.polls, 2);
-    });
-    test('only blocks on requested channels, ignoring other offline channels', async () => {
-        // telegram stays offline forever but is not requested, so it must not block on slack.
-        const { request } = seqRequest([statusPayload({ slack: true, telegram: false })]);
-        const clock = fakeClock();
-        const result = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, ['slack'], { ...clock });
-        assert.strictEqual(result.ready, true);
-        assert.deepStrictEqual(result.live, ['slack']);
-        assert.deepStrictEqual(result.pending, []);
-    });
-    test('requires all requested channels before reporting ready', async () => {
-        const { request } = seqRequest([
-            statusPayload({ slack: true, telegram: false }),
-            statusPayload({ slack: true, telegram: true }),
-        ]);
-        const clock = fakeClock();
-        const result = await (0, openclaw_channel_routing_js_1.waitForChannelsLive)(request, ['slack', 'telegram'], {
-            intervalMs: 100,
-            timeoutMs: 5000,
-            ...clock,
-        });
-        assert.strictEqual(result.ready, true);
-        assert.strictEqual(result.polls, 2);
-        assert.deepStrictEqual(result.live.sort(), ['slack', 'telegram']);
-    });
-});

package/out/test/pack-admission.test.js

@@ -1,216 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Pack admission: fail closed by default, re-verified per turn, and say WHY.
- *
- *  Three gaps, one suite:
- *    - the default was warn-and-run, so "verify before run, fail closed" was not true of the
- *      shipped shape;
- *    - the verdict was computed once at boot and cached for the life of the process, while the
- *      default deployment runs the engine in-process against a `fileAccess: full` pack directory;
- *    - each distinct failure needs its own message, because each has a different remedy.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert = __importStar(require("assert"));
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const warrant_1 = require("../authority/warrant");
-const signature_1 = require("../pack/signature");
-const key = (0, warrant_1.generateWarrantKeypair)('k1');
-const keys = { k1: key.publicKeyPem };
-function makePack(files = { 'agent.yaml': 'name: demo\n' }) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pack-admission-'));
-    for (const [rel, body] of Object.entries(files)) {
-        const abs = path.join(dir, rel);
-        fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, body);
-    }
-    return dir;
-}
-const sign = (dir) => (0, signature_1.signPack)({ packDir: dir, pack: 'demo', packVersion: '1.0.0', privateKeyPem: key.privateKeyPem, kid: 'k1' });
-suite('signing is required by DEFAULT', () => {
-    test('nothing configured ⇒ a signature is required', () => {
-        assert.strictEqual((0, signature_1.resolveRequireSignedPack)({}), true);
-    });
-    test('the escape hatch relaxes only this instance', () => {
-        assert.strictEqual((0, signature_1.resolveRequireSignedPack)({ localAllowUnsigned: true }), false);
-    });
-    test('a lease demand OVERRIDES the escape hatch — tighten-only survives the flip', () => {
-        assert.strictEqual((0, signature_1.resolveRequireSignedPack)({ lease: true, localAllowUnsigned: true }), true, 'an instance must never be able to waive what the control plane demanded');
-    });
-    test('--require-signed-pack still means something, and still cannot be waived', () => {
-        assert.strictEqual((0, signature_1.resolveRequireSignedPack)({ localRequire: true, localAllowUnsigned: true }), true);
-    });
-    test('the underlying tighten-only OR is unchanged', () => {
-        assert.strictEqual((0, signature_1.requireSignedPack)(undefined, undefined), false);
-        assert.strictEqual((0, signature_1.requireSignedPack)(true, undefined), true);
-        assert.strictEqual((0, signature_1.requireSignedPack)(undefined, true), true);
-        assert.strictEqual((0, signature_1.requireSignedPack)(true, true), true);
-    });
-    test('the escape hatch env var is explicit, not merely present', () => {
-        assert.strictEqual((0, signature_1.allowUnsignedPackFromEnv)({ [signature_1.ALLOW_UNSIGNED_PACK_ENV]: '1' }), true);
-        assert.strictEqual((0, signature_1.allowUnsignedPackFromEnv)({ [signature_1.ALLOW_UNSIGNED_PACK_ENV]: 'true' }), true);
-        assert.strictEqual((0, signature_1.allowUnsignedPackFromEnv)({ [signature_1.ALLOW_UNSIGNED_PACK_ENV]: '0' }), false);
-        assert.strictEqual((0, signature_1.allowUnsignedPackFromEnv)({}), false);
-    });
-});
-suite('each refusal names its own remedy', () => {
-    const cases = [
-        ['unsigned', /pack sign/],
-        ['no-trust-root', /AGENTHIPPO_PACK_JWKS_URL/],
-        ['trust-root-unavailable', /could not be loaded/],
-        ['unknown-key', /does not trust/],
-        ['digest-mismatch', /changed after signing/],
-        ['identity-mismatch', /different pack or version/],
-    ];
-    for (const [kind, expected] of cases) {
-        test(`${kind} produces its own actionable message`, () => {
-            const msg = (0, signature_1.describePackRefusal)({ kind, detail: 'detail here', pack: 'demo', packVersion: '1.0.0', packDir: '/p' });
-            assert.match(msg, /refusing to run demo@1\.0\.0/);
-            assert.match(msg, expected);
-            assert.match(msg, /AGENTHIPPO_ALLOW_UNSIGNED_PACK=1/, 'every refusal must state how to get moving again');
-            assert.match(msg, /cannot be waived locally/, 'and that the lease still wins');
-        });
-    }
-    test('"no trust root" and "unsigned" are different messages with different fixes', () => {
-        const unsigned = (0, signature_1.describePackRefusal)({ kind: 'unsigned', detail: 'x', pack: 'demo' });
-        const noRoot = (0, signature_1.describePackRefusal)({ kind: 'no-trust-root', detail: 'x', pack: 'demo' });
-        assert.notStrictEqual(unsigned, noRoot);
-        assert.ok(!/NOT a problem with the pack/.test(unsigned));
-        assert.match(noRoot, /NOT a problem with the pack/);
-    });
-});
-suite('the verifier refuses each distinct failure with its kind', () => {
-    test('unsigned', () => {
-        const v = (0, signature_1.createPackVerifier)();
-        const res = v.verify({ packDir: makePack(), pack: 'demo', packVersion: '1.0.0', keys });
-        assert.strictEqual(res.ok, false);
-        assert.strictEqual(res.kind, 'unsigned');
-    });
-    test('no trust root — distinguishable from unsigned', () => {
-        const dir = makePack();
-        sign(dir);
-        const res = (0, signature_1.createPackVerifier)().verify({ packDir: dir, pack: 'demo', packVersion: '1.0.0', keys: {} });
-        assert.strictEqual(res.ok, false);
-        assert.strictEqual(res.kind, 'no-trust-root');
-    });
-    test('unknown signing key', () => {
-        const dir = makePack();
-        sign(dir);
-        const stranger = (0, warrant_1.generateWarrantKeypair)('other');
-        const res = (0, signature_1.createPackVerifier)().verify({ packDir: dir, pack: 'demo', packVersion: '1.0.0', keys: { other: stranger.publicKeyPem } });
-        assert.strictEqual(res.ok, false);
-        assert.strictEqual(res.kind, 'unknown-key');
-    });
-    test('digest mismatch', () => {
-        const dir = makePack();
-        sign(dir);
-        fs.writeFileSync(path.join(dir, 'agent.yaml'), 'name: demo\nevil: true\n');
-        const res = (0, signature_1.createPackVerifier)().verify({ packDir: dir, pack: 'demo', packVersion: '1.0.0', keys });
-        assert.strictEqual(res.ok, false);
-        assert.strictEqual(res.kind, 'digest-mismatch');
-    });
-    test('identity mismatch — a valid signature for a different pack', () => {
-        const dir = makePack();
-        sign(dir);
-        const res = (0, signature_1.createPackVerifier)().verify({ packDir: dir, pack: 'payments', packVersion: '1.0.0', keys });
-        assert.strictEqual(res.ok, false);
-        assert.strictEqual(res.kind, 'identity-mismatch');
-    });
-});
-suite('re-verification on the turn path', () => {
-    /**
-     * The exact scenario: no --sandbox, so the engine runs in-process with `fileAccess: full`. The
-     * agent edits its own pack directory after boot. Under the old boot-once cache every subsequent
-     * turn passed on a stale `true`.
-     */
-    test('a pack edited AFTER the first verification is caught on the next turn', () => {
-        const dir = makePack();
-        sign(dir);
-        const v = (0, signature_1.createPackVerifier)({ probeIntervalMs: 0 });
-        const input = { packDir: dir, pack: 'demo', packVersion: '1.0.0', keys };
-        assert.ok(v.verify(input, 1_000).ok, 'clean at boot');
-        fs.writeFileSync(path.join(dir, '.claude', 'settings.json').replace('.claude/', ''), 'x');
-        fs.mkdirSync(path.join(dir, '.claude'), { recursive: true });
-        fs.writeFileSync(path.join(dir, '.claude', 'settings.json'), '{"hooks":{"PreToolUse":[{"command":"sh"}]}}');
-        const after = v.verify(input, 2_000);
-        assert.strictEqual(after.ok, false, 'the injected hook must be caught on a later turn');
-        assert.strictEqual(after.kind, 'digest-mismatch');
-    });
-    test('an unchanged pack is NOT re-hashed on every turn — the probe is what makes this affordable', () => {
-        const dir = makePack();
-        sign(dir);
-        const v = (0, signature_1.createPackVerifier)({ probeIntervalMs: 0, fullReverifyIntervalMs: 1_000_000 });
-        const input = { packDir: dir, pack: 'demo', packVersion: '1.0.0', keys };
-        v.verify(input, 1_000);
-        const afterFirst = v.fullVerifications();
-        for (let i = 0; i < 50; i++) {
-            assert.ok(v.verify(input, 1_000 + i).ok);
-        }
-        assert.strictEqual(v.fullVerifications(), afterFirst, '50 turns, one digest');
-    });
-    test('a full re-verify happens on an interval regardless of how clean the probe looks', () => {
-        const dir = makePack();
-        sign(dir);
-        const v = (0, signature_1.createPackVerifier)({ probeIntervalMs: 0, fullReverifyIntervalMs: 5_000 });
-        const input = { packDir: dir, pack: 'demo', packVersion: '1.0.0', keys };
-        v.verify(input, 0);
-        const before = v.fullVerifications();
-        v.verify(input, 1_000);
-        assert.strictEqual(v.fullVerifications(), before, 'within the interval, the probe decides');
-        v.verify(input, 6_000);
-        assert.strictEqual(v.fullVerifications(), before + 1, 'past it, we hash regardless — bounds the mtime-restoring attacker');
-    });
-    test('changing the keyring or the version invalidates the cached verdict outright', () => {
-        const dir = makePack();
-        sign(dir);
-        const v = (0, signature_1.createPackVerifier)({ fullReverifyIntervalMs: 1_000_000 });
-        assert.ok(v.verify({ packDir: dir, pack: 'demo', packVersion: '1.0.0', keys }, 0).ok);
-        const res = v.verify({ packDir: dir, pack: 'demo', packVersion: '2.0.0', keys }, 1);
-        assert.strictEqual(res.ok, false, 'a version change must not reuse the previous verdict');
-    });
-    test('a probe within the probe interval is not even taken', () => {
-        const dir = makePack();
-        sign(dir);
-        const v = (0, signature_1.createPackVerifier)({ probeIntervalMs: 10_000, fullReverifyIntervalMs: 1_000_000 });
-        const input = { packDir: dir, pack: 'demo', packVersion: '1.0.0', keys };
-        v.verify(input, 0);
-        fs.writeFileSync(path.join(dir, 'agent.yaml'), 'tampered');
-        assert.ok(v.verify(input, 5_000).ok, 'inside the probe interval the cached verdict stands (documented)');
-        assert.strictEqual(v.verify(input, 11_000).ok, false, 'and the very next probe catches it');
-    });
-});

package/out/test/pack-digest-parity.test.js

@@ -1,140 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  The two digest paths must agree, or a locally-signed pack can never verify through the store.
- *
- *  `computePackDigest` (directory walk) excluded SEVEN names at every level;
- *  `computePackDigestFromFiles` (fetched artifact) excluded ONE. Any pack containing `.claude/`,
- *  `.codex/` or `.agent-hippo/` therefore produced two different digests depending on which path
- *  looked at it — and the walk's exclusions were exactly where executable content lives.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert = __importStar(require("assert"));
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const reconcile_1 = require("../pack/reconcile");
-const signature_1 = require("../pack/signature");
-function makeTree() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'digest-parity-'));
-    const write = (rel, body) => {
-        const abs = path.join(dir, rel);
-        fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, body);
-    };
-    write('agent.yaml', 'name: demo\n');
-    write('AGENTS.md', '# demo\n');
-    write('skills/a/SKILL.md', 'do a thing');
-    // Executable content that used to sit OUTSIDE the signature at every level.
-    write('.claude/settings.json', '{"hooks":{}}');
-    write('.codex/config.toml', 'model = "x"');
-    write('.agent-hippo/agents/x/AGENTS.md', 'nested');
-    write('nested/.claude/settings.json', '{"hooks":{"PreToolUse":[]}}');
-    // OS litter, now hashed like anything else.
-    write('.DS_Store', 'finder junk');
-    // Genuinely not pack content, excluded at every depth.
-    write('.git/HEAD', 'ref: refs/heads/main');
-    write('node_modules/dep/index.js', 'module.exports = 1');
-    write('skills/node_modules/nested-dep/index.js', 'module.exports = 2');
-    // The signature cannot cover itself.
-    write(signature_1.PACK_SIGNATURE_FILE, 'a.b.c');
-    fs.symlinkSync('agent.yaml', path.join(dir, 'link-to-agent'));
-    return dir;
-}
-suite('digest parity between the tree walk and the file list', () => {
-    test('identical trees hash identically through both paths', () => {
-        const dir = makeTree();
-        assert.strictEqual((0, signature_1.computePackDigestFromFiles)((0, reconcile_1.readDirAsFiles)(dir)), (0, signature_1.computePackDigest)(dir), 'a pack signed on disk must verify from its own file list');
-    });
-    test('a change under .claude moves BOTH digests, not just one', () => {
-        const dir = makeTree();
-        const beforeWalk = (0, signature_1.computePackDigest)(dir);
-        const beforeFiles = (0, signature_1.computePackDigestFromFiles)((0, reconcile_1.readDirAsFiles)(dir));
-        fs.writeFileSync(path.join(dir, '.claude', 'settings.json'), '{"hooks":{"PreToolUse":[{"command":"sh -c evil"}]}}');
-        assert.notStrictEqual((0, signature_1.computePackDigest)(dir), beforeWalk);
-        assert.notStrictEqual((0, signature_1.computePackDigestFromFiles)((0, reconcile_1.readDirAsFiles)(dir)), beforeFiles);
-        assert.strictEqual((0, signature_1.computePackDigestFromFiles)((0, reconcile_1.readDirAsFiles)(dir)), (0, signature_1.computePackDigest)(dir));
-    });
-    test('a change under node_modules or .git moves neither', () => {
-        const dir = makeTree();
-        const walk = (0, signature_1.computePackDigest)(dir);
-        const files = (0, signature_1.computePackDigestFromFiles)((0, reconcile_1.readDirAsFiles)(dir));
-        fs.writeFileSync(path.join(dir, 'node_modules', 'dep', 'index.js'), 'module.exports = 99');
-        fs.writeFileSync(path.join(dir, '.git', 'HEAD'), 'ref: refs/heads/other');
-        assert.strictEqual((0, signature_1.computePackDigest)(dir), walk);
-        assert.strictEqual((0, signature_1.computePackDigestFromFiles)((0, reconcile_1.readDirAsFiles)(dir)), files);
-    });
-    test('a symlink and a regular file with the same target string are distinguishable', () => {
-        const a = fs.mkdtempSync(path.join(os.tmpdir(), 'digest-link-a-'));
-        fs.symlinkSync('target.txt', path.join(a, 'x'));
-        const b = fs.mkdtempSync(path.join(os.tmpdir(), 'digest-link-b-'));
-        fs.writeFileSync(path.join(b, 'x'), 'target.txt');
-        assert.notStrictEqual((0, signature_1.computePackDigest)(a), (0, signature_1.computePackDigest)(b));
-    });
-    test('the exclusion predicate is one function, applied to relative paths', () => {
-        assert.ok((0, signature_1.isDigestExcluded)(signature_1.PACK_SIGNATURE_FILE));
-        assert.ok((0, signature_1.isDigestExcluded)('.git/HEAD'));
-        assert.ok((0, signature_1.isDigestExcluded)('a/node_modules/b'));
-        assert.ok(!(0, signature_1.isDigestExcluded)('.claude/settings.json'));
-        assert.ok(!(0, signature_1.isDigestExcluded)('.codex/config.toml'));
-        assert.ok(!(0, signature_1.isDigestExcluded)('.agent-hippo/x'));
-        assert.ok(!(0, signature_1.isDigestExcluded)('.DS_Store'));
-        // `pack.sig` is only special at the ROOT — a file of that name deeper in is content.
-        assert.ok(!(0, signature_1.isDigestExcluded)(`skills/${signature_1.PACK_SIGNATURE_FILE}`));
-    });
-});
-suite('the cheap integrity probe', () => {
-    test('it moves when content changes, and is stable when nothing does', () => {
-        const dir = makeTree();
-        const before = (0, signature_1.packTreeProbe)(dir);
-        assert.strictEqual((0, signature_1.packTreeProbe)(dir), before, 'a stat-only probe must be deterministic');
-        fs.writeFileSync(path.join(dir, 'agent.yaml'), 'name: demo\nchanged: true\n');
-        assert.notStrictEqual((0, signature_1.packTreeProbe)(dir), before);
-    });
-    test('it moves when a file is ADDED, which a per-file check would miss', () => {
-        const dir = makeTree();
-        const before = (0, signature_1.packTreeProbe)(dir);
-        fs.writeFileSync(path.join(dir, '.claude', 'hooks.json'), '{}');
-        assert.notStrictEqual((0, signature_1.packTreeProbe)(dir), before);
-    });
-    test('it ignores the same subtrees the digest does', () => {
-        const dir = makeTree();
-        const before = (0, signature_1.packTreeProbe)(dir);
-        fs.mkdirSync(path.join(dir, 'node_modules', 'new'), { recursive: true });
-        fs.writeFileSync(path.join(dir, 'node_modules', 'new', 'i.js'), 'x');
-        assert.strictEqual((0, signature_1.packTreeProbe)(dir), before);
-    });
-});