@askthew/mcp-plugin 0.4.6 → 0.4.8

package/dist/install.test.d.ts

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

package/dist/install.test.js

@@ -1,314 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { formatInstallCommand, installBehaviorInstructions, installHostConfig, mergeHostSettings, resolveSettingsPath, sendInstallHeartbeat, uninstallBehaviorInstructions, uninstallHostConfig, verificationNextStep, } from "./install.js";
-test("mergeHostSettings preserves unrelated MCP servers and replaces askthew", () => {
-    const tempProject = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-merge-project-"));
-    fs.writeFileSync(path.join(tempProject, "package.json"), "{}", "utf8");
-    const merged = mergeHostSettings({
-        existingSettings: {
-            theme: "dark",
-            mcpServers: {
-                github: {
-                    command: "github-mcp",
-                },
-                askthew: {
-                    command: "old-command",
-                },
-            },
-        },
-        hostType: "codex",
-        token: "token-123",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew_workspace_a",
-        cwd: tempProject,
-    });
-    assert.deepEqual(merged.theme, "dark");
-    assert.deepEqual(Object.keys(merged.mcpServers ?? {}).sort(), ["askthew_workspace_a", "github"]);
-    assert.deepEqual(merged.mcpServers.askthew_workspace_a, {
-        command: "npx",
-        args: ["-y", "--prefer-online", "--package", "@askthew/mcp-plugin@latest", "askthew-mcp"],
-        env: {
-            ASKTHEW_INSTALL_TOKEN: "token-123",
-            ASKTHEW_API_URL: "https://askthew.example.com",
-            ASKTHEW_HOST_TYPE: "codex",
-            ASKTHEW_SERVER_NAME: "askthew_workspace_a",
-            ASKTHEW_REPO_NAME: path.basename(tempProject),
-            ASKTHEW_REPO_ROOT: tempProject,
-        },
-    });
-    fs.rmSync(tempProject, { recursive: true, force: true });
-});
-test("installHostConfig writes Claude Code local MCP settings and stays idempotent", () => {
-    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-mcp-install-"));
-    const tempProject = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-claude-project-"));
-    const settingsPath = resolveSettingsPath({
-        hostType: "claude_code",
-        homeDirectory: tempHome,
-    });
-    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-    fs.writeFileSync(settingsPath, JSON.stringify({
-        projects: {
-            [tempProject]: {
-                mcpServers: {
-                    github: {
-                        command: "github-mcp",
-                    },
-                },
-            },
-        },
-    }, null, 2), "utf8");
-    const first = installHostConfig({
-        hostType: "claude_code",
-        token: "token-456",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew_workspace_a",
-        clientId: "claude_code",
-        clientLabel: "Claude Code",
-        homeDirectory: tempHome,
-        cwd: tempProject,
-    });
-    const afterFirst = fs.readFileSync(settingsPath, "utf8");
-    const second = installHostConfig({
-        hostType: "claude_code",
-        token: "token-456",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew_workspace_a",
-        clientId: "claude_code",
-        clientLabel: "Claude Code",
-        homeDirectory: tempHome,
-        cwd: tempProject,
-    });
-    const afterSecond = fs.readFileSync(settingsPath, "utf8");
-    const parsed = JSON.parse(afterSecond);
-    const projectServers = parsed.projects[tempProject].mcpServers;
-    assert.equal(first.settingsPath, settingsPath);
-    assert.equal(second.settingsPath, settingsPath);
-    assert.equal(afterFirst, afterSecond);
-    assert.deepEqual(Object.keys(projectServers ?? {}).sort(), ["askthew_workspace_a", "github"]);
-    assert.equal(projectServers.askthew_workspace_a.env.ASKTHEW_INSTALL_TOKEN, "token-456");
-    assert.equal(projectServers.askthew_workspace_a.env.ASKTHEW_CLIENT_ID, "claude_code");
-    assert.equal(projectServers.askthew_workspace_a.env.ASKTHEW_CLIENT_LABEL, "Claude Code");
-    fs.rmSync(tempHome, { recursive: true, force: true });
-    fs.rmSync(tempProject, { recursive: true, force: true });
-});
-test("installHostConfig writes Codex MCP servers to config.toml", () => {
-    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-mcp-multi-workspace-"));
-    const settingsPath = resolveSettingsPath({
-        hostType: "codex",
-        homeDirectory: tempHome,
-    });
-    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-    fs.writeFileSync(settingsPath, [
-        'model = "gpt-5"',
-        "",
-        "[mcp_servers.github]",
-        'command = "github-mcp"',
-        "",
-    ].join("\n"), "utf8");
-    installHostConfig({
-        hostType: "codex",
-        token: "token-a",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew_workspace_a",
-        homeDirectory: tempHome,
-    });
-    installHostConfig({
-        hostType: "codex",
-        token: "token-b",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew_workspace_b",
-        homeDirectory: tempHome,
-    });
-    const toml = fs.readFileSync(settingsPath, "utf8");
-    assert.match(toml, /\[mcp_servers\.github\]/);
-    assert.match(toml, /\[mcp_servers\.askthew_workspace_a\]/);
-    assert.match(toml, /\[mcp_servers\.askthew_workspace_b\]/);
-    assert.match(toml, /ASKTHEW_INSTALL_TOKEN = "token-a"/);
-    assert.match(toml, /ASKTHEW_INSTALL_TOKEN = "token-b"/);
-    fs.rmSync(tempHome, { recursive: true, force: true });
-});
-test("installHostConfig dry run returns merged JSON without writing a file", () => {
-    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-mcp-dry-run-"));
-    const settingsPath = resolveSettingsPath({
-        hostType: "codex",
-        homeDirectory: tempHome,
-    });
-    const result = installHostConfig({
-        hostType: "codex",
-        token: "token-789",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew_workspace_a",
-        homeDirectory: tempHome,
-        dryRun: true,
-    });
-    assert.equal(result.wroteFile, false);
-    assert.equal(fs.existsSync(settingsPath), false);
-    assert.match(result.json, /ASKTHEW_INSTALL_TOKEN/);
-    assert.match(result.json, /\[mcp_servers\.askthew_workspace_a\]/);
-    fs.rmSync(tempHome, { recursive: true, force: true });
-});
-test("installHostConfig writes Cursor global mcp.json", () => {
-    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-cursor-mcp-"));
-    const settingsPath = resolveSettingsPath({
-        hostType: "cursor",
-        homeDirectory: tempHome,
-    });
-    installHostConfig({
-        hostType: "cursor",
-        token: "token-cursor",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew",
-        homeDirectory: tempHome,
-    });
-    const parsed = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
-    assert.deepEqual(Object.keys(parsed.mcpServers ?? {}), ["askthew"]);
-    assert.equal(parsed.mcpServers.askthew.command, "npx");
-    assert.equal(parsed.mcpServers.askthew.env.ASKTHEW_HOST_TYPE, "cursor");
-    fs.rmSync(tempHome, { recursive: true, force: true });
-});
-test("formatInstallCommand emits the one-command guided install form", () => {
-    const command = formatInstallCommand({
-        hostType: "codex",
-        token: "token-abc",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew_workspace_a",
-    });
-    assert.equal(command, 'npx -y --prefer-online --package @askthew/mcp-plugin@latest askthew-mcp install --host codex --token "token-abc" --api-url "https://askthew.example.com" --server-name "askthew_workspace_a"');
-});
-test("verificationNextStep points users to every-session startup capture", () => {
-    const nextStep = verificationNextStep("codex");
-    assert.match(nextStep, /Refresh Ask The W/);
-    assert.match(nextStep, /every new Codex session in this repo/);
-    assert.match(nextStep, /before plan mode or exploration/);
-    assert.match(nextStep, /list_mcp_resources\/list_mcp_resource_templates may be empty/);
-});
-test("sendInstallHeartbeat pings Ask The W after config install", async () => {
-    const calls = [];
-    const ok = await sendInstallHeartbeat({
-        hostType: "codex",
-        token: "token-abc",
-        apiUrl: "https://askthew.example.com/",
-        serverName: "askthew",
-        cwd: process.cwd(),
-        fetchImpl: async (url, init) => {
-            calls.push({
-                url: String(url),
-                body: JSON.parse(String(init?.body ?? "{}")),
-            });
-            return new Response("{}", { status: 200 });
-        },
-    });
-    assert.equal(ok, true);
-    assert.equal(calls[0]?.url, "https://askthew.example.com/api/connectors/mcp/heartbeat");
-    assert.equal(calls[0]?.body.installToken, "token-abc");
-    assert.equal(calls[0]?.body.hostType, "codex");
-    assert.equal(calls[0]?.body.serverName, "askthew");
-    assert.equal(calls[0]?.body.clientId, "codex");
-});
-test("installBehaviorInstructions adds persistent Codex tracking rules without clobbering existing instructions", () => {
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-agent-instructions-"));
-    const claudePath = path.join(tempRoot, "CLAUDE.md");
-    const agentsPath = path.join(tempRoot, "AGENTS.md");
-    fs.writeFileSync(agentsPath, "# Existing instructions\n\nKeep this section.\n", "utf8");
-    const result = installBehaviorInstructions({
-        hostType: "codex",
-        cwd: tempRoot,
-    });
-    const claudeContents = fs.readFileSync(claudePath, "utf8");
-    const contents = fs.readFileSync(agentsPath, "utf8");
-    assert.equal(result.path, agentsPath);
-    assert.deepEqual(result.paths, [claudePath, agentsPath]);
-    assert.match(claudeContents, /Ask The W Plugin/);
-    assert.match(claudeContents, /At the start of every new Codex session in this repo/);
-    assert.match(contents, /# Existing instructions/);
-    assert.match(contents, /Ask The W Plugin/);
-    assert.match(contents, /capture_session_signal/);
-    assert.match(contents, /At the start of every new Codex session in this repo/);
-    assert.match(contents, /before plan mode, exploration, or any normal reply/);
-    assert.match(contents, /metadata\.recovered_missed_startup=true/);
-    assert.match(contents, /before using tools that write files/);
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-test("installBehaviorInstructions creates Cursor rule file", () => {
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-cursor-rules-"));
-    const result = installBehaviorInstructions({
-        hostType: "cursor",
-        cwd: tempRoot,
-    });
-    assert.equal(result.path, path.join(tempRoot, ".cursor", "rules", "askthew.mdc"));
-    assert.match(fs.readFileSync(result.path, "utf8"), /alwaysApply: true/);
-    assert.match(fs.readFileSync(result.path, "utf8"), /Ask The W Plugin/);
-    assert.match(fs.readFileSync(result.path, "utf8"), /At the start of every new Cursor session/);
-    assert.match(fs.readFileSync(result.path, "utf8"), /before plan mode, exploration, or any normal reply/);
-    assert.match(fs.readFileSync(result.path, "utf8"), /metadata\.recovered_missed_startup=true/);
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-test("installBehaviorInstructions adds stack-specific verification nudges", () => {
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-stack-rules-"));
-    fs.writeFileSync(path.join(tempRoot, "package.json"), JSON.stringify({
-        dependencies: {
-            next: "^15.0.0",
-            openai: "^5.0.0",
-            vite: "^6.0.0",
-        },
-    }), "utf8");
-    const result = installBehaviorInstructions({
-        hostType: "codex",
-        cwd: tempRoot,
-        dryRun: true,
-    });
-    assert.match(result.content, /Next\.js detected/);
-    assert.match(result.content, /OpenAI SDK detected/);
-    assert.match(result.content, /Vite detected/);
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-test("uninstall removes host config and Ask The W agent instruction blocks", () => {
-    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-uninstall-home-"));
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-uninstall-project-"));
-    installHostConfig({
-        hostType: "codex",
-        token: "token-uninstall",
-        apiUrl: "https://askthew.example.com",
-        serverName: "askthew",
-        homeDirectory: tempHome,
-    });
-    installBehaviorInstructions({
-        hostType: "codex",
-        cwd: tempRoot,
-    });
-    const removed = uninstallHostConfig({
-        hostType: "codex",
-        serverName: "askthew",
-        homeDirectory: tempHome,
-    });
-    const instructions = uninstallBehaviorInstructions({
-        hostType: "codex",
-        cwd: tempRoot,
-    });
-    assert.doesNotMatch(fs.readFileSync(removed.settingsPath, "utf8"), /askthew/);
-    assert.equal(removed.foundConfigFile, true);
-    assert.equal(removed.removedServer, true);
-    assert.equal(removed.wroteFile, true);
-    assert.equal(instructions.paths.length, 2);
-    assert.doesNotMatch(fs.readFileSync(path.join(tempRoot, "AGENTS.md"), "utf8"), /ASKTHEW_PLUGIN_INSTRUCTIONS_START/);
-    assert.doesNotMatch(fs.readFileSync(path.join(tempRoot, "CLAUDE.md"), "utf8"), /ASKTHEW_PLUGIN_INSTRUCTIONS_START/);
-    fs.rmSync(tempHome, { recursive: true, force: true });
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-test("uninstall reports when no broken-npx install artifacts exist", () => {
-    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-uninstall-empty-home-"));
-    const removed = uninstallHostConfig({
-        hostType: "codex",
-        serverName: "askthew",
-        homeDirectory: tempHome,
-        dryRun: true,
-    });
-    assert.equal(removed.foundConfigFile, false);
-    assert.equal(removed.removedServer, false);
-    assert.equal(removed.wroteFile, false);
-    assert.equal(removed.json, "");
-    fs.rmSync(tempHome, { recursive: true, force: true });
-});

package/dist/local-identity.test.d.ts

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

package/dist/local-identity.test.js

@@ -1,29 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import crypto from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { ensureLocalIdentity, signLocalIdentityPayload } from "./lib/local-identity.js";
-import { identityPath } from "./lib/paths.js";
-test("local identity uses install id as primary identity and signs summary payloads", () => {
-    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-local-identity-"));
-    try {
-        const env = { ASKTHEW_DATA_DIR: dataDir };
-        const identity = ensureLocalIdentity({
-            emailClaim: "Founder@Example.com",
-            apiUrl: "https://app.askthew.com",
-            env,
-        });
-        const body = JSON.stringify({ schemaVersion: 1, activity: { signalCount: 1 } });
-        const signed = signLocalIdentityPayload({ identity, body, timestamp: "2026-05-07T12:00:00.000Z" });
-        assert.match(identity.installId, /^[0-9a-f-]{36}$/);
-        assert.equal(identity.emailClaim, "founder@example.com");
-        assert.equal(fs.existsSync(identityPath(env)), true);
-        assert.equal(crypto.verify(null, Buffer.from(`${signed.timestamp}.${body}`), identity.publicKey, Buffer.from(signed.signature, "base64url")), true);
-        assert.equal(crypto.verify(null, Buffer.from(`${signed.timestamp}.${JSON.stringify({ tampered: true })}`), identity.publicKey, Buffer.from(signed.signature, "base64url")), false);
-    }
-    finally {
-        fs.rmSync(dataDir, { recursive: true, force: true });
-    }
-});

package/dist/local-store.test.d.ts

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

package/dist/local-store.test.js

@@ -1,71 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { LocalStore } from "./lib/local-store.js";
-test("local store migrates, captures signals, decisions, and FIFO telemetry", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-store-"));
-    const store = LocalStore.open({ path: path.join(dir, "store.sqlite") });
-    const signal = store.insertSignal({
-        sessionId: "s1",
-        sequence: 1,
-        kind: "session_checkpoint",
-        summary: "Checkpoint",
-        filesTouched: ["src/app.ts"],
-        commandsRun: ["npm test"],
-    });
-    const duplicate = store.insertSignal({
-        sessionId: "s1",
-        sequence: 1,
-        kind: "session_checkpoint",
-        summary: "Checkpoint duplicate",
-    });
-    const decision = store.createDecision({
-        rawContent: "Use local SQLite for free-tier capture.",
-        sessionId: "s1",
-        sourceSignalIds: [signal.id],
-    });
-    const firstOutbox = store.enqueueTelemetry({ n: 1 });
-    const secondOutbox = store.enqueueTelemetry({ n: 2 });
-    assert.equal(signal.id, duplicate.id);
-    assert.equal(store.listSignals({ sessionId: "s1" }).length, 1);
-    assert.equal(store.getDecision(decision.id)?.headline, "Use local SQLite for free-tier capture.");
-    assert.deepEqual(store.listTelemetryOutbox().map((row) => row.id), [firstOutbox, secondOutbox]);
-    store.close();
-    fs.rmSync(dir, { recursive: true, force: true });
-});
-test("local store scopes trail rows, links decisions, and tracks lifecycle timestamps", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-store-scope-"));
-    const store = LocalStore.open({ path: path.join(dir, "store.sqlite") });
-    const scoped = store.insertSignal({
-        sessionId: "s1",
-        sequence: 1,
-        kind: "direction_change",
-        summary: "Let's go with local search because it is fast.",
-        scopeKey: "repo-a",
-    });
-    store.insertSignal({
-        sessionId: "s2",
-        sequence: 1,
-        kind: "direction_change",
-        summary: "Use a different decision in another repo.",
-        scopeKey: "repo-b",
-    });
-    const decision = store.createDecision({
-        rawContent: "Adopt local search.",
-        sessionId: "s1",
-        sourceSignalIds: [scoped.id],
-        scopeKey: "repo-a",
-    });
-    const committed = store.updateDecision(decision.id, { status: "committed" });
-    assert.equal(store.listSignals({ scopeKey: "repo-a" }).length, 1);
-    assert.equal(store.listSignals({ scopeKey: "repo-b" }).length, 1);
-    assert.equal(store.listDecisions({ scopeKey: "repo-a" }).length, 1);
-    assert.equal(store.getDecisionForSignal(scoped.id)?.id, decision.id);
-    assert.equal(Boolean(decision.proposedAt), true);
-    assert.equal(Boolean(committed?.committedAt), true);
-    assert.equal(store.mostRecentSessionId({ scopeKey: "repo-a" }), "s1");
-    store.close();
-    fs.rmSync(dir, { recursive: true, force: true });
-});

package/dist/scope.test.d.ts

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

package/dist/scope.test.js

@@ -1,49 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { resolvePluginScope } from "./scope.js";
-test("resolvePluginScope derives repo and app path from cwd", () => {
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-scope-"));
-    const repoRoot = path.join(tempRoot, "repo");
-    const appRoot = path.join(repoRoot, "apps", "landing");
-    fs.mkdirSync(path.join(repoRoot, ".git"), { recursive: true });
-    fs.mkdirSync(appRoot, { recursive: true });
-    const scope = resolvePluginScope(appRoot);
-    assert.equal(scope.repoName, "repo");
-    assert.equal(scope.repoRoot, repoRoot);
-    assert.equal(scope.appPath, "apps/landing");
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-test("resolvePluginScope respects explicit .asktheworld.toml values", () => {
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-scope-config-"));
-    fs.mkdirSync(tempRoot, { recursive: true });
-    fs.writeFileSync(path.join(tempRoot, ".asktheworld.toml"), [
-        'repo_name = "main-platform"',
-        'app_path = "apps/decisions"',
-        'service_name = "decisions"',
-    ].join("\n"), "utf8");
-    const scope = resolvePluginScope(tempRoot);
-    assert.equal(scope.repoName, "main-platform");
-    assert.equal(scope.appPath, "apps/decisions");
-    assert.equal(scope.serviceName, "decisions");
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-});
-test("resolvePluginScope prefers install-time repo env over npx sandbox cwd", () => {
-    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "askthew-scope-env-"));
-    const repoRoot = path.join(tempRoot, "ThesisEngine-main");
-    const sandboxRoot = path.join(tempRoot, "task");
-    fs.mkdirSync(path.join(repoRoot, ".git"), { recursive: true });
-    fs.mkdirSync(sandboxRoot, { recursive: true });
-    fs.writeFileSync(path.join(sandboxRoot, "package.json"), "{}", "utf8");
-    const scope = resolvePluginScope(sandboxRoot, {
-        ASKTHEW_REPO_NAME: "ThesisEngine-main",
-        ASKTHEW_REPO_ROOT: repoRoot,
-        ASKTHEW_APP_PATH: "apps/app",
-    });
-    assert.equal(scope.repoName, "ThesisEngine-main");
-    assert.equal(scope.repoRoot, repoRoot);
-    assert.equal(scope.appPath, "apps/app");
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-});

package/dist/timeline-insights.test.d.ts

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

package/dist/timeline-insights.test.js

@@ -1,85 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { buildTimelineInsights, buildLocalTimeline } from "./lib/timeline-insights.js";
-function signal(id, day) {
-    return {
-        id,
-        sessionId: "session-a",
-        sequence: id,
-        kind: "session_checkpoint",
-        summary: "checkpoint",
-        evidence: [],
-        filesTouched: [],
-        commandsRun: [],
-        metadata: {},
-        capturedAt: `${day}T10:00:00.000Z`,
-    };
-}
-test("local timeline buckets signals and decisions by day", () => {
-    const decisions = [{
-            id: "d1",
-            sessionId: "session-a",
-            headline: "Decision",
-            why: null,
-            status: "proposed",
-            alignment: null,
-            files: [],
-            sourceSignalIds: [],
-            rawContent: "Decision",
-            createdAt: "2026-05-01T11:00:00.000Z",
-            updatedAt: "2026-05-01T11:00:00.000Z",
-            uploadedAt: null,
-        }];
-    const points = buildLocalTimeline({
-        scope: "day",
-        signals: [signal(1, "2026-05-01"), signal(2, "2026-05-02")],
-        decisions,
-    });
-    assert.deepEqual(points.map((point) => [point.x, point.signalCount, point.decisionCount]), [
-        ["2026-05-01", 1, 1],
-        ["2026-05-02", 1, 0],
-    ]);
-});
-test("local timeline insight ids stay in timeline namespace", () => {
-    const insights = buildTimelineInsights([{ x: "2026-05-01", signalCount: 20, decisionCount: 1 }]);
-    assert.ok(insights.every((insight) => insight.id.startsWith("timeline.")));
-});
-test("session timeline buckets by sessionId without inventing Other", () => {
-    const decisions = [
-        {
-            id: "d1",
-            sessionId: null,
-            headline: "Decision without session",
-            why: null,
-            status: "proposed",
-            alignment: null,
-            files: [],
-            sourceSignalIds: [],
-            rawContent: "Decision without session",
-            createdAt: "2026-05-01T11:00:00.000Z",
-            updatedAt: "2026-05-01T11:00:00.000Z",
-            uploadedAt: null,
-        },
-        {
-            id: "d2",
-            sessionId: "session-a",
-            headline: "Decision with session",
-            why: null,
-            status: "proposed",
-            alignment: null,
-            files: [],
-            sourceSignalIds: [],
-            rawContent: "Decision with session",
-            createdAt: "2026-05-01T11:00:00.000Z",
-            updatedAt: "2026-05-01T11:00:00.000Z",
-            uploadedAt: null,
-        },
-    ];
-    const points = buildLocalTimeline({
-        scope: "session",
-        signals: [signal(1, "2026-05-01")],
-        decisions,
-    });
-    assert.deepEqual(points.map((point) => point.x), ["session-a"]);
-    assert.equal(points[0]?.decisionCount, 1);
-});

package/dist/tip-engine.test.d.ts

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

package/dist/tip-engine.test.js

@@ -1,51 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { analyzeLocalPatterns } from "./lib/tip-engine.js";
-function signal(id, kind, summary = "ok") {
-    return {
-        id,
-        sessionId: "s1",
-        sequence: id,
-        kind,
-        summary,
-        evidence: [],
-        filesTouched: [`file${id}.ts`],
-        commandsRun: [],
-        metadata: {},
-        capturedAt: "2026-05-05T10:00:00.000Z",
-    };
-}
-test("tip engine is deterministic and sorts top severity first", () => {
-    const signals = [
-        signal(1, "direction_change"),
-        signal(2, "direction_change"),
-        signal(3, "direction_change"),
-        signal(4, "direction_change"),
-        signal(5, "verification_result", "failed"),
-        signal(6, "verification_result", "failed"),
-        signal(7, "verification_result", "failed"),
-        signal(8, "verification_result", "passed"),
-    ];
-    const decisions = [1, 2, 3].map((index) => ({
-        id: `d_${index}`,
-        sessionId: "s1",
-        headline: `Decision ${index}`,
-        why: "",
-        status: "proposed",
-        alignment: null,
-        files: [],
-        sourceSignalIds: [],
-        rawContent: `Decision ${index}`,
-        createdAt: "2026-05-01T10:00:00.000Z",
-        updatedAt: "2026-05-01T10:00:00.000Z",
-        uploadedAt: null,
-    }));
-    const first = analyzeLocalPatterns({ signals, decisions, now: new Date("2026-05-05T10:00:00.000Z") });
-    const second = analyzeLocalPatterns({ signals, decisions, now: new Date("2026-05-05T10:00:00.000Z") });
-    assert.deepEqual(first, second);
-    assert.equal(first.length, 3);
-    assert.equal(first[0]?.severity, "high");
-});
-test("tip engine stays quiet on empty input", () => {
-    assert.deepEqual(analyzeLocalPatterns({ signals: [], decisions: [] }), []);
-});