@selesai/code 0.13.7 → 0.13.9

package/dist/skills/unlazy/tests/run-tests.mjs

@@ -16,8 +16,6 @@ import { fileURLToPath } from "node:url";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const GATE_CHECK = join(HERE, "..", "scripts", "gate-check.mjs");
-const STOP_HOOK = join(HERE, "..", "scripts", "stop-hook.mjs");
-const INSTALL = join(HERE, "..", "scripts", "install-hooks.mjs");
 const filter = process.argv[2] || "";
 const APPROVAL_ROOT = mkdtempSync(join(tmpdir(), "unlazy-test-approvals-"));
 
@@ -43,7 +41,7 @@ function sandbox() {
 
 function run(script, args, opts = {}) {
   return new Promise((res) => {
-    const actions = new Set(["--status", "--claim", "--release", "--list-scopes", "--log", "--bind", "--help", "-h"]);
+    const actions = new Set(["--status", "--claim", "--release", "--list-scopes", "--log", "--help", "-h"]);
     const needsApproval = script === GATE_CHECK && !opts.noApprove && !args.some((arg) => actions.has(arg));
     const actualArgs = needsApproval && !args.includes("--approve") ? ["--approve", ...args] : args;
     const child = execFile(process.execPath, [script, ...actualArgs], {
@@ -338,198 +336,6 @@ test("status log: appends, and appends survive concurrency", async () => {
   } finally { s.cleanup(); }
 });
 
-test("hook: does not block on a pipeline this session does not own", async () => {
-  const s = sandbox();
-  try {
-    // api is finished; web has never been started. Ending the api session must
-    // not be blocked by web's gates.
-    s.write(".unlazy/api/gates/leaf-1.md", "# Gates\n\n- [x] G1: done\n  EVIDENCE: measured, 8/8 passed\n");
-    s.write(".unlazy/web/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "not started", null, null));
-    const r = await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir }) });
-    assertLacks(r.out, '"decision":"block"', "hook");
-    assert(r.code === 0, "hook should exit 0");
-  } finally { s.cleanup(); }
-});
-
-test("hook: blocks on its own scope, naming qualified ids", async () => {
-  const s = sandbox();
-  try {
-    s.write(".unlazy/api/gates/leaf-7.md", "# Gates\n\n" + gate("G3", "unfinished", null, null));
-    s.write(".unlazy/web/gates/leaf-1.md", "# Gates\n\n- [x] G1: done\n  EVIDENCE: proven\n");
-    const r = await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir }) });
-    assertHas(r.out, '"decision":"block"');
-    assertHas(r.out, "leaf-7:G3");
-    assertHas(r.out, "[scope api]");
-  } finally { s.cleanup(); }
-});
-
-test("hook: abandonment allows Stop but reports an explicit bounded handoff", async () => {
-  const s = sandbox();
-  try {
-    s.write(".unlazy/api/gates/leaf-7.md", [
-      "# Gates",
-      "",
-      "- [ ] G3: impossible",
-      "  EVIDENCE: pending",
-      "",
-      "ABANDON: G3 secret-looking reason that must stay ledger-local",
-      "",
-    ].join("\n"));
-    const r = await run(STOP_HOOK, ["--scope", "api"], {
-      cwd: s.dir,
-      stdin: JSON.stringify({ cwd: s.dir, session_id: "handoff-test" }),
-    });
-    assertLacks(r.out, '"decision":"block"');
-    assertHas(r.out, "HANDOFF REQUIRED");
-    assertHas(r.out, "leaf-7:G3");
-    assertLacks(r.out, "secret-looking reason");
-  } finally { s.cleanup(); }
-});
-
-test("hook: unresolvable scope allows the stop instead of blocking blindly", async () => {
-  const s = sandbox();
-  try {
-    s.write(".unlazy/api/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "a", null, null));
-    s.write(".unlazy/web/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "b", null, null));
-    const r = await run(STOP_HOOK, [], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir }) });
-    assertLacks(r.out, '"decision":"block"', "hook");
-    assertHas(r.out, "2 pipelines");
-  } finally { s.cleanup(); }
-});
-
-test("hook: session binding resolves the scope among several", async () => {
-  const s = sandbox();
-  try {
-    s.write(".unlazy/api/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "a", null, null));
-    s.write(".unlazy/web/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "b", null, null));
-    const bind = await run(GATE_CHECK, ["--scope", "web", "--bind", "sess-abc"], { cwd: s.dir });
-    assertHas(bind.out, "bound session sess-abc to scope web");
-    const r = await run(STOP_HOOK, [], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir, session_id: "sess-abc" }) });
-    assertHas(r.out, '"decision":"block"');
-    assertHas(r.out, "[scope web]");
-  } finally { s.cleanup(); }
-});
-
-test("hook: each pipeline keeps its own loop-guard counter", async () => {
-  const s = sandbox();
-  try {
-    s.write(".unlazy/api/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "a", null, null));
-    s.write(".unlazy/web/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "b", null, null));
-    const stdin = JSON.stringify({ cwd: s.dir });
-    for (let i = 0; i < 7; i++) await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin });
-    const apiState = JSON.parse(s.read(".unlazy/api/hook-state.json"));
-    const apiSession = Object.values(apiState.sessions)[0];
-    assert(apiSession.blocks === 7, "api counter should be 7, got " + apiSession.blocks);
-    // api has exhausted its guard and now releases; web is untouched and still blocks.
-    const apiNow = await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin });
-    assertHas(apiNow.out, "releasing after 6 blocks");
-    const webNow = await run(STOP_HOOK, ["--scope", "web"], { cwd: s.dir, stdin });
-    assertHas(webNow.out, '"decision":"block"');
-  } finally { s.cleanup(); }
-});
-
-test("hook: the loop guard tracks gate state, not file bytes", async () => {
-  const s = sandbox();
-  try {
-    // A cosmetic edit is not progress. Keying the guard to raw bytes let any
-    // touch of the ledger reset the counter, so an agent that keeps editing
-    // without meeting a gate is never released. Re-running the checker did the
-    // same thing by rewriting evidence text.
-    s.write(".unlazy/api/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "a", null, null) + gate("G2", "b", null, null));
-    const stdin = JSON.stringify({ cwd: s.dir });
-    for (let i = 0; i < 6; i++) {
-      const blocked = await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin });
-      assertHas(blocked.out, '"decision":"block"');
-    }
-    s.write(".unlazy/api/gates/leaf-1.md",
-      s.read(".unlazy/api/gates/leaf-1.md") + "\n<!-- still thinking about it -->\n");
-    const afterCosmetic = await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin });
-    assertHas(afterCosmetic.out, "releasing after 6 blocks");
-  } finally { s.cleanup(); }
-});
-
-test("hook: meeting a gate resets the loop guard", async () => {
-  const s = sandbox();
-  try {
-    // The converse of the test above: real progress must still rearm the guard,
-    // or a long run would be released while it is genuinely advancing.
-    s.write(".unlazy/api/gates/leaf-1.md", "# Gates\n\n" + gate("G1", "a", null, null) + gate("G2", "b", null, null));
-    const stdin = JSON.stringify({ cwd: s.dir });
-    for (let i = 0; i < 3; i++) await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin });
-    s.write(".unlazy/api/gates/leaf-1.md",
-      "# Gates\n\n- [x] G1: a\n  EVIDENCE: measured 3 of 3\n\n" + gate("G2", "b", null, null));
-    for (let i = 0; i < 4; i++) {
-      const blocked = await run(STOP_HOOK, ["--scope", "api"], { cwd: s.dir, stdin });
-      assertHas(blocked.out, '"decision":"block"');
-    }
-  } finally { s.cleanup(); }
-});
-
-test("hook: no gate files anywhere means silence", async () => {
-  const s = sandbox();
-  try {
-    const r = await run(STOP_HOOK, [], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir }) });
-    assert(r.out.trim() === "", "expected no output, got: " + r.out);
-    assert(r.code === 0, "expected exit 0");
-  } finally { s.cleanup(); }
-});
-
-test("install: repeated install stays a single Stop entry", async () => {
-  const s = sandbox();
-  try {
-    await run(INSTALL, ["--scope", "api"], { cwd: s.dir });
-    await run(INSTALL, ["--scope", "api"], { cwd: s.dir });
-    const cfg = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(cfg.hooks.Stop.length === 1, "expected 1 Stop entry, got " + cfg.hooks.Stop.length);
-    assertHas(cfg.hooks.Stop[0].hooks[0].command, "--scope api", "hook command");
-  } finally { s.cleanup(); }
-});
-
-test("install: changing the scope replaces the entry instead of stacking", async () => {
-  const s = sandbox();
-  try {
-    await run(INSTALL, ["--scope", "api"], { cwd: s.dir });
-    await run(INSTALL, ["--scope", "web"], { cwd: s.dir });
-    const cfg = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(cfg.hooks.Stop.length === 1, "expected 1 Stop entry, got " + cfg.hooks.Stop.length);
-    assertHas(cfg.hooks.Stop[0].hooks[0].command, "--scope web", "hook command");
-  } finally { s.cleanup(); }
-});
-
-test("install: uninstall removes our entry and leaves others alone", async () => {
-  const s = sandbox();
-  try {
-    s.write(".claude/settings.local.json", JSON.stringify({
-      hooks: { Stop: [{ hooks: [{ type: "command", command: "node other-tool.mjs" }] }] },
-    }, null, 2));
-    await run(INSTALL, ["--scope", "api"], { cwd: s.dir });
-    const r = await run(INSTALL, ["--uninstall"], { cwd: s.dir });
-    assertHas(r.out, "Removed unlazy Stop hook");
-    const cfg = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(cfg.hooks.Stop.length === 1, "expected the unrelated hook to remain");
-    assertHas(cfg.hooks.Stop[0].hooks[0].command, "other-tool.mjs", "unrelated hook");
-  } finally { s.cleanup(); }
-});
-
-test("install: an upstream v2.0 entry is still recognised and removable", async () => {
-  const s = sandbox();
-  try {
-    s.write(".claude/settings.local.json", JSON.stringify({
-      hooks: {
-        Stop: [{
-          hooks: [{
-            type: "command",
-            command: 'node "/home/me/.claude/skills/unlazy/scripts/stop-hook.mjs"',
-          }],
-        }],
-      },
-    }, null, 2));
-    const r = await run(INSTALL, ["--uninstall"], { cwd: s.dir });
-    assertHas(r.out, "Removed unlazy Stop hook");
-    const cfg = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(!cfg.hooks, "settings should be left clean, got " + JSON.stringify(cfg));
-  } finally { s.cleanup(); }
-});
 
 // ---------------------------------------------------------------- driver
 

