chainlesschain 0.162.100 → 0.162.102

package/src/lib/instinct-manager.js

@@ -20,6 +20,70 @@ export function ensureInstinctsTable(db) {
   `);
 }
 
+/** datetime('now')-style timestamp for rows missing one on import. */
+function _instinctNowSqlite() {
+  return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+
+/**
+ * Export ALL instincts (full dump) for §8.3 cross-device backup. Deterministic
+ * order so the same DB exports identically.
+ */
+export function exportInstincts(db) {
+  ensureInstinctsTable(db);
+  return db
+    .prepare(
+      `SELECT id, category, pattern, confidence, occurrences, last_seen, created_at
+       FROM instincts ORDER BY created_at ASC, id ASC`,
+    )
+    .all();
+}
+
+/**
+ * Import instincts (§8.3 restore): idempotent upsert by id — preserves created_at,
+ * updates category/pattern/confidence/occurrences/last_seen. Never aborts mid-batch.
+ */
+export function importInstincts(db, rows) {
+  ensureInstinctsTable(db);
+  if (!Array.isArray(rows)) {
+    throw new Error("importInstincts: rows must be a JSON array");
+  }
+  const stmt = db.prepare(
+    `INSERT INTO instincts (id, category, pattern, confidence, occurrences, last_seen, created_at)
+     VALUES (@id, @category, @pattern, @confidence, @occurrences, @last_seen, @created_at)
+     ON CONFLICT(id) DO UPDATE SET
+       category = excluded.category,
+       pattern = excluded.pattern,
+       confidence = excluded.confidence,
+       occurrences = excluded.occurrences,
+       last_seen = excluded.last_seen`,
+  );
+  let imported = 0;
+  let failed = 0;
+  const errors = [];
+  for (const r of rows) {
+    try {
+      if (!r || !r.id || !r.category || !r.pattern) {
+        throw new Error("invalid instinct (need id + category + pattern)");
+      }
+      stmt.run({
+        id: String(r.id),
+        category: r.category,
+        pattern: r.pattern,
+        confidence: typeof r.confidence === "number" ? r.confidence : 0.5,
+        occurrences: Number.isInteger(r.occurrences) ? r.occurrences : 1,
+        last_seen: r.last_seen || _instinctNowSqlite(),
+        created_at: r.created_at || _instinctNowSqlite(),
+      });
+      imported += 1;
+    } catch (e) {
+      failed += 1;
+      if (errors.length < 10) errors.push({ id: r && r.id, error: e.message });
+    }
+  }
+  return { ok: failed === 0, imported, failed, errors };
+}
+
 function generateId() {
   const hex = () =>
     Math.floor(Math.random() * 0x10000)

package/src/lib/learning/learning-tables.js

@@ -64,3 +64,86 @@ export function ensureLearningTables(db) {
     )
   `);
 }
+
+/** datetime('now')-style timestamp for rows missing one on import. */
+function _learningNowSqlite() {
+  return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+
+/**
+ * Export ALL learning trajectories (full dump) for §8.3 cross-device backup.
+ * Includes the synthesized_skill linkage (synthesized skills travel with the
+ * trajectories that produced them). The learning_trajectory_tags side-table is
+ * derived and intentionally not exported in v1.
+ */
+export function exportTrajectories(db) {
+  ensureLearningTables(db);
+  return db
+    .prepare(
+      `SELECT id, session_id, user_intent, tool_chain, tool_count, final_response,
+              outcome_score, outcome_source, complexity_level, synthesized_skill,
+              created_at, completed_at
+       FROM learning_trajectories ORDER BY created_at ASC, id ASC`,
+    )
+    .all();
+}
+
+/**
+ * Import learning trajectories (§8.3 restore): idempotent upsert by id —
+ * preserves created_at, updates the rest. Never aborts mid-batch.
+ */
+export function importTrajectories(db, rows) {
+  ensureLearningTables(db);
+  if (!Array.isArray(rows)) {
+    throw new Error("importTrajectories: rows must be a JSON array");
+  }
+  const stmt = db.prepare(
+    `INSERT INTO learning_trajectories
+       (id, session_id, user_intent, tool_chain, tool_count, final_response,
+        outcome_score, outcome_source, complexity_level, synthesized_skill,
+        created_at, completed_at)
+     VALUES (@id, @session_id, @user_intent, @tool_chain, @tool_count, @final_response,
+             @outcome_score, @outcome_source, @complexity_level, @synthesized_skill,
+             @created_at, @completed_at)
+     ON CONFLICT(id) DO UPDATE SET
+       session_id = excluded.session_id,
+       user_intent = excluded.user_intent,
+       tool_chain = excluded.tool_chain,
+       tool_count = excluded.tool_count,
+       final_response = excluded.final_response,
+       outcome_score = excluded.outcome_score,
+       outcome_source = excluded.outcome_source,
+       complexity_level = excluded.complexity_level,
+       synthesized_skill = excluded.synthesized_skill,
+       completed_at = excluded.completed_at`,
+  );
+  let imported = 0;
+  let failed = 0;
+  const errors = [];
+  for (const r of rows) {
+    try {
+      if (!r || !r.id || !r.session_id) {
+        throw new Error("invalid trajectory (need id + session_id)");
+      }
+      stmt.run({
+        id: String(r.id),
+        session_id: String(r.session_id),
+        user_intent: r.user_intent ?? null,
+        tool_chain: r.tool_chain ?? "[]",
+        tool_count: Number.isInteger(r.tool_count) ? r.tool_count : 0,
+        final_response: r.final_response ?? null,
+        outcome_score: typeof r.outcome_score === "number" ? r.outcome_score : null,
+        outcome_source: r.outcome_source ?? null,
+        complexity_level: r.complexity_level ?? "simple",
+        synthesized_skill: r.synthesized_skill ?? null,
+        created_at: r.created_at || _learningNowSqlite(),
+        completed_at: r.completed_at ?? null,
+      });
+      imported += 1;
+    } catch (e) {
+      failed += 1;
+      if (errors.length < 10) errors.push({ id: r && r.id, error: e.message });
+    }
+  }
+  return { ok: failed === 0, imported, failed, errors };
+}

package/src/lib/mcp-oauth.js

@@ -410,7 +410,7 @@ function defaultOpenBrowser(url) {
 }
 
 /** Wait for the OAuth redirect on a localhost callback server; resolve {code,state}. */
-function waitForCallback({
+export function waitForCallback({
   port,
   host = "127.0.0.1",
   path = "/callback",
@@ -446,7 +446,15 @@ function waitForCallback({
       server.close();
       reject(new Error("timed out waiting for the OAuth callback"));
     }, timeout);
-    server.on("error", reject);
+    // Backstop timer should never keep the process alive on its own (the
+    // listening server does that); the loop exits promptly once it closes.
+    timer.unref?.();
+    server.on("error", (err) => {
+      // Without clearing the timer here, a bind failure (e.g. port in use)
+      // left it pending for the full `timeout`, delaying process exit.
+      clearTimeout(timer);
+      reject(err);
+    });
     server.listen(port, host);
   });
 }

package/src/lib/memory-manager.js

@@ -133,6 +133,73 @@ export function listMemory(db, options = {}) {
     .all(limit);
 }
 
+/**
+ * Export ALL memory entries (full dump, no limit) for §8.3 cross-device backup.
+ * Returns rows with id/content/category/importance/source/created_at/updated_at,
+ * ordered deterministically so the same DB exports identically.
+ */
+export function exportMemory(db) {
+  ensureMemoryTable(db);
+  return db
+    .prepare(
+      `SELECT id, content, category, importance, source, created_at, updated_at
+       FROM memory_entries ORDER BY created_at ASC, id ASC`,
+    )
+    .all();
+}
+
+/** datetime('now')-style timestamp for entries missing one on import. */
+function _nowSqlite() {
+  return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+
+/**
+ * Import memory entries (§8.3 backup restore): idempotent upsert by id —
+ * preserves the original created_at, updates content/category/importance/source/
+ * updated_at. Never aborts mid-batch; returns {ok, imported, failed, errors}.
+ */
+export function importMemory(db, entries) {
+  ensureMemoryTable(db);
+  if (!Array.isArray(entries)) {
+    throw new Error("importMemory: entries must be a JSON array");
+  }
+  const stmt = db.prepare(
+    `INSERT INTO memory_entries
+       (id, content, category, importance, source, created_at, updated_at)
+     VALUES (@id, @content, @category, @importance, @source, @created_at, @updated_at)
+     ON CONFLICT(id) DO UPDATE SET
+       content = excluded.content,
+       category = excluded.category,
+       importance = excluded.importance,
+       source = excluded.source,
+       updated_at = excluded.updated_at`,
+  );
+  let imported = 0;
+  let failed = 0;
+  const errors = [];
+  for (const e of entries) {
+    try {
+      if (!e || !e.id || typeof e.content !== "string") {
+        throw new Error("invalid memory entry (need id + content)");
+      }
+      stmt.run({
+        id: String(e.id),
+        content: e.content,
+        category: e.category || "general",
+        importance: Number.isInteger(e.importance) ? e.importance : 3,
+        source: e.source || "user",
+        created_at: e.created_at || _nowSqlite(),
+        updated_at: e.updated_at || _nowSqlite(),
+      });
+      imported += 1;
+    } catch (err) {
+      failed += 1;
+      if (errors.length < 10) errors.push({ id: e && e.id, error: err.message });
+    }
+  }
+  return { ok: failed === 0, imported, failed, errors };
+}
+
 /**
  * Delete a memory entry
  */

package/src/lib/plan-mode.js

@@ -31,6 +31,7 @@ export const PlanState = {
   APPROVED: "approved",
   EXECUTING: "executing",
   COMPLETED: "completed",
+  FAILED: "failed",
   REJECTED: "rejected",
 };
 
@@ -499,10 +500,10 @@ export class PlanModeManager extends EventEmitter {
     });
 
     const allDone = results.every((r) => r.success);
-    this.state = allDone ? PlanState.COMPLETED : PlanState.COMPLETED;
+    this.state = allDone ? PlanState.COMPLETED : PlanState.FAILED;
     this.currentPlan.status = allDone
       ? PlanState.COMPLETED
-      : PlanState.COMPLETED;
+      : PlanState.FAILED;
 
     return { results, success: allDone };
   }

package/src/repl/__tests__/mcp-prompt.test.js

@@ -0,0 +1,155 @@
+"use strict";
+
+/**
+ * mcp-prompt tests (previously untested) — the pure core that surfaces MCP
+ * server prompts as `/mcp__<server>__<prompt>` slash commands. Covers
+ * parseMcpPromptCommand (server/name split incl. `__` in names, JSON-object args
+ * vs non-JSON tail, reject non-mcp / missing parts), renderPromptMessages
+ * (text + embedded resource text, ignore binary, single vs array content),
+ * expandMcpPrompt (parse -> getPrompt -> render, null for non-mcp, throw when no
+ * client) and renderMcpSurface (overview / empty / no-client). No I/O.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import {
+  parseMcpPromptCommand,
+  renderPromptMessages,
+  expandMcpPrompt,
+  renderMcpSurface,
+} from "../mcp-prompt.js";
+
+describe("parseMcpPromptCommand", () => {
+  it("returns null for non-mcp lines", () => {
+    expect(parseMcpPromptCommand("hello")).toBe(null);
+    expect(parseMcpPromptCommand("/other__a__b")).toBe(null);
+    expect(parseMcpPromptCommand("")).toBe(null);
+  });
+
+  it("parses server and prompt name with empty args", () => {
+    expect(parseMcpPromptCommand("/mcp__github__review")).toEqual({
+      server: "github",
+      name: "review",
+      args: {},
+    });
+  });
+
+  it("keeps '__' inside the prompt name", () => {
+    expect(parseMcpPromptCommand("/mcp__srv__deep__name").name).toBe(
+      "deep__name",
+    );
+  });
+
+  it("parses a trailing JSON object as args", () => {
+    expect(parseMcpPromptCommand('/mcp__s__p {"a":1,"b":"x"}').args).toEqual({
+      a: 1,
+      b: "x",
+    });
+  });
+
+  it("treats a non-JSON tail as { input: tail }", () => {
+    expect(parseMcpPromptCommand("/mcp__s__p just some text").args).toEqual({
+      input: "just some text",
+    });
+  });
+
+  it("treats a JSON array tail as { input } (not an object)", () => {
+    expect(parseMcpPromptCommand("/mcp__s__p [1,2]").args).toEqual({
+      input: "[1,2]",
+    });
+  });
+
+  it("returns null when server or prompt is missing", () => {
+    expect(parseMcpPromptCommand("/mcp__srv")).toBe(null); // < 3 parts
+    expect(parseMcpPromptCommand("/mcp____p")).toBe(null); // empty server
+  });
+});
+
+describe("renderPromptMessages", () => {
+  it("returns '' when there are no messages", () => {
+    expect(renderPromptMessages(null)).toBe("");
+    expect(renderPromptMessages({ messages: [] })).toBe("");
+  });
+
+  it("joins text blocks with blank lines", () => {
+    const r = renderPromptMessages({
+      messages: [
+        { content: [{ type: "text", text: "one" }] },
+        { content: [{ type: "text", text: "two" }] },
+      ],
+    });
+    expect(r).toBe("one\n\ntwo");
+  });
+
+  it("includes embedded resource text and ignores binary/unknown blocks", () => {
+    const r = renderPromptMessages({
+      messages: [
+        {
+          content: [
+            { type: "text", text: "T" },
+            { type: "resource", resource: { text: "R" } },
+            { type: "image", data: "..." },
+            null,
+          ],
+        },
+      ],
+    });
+    expect(r).toBe("T\n\nR");
+  });
+
+  it("handles content given as a single block (not an array)", () => {
+    const r = renderPromptMessages({
+      messages: [{ content: { type: "text", text: "solo" } }],
+    });
+    expect(r).toBe("solo");
+  });
+});
+
+describe("expandMcpPrompt", () => {
+  it("returns null for a non-mcp line", async () => {
+    expect(await expandMcpPrompt("hi", {})).toBe(null);
+  });
+
+  it("throws when no MCP client is connected", async () => {
+    await expect(expandMcpPrompt("/mcp__s__p", null)).rejects.toThrow(
+      /No MCP servers/,
+    );
+  });
+
+  it("calls getPrompt with parsed args and renders the result", async () => {
+    const getPrompt = vi.fn(async () => ({
+      messages: [{ content: [{ type: "text", text: "rendered" }] }],
+    }));
+    const out = await expandMcpPrompt('/mcp__s__p {"k":1}', { getPrompt });
+    expect(getPrompt).toHaveBeenCalledWith("s", "p", { k: 1 });
+    expect(out).toBe("rendered");
+  });
+});
+
+describe("renderMcpSurface", () => {
+  it("reports when no client is connected", () => {
+    expect(renderMcpSurface(null)).toMatch(/No MCP servers/);
+  });
+
+  it("lists resources and prompts with counts", () => {
+    const surface = renderMcpSurface({
+      listResources: () => [{ uri: "file://x", server: "fs", name: "X" }],
+      listPrompts: () => [
+        { server: "gh", name: "review", description: "code review" },
+      ],
+    });
+    expect(surface).toContain("MCP resources (1):");
+    expect(surface).toContain("file://x [fs] — X");
+    expect(surface).toContain("MCP prompts (1):");
+    expect(surface).toContain("/mcp__gh__review — code review");
+  });
+
+  it("notes when servers expose nothing", () => {
+    const surface = renderMcpSurface({
+      listResources: () => [],
+      listPrompts: () => [],
+    });
+    expect(surface).toContain(
+      "(connected servers expose no resources or prompts)",
+    );
+  });
+});

package/src/repl/__tests__/slash-macro.test.js

@@ -0,0 +1,81 @@
+"use strict";
+
+/**
+ * resolveSlashMacro tests (previously untested) — the REPL's user-command-macro
+ * wire (.claude/commands/*.md). The routing safety matters: a leading `/name`
+ * that resolves to a macro is expanded, but plain text or an unknown `/...`
+ * (e.g. asking about "/etc/hosts") must pass through verbatim to the LLM and
+ * never be swallowed. Deps (getCommand/expandCommand) are injected; no I/O.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { resolveSlashMacro } from "../slash-macro.js";
+
+const deps = (macro, expand = { prompt: "EXPANDED", warnings: [] }) => ({
+  getCommand: vi.fn(() => macro),
+  expandCommand: vi.fn(() => expand),
+});
+
+describe("resolveSlashMacro", () => {
+  it("returns plain text unchanged (no slash)", async () => {
+    const r = await resolveSlashMacro("  just a question  ", {
+      deps: deps(null),
+    });
+    expect(r.matched).toBe(false);
+    expect(r.promptText).toBe("just a question"); // trimmed
+  });
+
+  it("passes an unknown /... through verbatim (does not swallow /etc/hosts)", async () => {
+    const d = deps(null);
+    const r = await resolveSlashMacro("/etc/hosts is interesting", { deps: d });
+    expect(r.matched).toBe(false);
+    expect(r.promptText).toBe("/etc/hosts is interesting");
+    // first token after the slash was probed, but no macro matched
+    expect(d.getCommand).toHaveBeenCalledWith("etc/hosts", expect.any(String));
+  });
+
+  it("expands a resolved macro and reports its name/scope", async () => {
+    const macro = { name: "deploy", scope: "project" };
+    const d = deps(macro);
+    const r = await resolveSlashMacro("/deploy prod fast", {
+      deps: d,
+      cwd: "/proj",
+    });
+    expect(r.matched).toBe(true);
+    expect(r.promptText).toBe("EXPANDED");
+    expect(r.name).toBe("deploy");
+    expect(r.scope).toBe("project");
+    expect(d.getCommand).toHaveBeenCalledWith("deploy", "/proj");
+    expect(d.expandCommand).toHaveBeenCalledWith(macro, ["prod", "fast"], {
+      cwd: "/proj",
+    });
+  });
+
+  it("propagates warnings from expandCommand", async () => {
+    const d = deps(
+      { name: "x", scope: "personal" },
+      {
+        prompt: "P",
+        warnings: ["missing $2"],
+      },
+    );
+    const r = await resolveSlashMacro("/x a", { deps: d });
+    expect(r.warnings).toEqual(["missing $2"]);
+  });
+
+  it("does not treat a bare '/' as a command", async () => {
+    const d = deps({ name: "should-not-fire", scope: "project" });
+    const r = await resolveSlashMacro("/", { deps: d });
+    expect(r.matched).toBe(false);
+    expect(d.getCommand).not.toHaveBeenCalled(); // empty head → never probed
+  });
+
+  it("handles empty/nullish input", async () => {
+    expect((await resolveSlashMacro("", { deps: deps(null) })).matched).toBe(
+      false,
+    );
+    expect(
+      (await resolveSlashMacro(null, { deps: deps(null) })).promptText,
+    ).toBe("");
+  });
+});

package/src/runtime/__tests__/coding-agent-contract-shared.test.js

@@ -0,0 +1,136 @@
+"use strict";
+
+/**
+ * coding-agent-contract-shared tests (previously untested) — the single source
+ * of truth for the coding agent's tool surface (the function-calling contracts
+ * the LLM sees). Rather than hardcode the whole table, this pins the accessor
+ * contracts + cross-table invariants: every listed name resolves to a contract
+ * AND a function definition, lookups return defensive clones, unknown -> null,
+ * the OpenAI function-tool shape, names/tier filtering, MVP/extension membership
+ * and the policy projection. Anchored on the stable `read_file` tool. No I/O.
+ */
+
+import { describe, it, expect } from "vitest";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const {
+  CODING_AGENT_MVP_TOOL_NAMES,
+  CODING_AGENT_EXTENSION_TOOL_NAMES,
+  getCodingAgentFunctionToolDefinition,
+  getCodingAgentFunctionToolDefinitions,
+  getCodingAgentToolContract,
+  getCodingAgentToolContracts,
+  getCodingAgentToolPolicy,
+  isCodingAgentMvpTool,
+  listCodingAgentToolNames,
+} = require("../coding-agent-contract-shared.cjs");
+
+describe("listCodingAgentToolNames + consistency", () => {
+  it("returns a non-empty list of unique names including read_file", () => {
+    const names = listCodingAgentToolNames();
+    expect(names.length).toBeGreaterThan(0);
+    expect(new Set(names).size).toBe(names.length);
+    expect(names).toContain("read_file");
+  });
+
+  it("every listed name resolves to both a contract and a function definition", () => {
+    for (const n of listCodingAgentToolNames()) {
+      expect(getCodingAgentToolContract(n)).toBeTruthy();
+      expect(getCodingAgentFunctionToolDefinition(n)).toBeTruthy();
+    }
+  });
+});
+
+describe("getCodingAgentToolContract", () => {
+  it("returns the contract for a known tool", () => {
+    const c = getCodingAgentToolContract("read_file");
+    expect(c.name).toBe("read_file");
+    expect(c.tier).toBe("mvp");
+  });
+
+  it("returns null for an unknown tool", () => {
+    expect(getCodingAgentToolContract("__nope__")).toBe(null);
+  });
+
+  it("returns a defensive clone (mutation does not leak back)", () => {
+    const a = getCodingAgentToolContract("read_file");
+    a.name = "MUTATED";
+    expect(getCodingAgentToolContract("read_file").name).toBe("read_file");
+  });
+});
+
+describe("getCodingAgentFunctionToolDefinition", () => {
+  it("emits an OpenAI function-tool definition for a known tool", () => {
+    const def = getCodingAgentFunctionToolDefinition("read_file");
+    expect(def.type).toBe("function");
+    expect(def.function.name).toBe("read_file");
+    expect(typeof def.function.description).toBe("string");
+    expect(def.function.parameters.type).toBe("object");
+    expect(def.function.parameters.required).toContain("path");
+  });
+
+  it("returns null for an unknown tool", () => {
+    expect(getCodingAgentFunctionToolDefinition("__nope__")).toBe(null);
+  });
+});
+
+describe("getCodingAgentFunctionToolDefinitions filtering", () => {
+  it("filters by an explicit names allow-list", () => {
+    const defs = getCodingAgentFunctionToolDefinitions({
+      names: ["read_file"],
+    });
+    expect(defs).toHaveLength(1);
+    expect(defs[0].function.name).toBe("read_file");
+  });
+
+  it("treats an empty names array as no filter (returns all)", () => {
+    const all = getCodingAgentFunctionToolDefinitions();
+    expect(getCodingAgentFunctionToolDefinitions({ names: [] })).toHaveLength(
+      all.length,
+    );
+  });
+
+  it("returns [] for unknown names", () => {
+    expect(
+      getCodingAgentFunctionToolDefinitions({ names: ["__nope__"] }),
+    ).toHaveLength(0);
+  });
+});
+
+describe("tier filtering", () => {
+  it("getCodingAgentToolContracts({tier}) returns only that tier", () => {
+    const mvp = getCodingAgentToolContracts({ tier: "mvp" });
+    expect(mvp.length).toBeGreaterThan(0);
+    expect(mvp.every((t) => t.tier === "mvp")).toBe(true);
+  });
+});
+
+describe("isCodingAgentMvpTool + membership", () => {
+  it("is true for every MVP name and false for unknown", () => {
+    for (const n of CODING_AGENT_MVP_TOOL_NAMES)
+      expect(isCodingAgentMvpTool(n)).toBe(true);
+    expect(isCodingAgentMvpTool("__nope__")).toBe(false);
+  });
+
+  it("MVP and extension names are all valid tool names", () => {
+    const all = new Set(listCodingAgentToolNames());
+    for (const n of CODING_AGENT_MVP_TOOL_NAMES) expect(all.has(n)).toBe(true);
+    for (const n of CODING_AGENT_EXTENSION_TOOL_NAMES)
+      expect(all.has(n)).toBe(true);
+  });
+});
+
+describe("getCodingAgentToolPolicy", () => {
+  it("projects the policy fields for a known tool", () => {
+    const p = getCodingAgentToolPolicy("read_file");
+    expect(p).toHaveProperty("tier");
+    expect(p).toHaveProperty("riskLevel");
+    expect(p).toHaveProperty("permissions");
+    expect(typeof p.planModeBehavior).toBe("string"); // defaults to "standard"
+  });
+
+  it("returns null for an unknown tool", () => {
+    expect(getCodingAgentToolPolicy("__nope__")).toBe(null);
+  });
+});