package/dist/skills/unlazy/tests/self-check.mjs

@@ -19,8 +19,6 @@ const SCRIPTS = [
   "scripts/gate-check.mjs",
   "scripts/gate-lint.mjs",
   "scripts/dispatch-check.mjs",
-  "scripts/stop-hook.mjs",
-  "scripts/install-hooks.mjs",
   "scripts/lib/gates.mjs",
   "scripts/lib/dispatch.mjs",
   "scripts/lib/check-supervisor.mjs",
@@ -93,13 +91,6 @@ check("approval identity binds execution semantics", () => {
   return missing.length ? "approval oracle missing source tokens: " + missing.join(", ") : null;
 });
 
-check("the hook resolves a scope rather than globbing the tree", () => {
-  const src = read("scripts/stop-hook.mjs");
-  if (!src.includes("resolveTarget")) return "stop-hook.mjs does not resolve a scope";
-  if (!src.includes("hookStatePath")) return "stop-hook.mjs does not use a per-scope state path";
-  return null;
-});
-
 check("every local resource the skill names exists", () => {
   const skill = read("SKILL.md");
   const missing = [];
@@ -138,13 +129,9 @@ check("request reconciliation keeps the focused solo cheap path", () => {
 
 check("abandonment is terminal handoff rather than ALL MET", () => {
   const checker = read("scripts/gate-check.mjs");
-  const hook = read("scripts/stop-hook.mjs");
   if (!checker.includes("HANDOFF REQUIRED") || !checker.includes("totalAbandoned === 0")) {
     return "gate checker can still classify abandonment as completion";
   }
-  if (!hook.includes("HANDOFF REQUIRED") || !hook.includes("handoffs")) {
-    return "Stop hook does not surface bounded abandonment handoff";
-  }
   return null;
 });
 

package/dist/skills/unlazy/tests/stress-tests.mjs

@@ -13,8 +13,6 @@ import { claimLeases, releaseLeases, writeAtomic } from "../scripts/lib/gates.mj
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const GATE_CHECK = join(HERE, "..", "scripts", "gate-check.mjs");
-const STOP_HOOK = join(HERE, "..", "scripts", "stop-hook.mjs");
-const INSTALL = join(HERE, "..", "scripts", "install-hooks.mjs");
 const tests = [];
 const test = (name, fn) => tests.push({ name, fn });
 
@@ -107,57 +105,6 @@ test("leases: an explicit release cleans orphaned leases after a scope directory
   } finally { s.cleanup(); }
 });
 
-test("hook: repeated 64-writer bursts are serialized without lost increments", async () => {
-  const s = sandbox();
-  try {
-    s.write("GATES.md", "- [ ] G1: pending\n  EVIDENCE: pending\n");
-    const payload = JSON.stringify({ cwd: s.dir, session_id: "one-session" });
-    for (let round = 1; round <= 3; round++) {
-      rmSync(s.path(".unlazy-hook-state.json"), { force: true });
-      const results = await Promise.all(Array.from({ length: 64 }, () =>
-        run(STOP_HOOK, [], { cwd: s.dir, stdin: payload })));
-      const crashed = results.filter((result) => result.code !== 0);
-      assert(crashed.length === 0,
-        "round " + round + ": " + crashed.length + " hook process(es) failed\n" +
-        [...new Set(crashed.map((result) => "exit=" + result.code + "\n" + result.out.trim()))]
-          .slice(0, 4).join("\n---\n"));
-      const failedUpdates = results
-        .filter((result) => result.out.includes("could not update the serialized hook state"))
-        .map((result) => result.out.trim());
-      assert(failedUpdates.length === 0,
-        "round " + round + ": " + failedUpdates.length + " hook(s) failed open on the state update\n" +
-        [...new Set(failedUpdates)].slice(0, 4).join("\n---\n"));
-      const state = JSON.parse(s.read(".unlazy-hook-state.json"));
-      const sessions = Object.values(state.sessions);
-      assert(sessions.length === 1, "round " + round + ": expected one session, got " + sessions.length);
-      assert(sessions[0].blocks === 64, "round " + round + ": expected 64 blocks, got " + sessions[0].blocks);
-    }
-  } finally { s.cleanup(); }
-});
-
-test("hook: sessions remain isolated and completion/no-gates clears stale state", async () => {
-  const s = sandbox();
-  try {
-    s.write("GATES.md", "- [ ] G1: pending\n  EVIDENCE: pending\n");
-    for (const id of ["alpha", "beta"]) {
-      const payload = JSON.stringify({ cwd: s.dir, session_id: id });
-      await Promise.all(Array.from({ length: 3 }, () => run(STOP_HOOK, [], { cwd: s.dir, stdin: payload })));
-    }
-    let state = JSON.parse(s.read(".unlazy-hook-state.json"));
-    assert(Object.keys(state.sessions).length === 2, "sessions were mixed: " + JSON.stringify(state));
-    assert(Object.values(state.sessions).every((value) => value.blocks === 3), "session counters were not isolated");
-
-    s.write("GATES.md", "- [x] G1: done\n  EVIDENCE: measured\n");
-    await run(STOP_HOOK, [], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir, session_id: "alpha" }) });
-    state = JSON.parse(s.read(".unlazy-hook-state.json"));
-    assert(Object.keys(state.sessions).length === 1, "completed alpha state was not cleared");
-
-    rmSync(s.path("GATES.md"));
-    await run(STOP_HOOK, [], { cwd: s.dir, stdin: JSON.stringify({ cwd: s.dir, session_id: "beta" }) });
-    assert(!existsSync(s.path(".unlazy-hook-state.json")), "no-gates path did not clear final state");
-  } finally { s.cleanup(); }
-});
-
 test("atomic writer: predictable pre-created temp links are never followed", async () => {
   if (process.platform === "win32") return;
   const s = sandbox();
@@ -216,141 +163,3 @@ test("status log: a FIFO is rejected without blocking the logger", async () => {
     has(result.out, "cannot append status");
   } finally { s.cleanup(); }
 });
-
-test("installer: malformed settings shapes are refused without mutation", async () => {
-  const fixtures = [
-    "[]\n",
-    JSON.stringify({ hooks: [] }, null, 2) + "\n",
-    JSON.stringify({ hooks: { Stop: {} } }, null, 2) + "\n",
-    JSON.stringify({ hooks: { Stop: [{ hooks: {} }] } }, null, 2) + "\n",
-    JSON.stringify({ hooks: { Stop: [{ hooks: [null] }] } }, null, 2) + "\n",
-  ];
-  for (const fixture of fixtures) {
-    const s = sandbox();
-    try {
-      s.write(".claude/settings.local.json", fixture);
-      const result = await run(INSTALL, [], { cwd: s.dir });
-      assert(result.code === 1, "invalid shape should fail\n" + result.out);
-      assert(s.read(".claude/settings.local.json") === fixture, "invalid settings were mutated");
-    } finally { s.cleanup(); }
-  }
-});
-
-test("installer: a FIFO settings target is rejected without blocking", async () => {
-  if (process.platform === "win32") return;
-  const s = sandbox();
-  try {
-    mkdirSync(s.path(".claude"), { recursive: true });
-    const target = s.path(".claude/settings.local.json");
-    const made = spawnSync("mkfifo", [target], { encoding: "utf8" });
-    assert(made.status === 0, "could not create FIFO fixture: " + made.stderr);
-    const started = Date.now();
-    const result = await run(INSTALL, [], { cwd: s.dir, timeoutMs: 2000 });
-    assert(result.code === 1, "FIFO installer target did not fail closed\n" + result.out);
-    assert(Date.now() - started < 1800, "FIFO installer validation blocked");
-    has(result.out, "Refusing to touch");
-  } finally { s.cleanup(); }
-});
-
-test("installer: uninstall preserves a sibling in the same matcher group and writes a backup", async () => {
-  const s = sandbox();
-  try {
-    const original = JSON.stringify({
-      hooks: {
-        Stop: [{
-          matcher: "",
-          hooks: [
-            { type: "command", command: "node other-tool.mjs" },
-            { type: "command", command: "node /tmp/unlazy/scripts/stop-hook.mjs --unlazy" },
-          ],
-        }],
-      },
-    }, null, 2) + "\n";
-    s.write(".claude/settings.local.json", original);
-    const result = await run(INSTALL, ["--uninstall"], { cwd: s.dir });
-    assert(result.code === 0, result.out);
-    const after = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(after.hooks.Stop.length === 1, "matcher group was removed");
-    assert(after.hooks.Stop[0].matcher === "", "matcher metadata was lost");
-    assert(after.hooks.Stop[0].hooks.length === 1, "wrong handler count");
-    has(after.hooks.Stop[0].hooks[0].command, "other-tool.mjs");
-    assert(s.read(".claude/settings.local.json.unlazy.bak") === original, "backup did not preserve original bytes");
-  } finally { s.cleanup(); }
-});
-
-test("installer: marker substrings do not claim an unrelated stop hook", async () => {
-  const s = sandbox();
-  try {
-    const unrelated = [
-      "node /opt/other/stop-hook.mjs --unlazy-helper",
-      "node /opt/unlazy/scripts/stop-hook.mjs --unlazy-helper",
-      "node " + JSON.stringify(STOP_HOOK) + " --unlazy-helper",
-      "node " + JSON.stringify(STOP_HOOK) + " \"--unlazy-helper\"",
-    ];
-    s.write(".claude/settings.local.json", JSON.stringify({
-      hooks: { Stop: [{ hooks: unrelated.map((command) => ({ type: "command", command, timeout: 20 })) }] },
-    }, null, 2) + "\n");
-    const result = await run(INSTALL, ["--uninstall"], { cwd: s.dir });
-    assert(result.code === 0, result.out);
-    has(result.out, "Nothing to remove");
-    const after = JSON.parse(s.read(".claude/settings.local.json"));
-    assert(after.hooks.Stop[0].hooks.map((hook) => hook.command).join("\n") === unrelated.join("\n"),
-      "unrelated hook was removed");
-  } finally { s.cleanup(); }
-});
-
-test("installer: a matching command with broken managed fields is repaired", async () => {
-  const s = sandbox();
-  try {
-    const installed = await run(INSTALL, [], { cwd: s.dir });
-    assert(installed.code === 0, installed.out);
-    const settings = JSON.parse(s.read(".claude/settings.local.json"));
-    const handler = settings.hooks.Stop[0].hooks[0];
-    handler.type = "prompt";
-    handler.timeout = 1;
-    s.write(".claude/settings.local.json", JSON.stringify(settings, null, 2) + "\n");
-    const repaired = await run(INSTALL, [], { cwd: s.dir });
-    assert(repaired.code === 0, repaired.out);
-    assert(!repaired.out.includes("Already installed"), "broken handler was treated as current");
-    const after = JSON.parse(s.read(".claude/settings.local.json"));
-    const managed = after.hooks.Stop.flatMap((group) => group.hooks)
-      .filter((item) => typeof item.command === "string" && item.command.includes("--unlazy"));
-    assert(managed.length === 1, "repair did not leave exactly one managed handler");
-    assert(managed[0].type === "command", "repair did not restore command type");
-    assert(managed[0].timeout === 20, "repair did not restore timeout");
-  } finally { s.cleanup(); }
-});
-
-test("installer: scope input is validated and local state warning is explicit", async () => {
-  const s = sandbox();
-  try {
-    const invalid = await run(INSTALL, ["--scope", "bad;echo"], { cwd: s.dir });
-    assert(invalid.code === 2, invalid.out);
-    assert(!existsSync(s.path(".claude/settings.local.json")), "invalid scope wrote settings");
-    const good = await run(INSTALL, ["--scope", "api"], { cwd: s.dir });
-    assert(good.code === 0, good.out);
-    has(good.out, ".unlazy/");
-    has(good.out, ".unlazy-hook-state.json");
-    const settings = JSON.parse(s.read(".claude/settings.local.json"));
-    const command = settings.hooks.Stop[0].hooks[0].command;
-    has(command, "--scope api");
-  } finally { s.cleanup(); }
-});
-
-let passed = 0;
-const failures = [];
-for (const item of tests) {
-  try {
-    await item.fn();
-    passed++;
-    console.log("ok   " + item.name);
-  } catch (error) {
-    failures.push(item.name);
-    console.log("FAIL " + item.name + "\n     " + String(error.message).replace(/\n/g, "\n     "));
-  }
-}
-console.log("\n" + passed + "/" + tests.length + " passed");
-if (failures.length) {
-  console.log("failed: " + failures.join(", "));
-  process.exit(1);
-}

package/docs/rpc.md

@@ -740,7 +740,7 @@ Each command has:
   - `"path"`: Explicit path via CLI or settings
 - `path`: Absolute file path to the command source (optional)
 
-**Note**: Built-in TUI commands (`/settings`, `/hotkeys`, etc.) are not included. They are handled only in interactive mode and would not execute if sent via `prompt`.
+**Note**: Built-in TUI commands (`/settings`, `/hotkeys`, etc.) are included with `source: "builtin"` and `interactiveOnly: true`. They are display-only: they are handled only in interactive mode and would not execute if sent via `prompt`.
 
 ## Events
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.7",
+  "version": "0.13.9",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {