@inetafrica/open-claudia 2.6.47 → 2.6.49

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v2.6.49
+- **Reusable tools + a directed tool-usage graph.** Two linked features. First, **reusable tools** (`core/tools.js`, `bin/tool.js`): the executable sibling of context packs — when the agent works out an operational procedure (hit an API, drive an interface, transform a file) it crystallises the script into a re-runnable command instead of a throwaway heredoc. Tools are one executable file with a parseable comment header, run pre-authed (the operational keyring is merged into their env so they reference `$NAME` and never hardcode a secret), can link to an owning skill pack, and are surfaced every turn as an always-on index (full docs/source on demand via `open-claudia tool show <name>`). Full CLI: `open-claudia tool list|show|add|run|remove`; `/learn` now crystallises the executable part too. Second, a **directed tool-graph** (`core/tool-graph.js`): a "tool B follows tool A" graph kept deliberately separate from the recall graph — for tools the useful signal is the *order* a chain runs in (auth → list → download), so edges are stored and traversed directionally. Each run-sequence reinforces consecutive pairs (Hebbian, decayed nightly, no structural floor so unused chains prune away). `tool show` and the system-prompt index surface "usually followed by …"; `pack show` gains the reverse view (a pack's linked tools); the nightly dream tends the graph (decay + orphan prune) and flags tools whose `--pack` link dangles. Adds `test-tools.js` + `test-tool-graph.js`.
+
 ## v2.6.43
 - **Fix the `🧠 Recall this turn` banner rendering raw HTML.** The recall debug banner (from `/recall on`) is built with `<b>` tags and HTML-escaped names, but its two `send()` calls in `runner.js` omitted the Telegram `parseMode: "HTML"` opts that every normal reply already passes via `telegramHtmlOpts()` — so the tags and `&amp;` entities showed up literally in chat instead of rendering. Both recall sends now pass `telegramHtmlOpts()`, matching the rest of the reply path. Display-only; no change to recall behaviour itself.
 

package/bin/cli.js

@@ -284,6 +284,11 @@ switch (command) {
     break;
   }
 
+  case "tool": {
+    require("./tool").run(args.slice(1));
+    break;
+  }
+
   case "entity": {
     require("./entity").run(args.slice(1));
     break;
@@ -365,6 +370,7 @@ Memory tools:
   open-claudia transcript-window <pattern>   Search project transcript, show hits with context
                                              (alias: tw; --help for options)
   open-claudia pack list|show|match|archive|restore|archived  Context packs: living topic docs (skills + memory)
+  open-claudia tool list|show|add|run|remove Reusable tools: executable scripts the agent saves & re-runs (keyring preauth)
   open-claudia entity list|show|match|note   Entity notes: people/places/projects memory
   open-claudia lessons list|add|remove|show  Always-loaded learned rules (cross-cutting, promoted after a miss)
   open-claudia ideas list|add|remove|show    Self-improvement backlog (captured by the nightly dream)

package/bin/pack.js

@@ -102,6 +102,16 @@ function run(args) {
       const prov = packs.readProvenance(p.dir);
       const authored = packs.SECTIONS.map((s) => `${s}=${prov.sections[s] || "user"}`).join("  ");
       console.log(`\n# provenance: ${authored}${prov.lastWriter ? `  (last: ${prov.lastWriter} ${prov.ts})` : ""}`);
+      // Reverse view: the runnable siblings of this pack's prose. A pack's
+      // Procedure documents *how*; a linked tool *is* the how. Surfacing them
+      // here keeps the doc and its crystallised commands discoverable together.
+      try {
+        const linked = require("../core/tools").listTools().filter((t) => t.pack === p.dir);
+        if (linked.length) {
+          console.log(`\n# tools (${linked.length}) — run with 'open-claudia tool run <name>':`);
+          for (const t of linked) console.log(`#   ${t.name} — ${t.description || "(no description)"}`);
+        }
+      } catch (e) { /* tools optional */ }
       break;
     }
 

package/bin/tool.js

@@ -0,0 +1,148 @@
+// CLI: manage and run reusable tools — executable scripts the agent saves so a
+// procedure it worked out once becomes a re-runnable command, not a re-typed
+// heredoc. The executable sibling of context packs (`open-claudia pack`).
+//
+//   open-claudia tool list                       — index (name — description [skill])
+//   open-claudia tool show <name>                — full docs, path, keyring status
+//   open-claudia tool add <path> [--name n]      — register a script as a tool
+//       [--pack <dir>] [--desc "..."] [--requires "k1,k2"] [--usage "..."]
+//   open-claudia tool run <name> [args...]       — run it with keyring pre-loaded
+//   open-claudia tool remove <name>              — delete one
+//   open-claudia tool path                       — print the tools directory
+//
+// Credentials: a tool runs with the operational keyring merged into its env, so
+// reference creds as $NAME inside the script. `open-claudia keyring list` shows
+// what's available; never hardcode secrets in a tool.
+
+const { spawnSync } = require("child_process");
+const tools = require("../core/tools");
+
+// Minimal flag parser: pulls --key value (and --key=value) out of argv, returns
+// { positional, flags }.
+function parseFlags(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq >= 0) { flags[a.slice(2, eq)] = a.slice(eq + 1); }
+      else { flags[a.slice(2)] = argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[++i] : true; }
+    } else positional.push(a);
+  }
+  return { positional, flags };
+}
+
+function run(args) {
+  const cmd = (args[0] || "list").toLowerCase();
+  const rest = args.slice(1);
+
+  switch (cmd) {
+    case "list":
+    case "ls": {
+      const all = tools.listTools();
+      if (all.length === 0) {
+        return console.log(`No tools yet (${tools.TOOLS_DIR}).\nSave one with: open-claudia tool add <script-path> --pack <skill>`);
+      }
+      console.log(`${all.length} reusable tool(s) — run via 'open-claudia tool run <name>':\n`);
+      for (const t of all) {
+        const skill = t.pack ? `  [skill: ${t.pack}]` : "";
+        console.log(`• ${t.name} — ${t.description || "(no description)"}${skill}`);
+      }
+      console.log(`\nDocs: open-claudia tool show <name>   ·   Dir: ${tools.TOOLS_DIR}`);
+      break;
+    }
+
+    case "show":
+    case "cat": {
+      const name = rest[0];
+      if (!name) { console.error("Usage: tool show <name>"); process.exitCode = 1; return; }
+      const t = tools.findTool(name);
+      if (!t) { console.error(`No tool named "${name}". Run: open-claudia tool list`); process.exitCode = 1; return; }
+      console.log(`Tool: ${t.name}`);
+      if (t.description) console.log(`Description: ${t.description}`);
+      if (t.pack) console.log(`Skill pack: ${t.pack}  (open-claudia pack show ${t.pack})`);
+      console.log(`Usage: open-claudia tool run ${t.name}${t.usage ? "   (" + t.usage + ")" : ""}`);
+      if (t.requires.length) {
+        const missing = tools.missingRequires(t);
+        const status = missing.length ? `MISSING: ${missing.join(", ")} — set with 'open-claudia keyring set'` : "all present in keyring";
+        console.log(`Requires keyring keys: ${t.requires.join(", ")}  (${status})`);
+      }
+      console.log(`File: ${t.file}${t.executable ? "" : "  (not executable!)"}`);
+      // Directed tool-graph: what tends to run right after / before this one.
+      try {
+        const graph = require("../core/tool-graph");
+        const fmt = (rows) => rows.map((r) => `${r.name} (${r.weight.toFixed(1)})`).join(", ");
+        const after = graph.followers(t.name);
+        const before = graph.predecessors(t.name);
+        if (after.length) console.log(`Often followed by: ${fmt(after)}`);
+        if (before.length) console.log(`Often preceded by: ${fmt(before)}`);
+      } catch (e) { /* graph optional (old node) */ }
+      console.log(`\n----- source -----\n${t.content}`);
+      break;
+    }
+
+    case "add":
+    case "save": {
+      const { positional, flags } = parseFlags(rest);
+      const srcPath = positional[0];
+      if (!srcPath) {
+        console.error('Usage: tool add <path> [--name n] [--pack dir] [--desc "..."] [--requires "k1,k2"] [--usage "..."]');
+        process.exitCode = 1; return;
+      }
+      try {
+        const t = tools.addTool(srcPath, {
+          name: typeof flags.name === "string" ? flags.name : undefined,
+          pack: typeof flags.pack === "string" ? flags.pack : undefined,
+          description: typeof flags.desc === "string" ? flags.desc : (typeof flags.description === "string" ? flags.description : undefined),
+          requires: typeof flags.requires === "string" ? flags.requires.split(/[,\s]+/).filter(Boolean) : undefined,
+          usage: typeof flags.usage === "string" ? flags.usage : undefined,
+        });
+        console.log(`Saved tool "${t.name}"${t.pack ? ` (skill: ${t.pack})` : ""}.`);
+        console.log(`Run it: open-claudia tool run ${t.name}`);
+        if (t.requires.length) {
+          const missing = tools.missingRequires(t);
+          if (missing.length) console.log(`Note: missing keyring keys it needs: ${missing.join(", ")}`);
+        }
+      } catch (e) {
+        console.error(`Could not add tool: ${e.message}`); process.exitCode = 1;
+      }
+      break;
+    }
+
+    case "run":
+    case "exec": {
+      const name = rest[0];
+      if (!name) { console.error("Usage: tool run <name> [args...]"); process.exitCode = 1; return; }
+      const t = tools.findTool(name);
+      if (!t) { console.error(`No tool named "${name}". Run: open-claudia tool list`); process.exitCode = 1; return; }
+      const missing = tools.missingRequires(t);
+      if (missing.length) {
+        console.error(`Cannot run ${t.name}: missing keyring keys ${missing.join(", ")}. Set them with 'open-claudia keyring set <name> <value>'.`);
+        process.exitCode = 1; return;
+      }
+      const r = spawnSync(t.file, rest.slice(1), { stdio: "inherit", env: tools.runEnv() });
+      if (r.error) { console.error(`Failed to run ${t.name}: ${r.error.message}`); process.exitCode = 1; return; }
+      process.exitCode = typeof r.status === "number" ? r.status : 1;
+      break;
+    }
+
+    case "remove":
+    case "rm": {
+      const name = rest[0];
+      if (!name) { console.error("Usage: tool remove <name>"); process.exitCode = 1; return; }
+      const removed = tools.removeTool(name);
+      console.log(removed ? `Removed tool "${removed.name}".` : `No tool named "${name}".`);
+      break;
+    }
+
+    case "path":
+      console.log(tools.TOOLS_DIR);
+      break;
+
+    default:
+      console.log('Usage: open-claudia tool [list | show <name> | add <path> [flags] | run <name> [args] | remove <name> | path]');
+  }
+}
+
+module.exports = { run };

package/channels/voice/adapter.js

@@ -127,6 +127,16 @@ class VoiceAdapter {
       });
     }
 
+    // Management API — REST surface over the core stores (tasks, jobs, packs,
+    // entities, people, lessons, ideas) so the app is a full Open Claudia
+    // frontend, not just a voice channel.
+    if (pathname.startsWith("/v1/manage/")) {
+      return require("./manage").handle(req, res, url, {
+        json: (code, payload) => this._json(res, code, payload),
+        readBody: (cb) => this._readBody(req, res, cb),
+      });
+    }
+
     if (req.method === "POST" && pathname === "/v1/messages/text") {
       return this._readBody(req, res, (buf) => this._onText(buf, res));
     }
@@ -330,10 +340,11 @@ class VoiceAdapter {
     this._broadcast({ kind: "delete", messageId, ts: Date.now() });
   }
 
-  async sendVoice(channelId, oggPath) {
+  async sendVoice(channelId, audioPath) {
     try {
-      const id = this._registerMedia(oggPath, "audio/ogg", path.basename(oggPath));
-      this._broadcast({ kind: "voice", messageId: this._mkId("v"), url: `/v1/media/${id}`, mime: "audio/ogg", ts: Date.now() });
+      const mime = this._guessMime(audioPath);
+      const id = this._registerMedia(audioPath, mime, path.basename(audioPath));
+      this._broadcast({ kind: "voice", messageId: this._mkId("v"), url: `/v1/media/${id}`, mime, ts: Date.now() });
       return true;
     } catch (e) {
       console.error("voice sendVoice error:", e.message);
@@ -341,6 +352,12 @@ class VoiceAdapter {
     }
   }
 
+  // Marks the end of a streamed multi-clip spoken reply so the client can stop
+  // queueing and re-arm the mic for the next hands-free turn.
+  async sendVoiceEnd() {
+    this._broadcast({ kind: "voice-end", ts: Date.now() });
+  }
+
   async sendPhoto(channelId, filePath, caption) { return this.sendFile(channelId, filePath, caption); }
 
   async sendFile(channelId, filePath, caption) {
@@ -442,7 +459,7 @@ class VoiceAdapter {
   _cors(res, code) {
     res.writeHead(code, {
       "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
       "Access-Control-Allow-Headers": "Authorization, Content-Type",
     });
     res.end();

package/channels/voice/manage.js

@@ -0,0 +1,285 @@
+// Management API for the voice/companion app — a thin REST surface over the
+// same core stores the CLI uses (tasks, jobs, packs, entities, people,
+// lessons, ideas). Lets the Expo client act as a full Open Claudia frontend:
+// browse and manage work across every channel, not just the voice one.
+//
+// Mounted by the voice adapter under /v1/manage/*. Auth is already enforced
+// by the adapter before we get here (same bearer token as the rest of the
+// bridge). All routes return JSON.
+//
+// Scope note: tasks are stored per channel (tasks/<adapter>-<channelId>.json),
+// so the owner's real backlog lives on the Telegram channel, not voice. We
+// aggregate across every task file so the app shows the whole picture. The
+// file stem is an opaque "key"; since tasks.filePathFor re-applies the same
+// safe() (idempotent on already-safe strings) and just concatenates with a
+// single "-", splitting the key at the first "-" round-trips to the same file
+// regardless of where the boundary truly was.
+
+const fs = require("fs");
+const path = require("path");
+const tasks = require("../../core/tasks");
+const jobs = require("../../core/jobs");
+const packs = require("../../core/packs");
+const entities = require("../../core/entities");
+const people = require("../../core/people");
+const lessons = require("../../core/lessons");
+const ideas = require("../../core/ideas");
+const { TASKS_DIR, DEFAULT_CLAUDE_MODEL } = require("../../core/config");
+
+let PKG_VERSION = "unknown";
+try { PKG_VERSION = require("../../package.json").version || "unknown"; } catch (e) {}
+
+// ── task channel keys ──────────────────────────────────────────────
+
+function taskFileKeys() {
+  let entries = [];
+  try { entries = fs.readdirSync(TASKS_DIR); } catch (e) { return []; }
+  return entries
+    .filter((f) => f.endsWith(".json") && !f.endsWith(".tmp") && !f.startsWith("."))
+    .map((f) => f.slice(0, -5));
+}
+
+function keyToAC(key) {
+  const i = String(key).indexOf("-");
+  if (i < 0) return { adapter: key, channelId: "" };
+  return { adapter: key.slice(0, i), channelId: key.slice(i + 1) };
+}
+
+// Friendlier channel label for the UI than the raw file stem.
+function channelLabel(key) {
+  const { adapter } = keyToAC(key);
+  const map = { telegram: "Telegram", kazee: "Kazee", voice: "Voice" };
+  return map[adapter] || adapter || key;
+}
+
+function isOpen(t) { return t.status === "pending" || t.status === "in_progress"; }
+
+// ── responses ──────────────────────────────────────────────────────
+
+function overview() {
+  const keys = taskFileKeys();
+  let openTasks = 0, inProgress = 0;
+  for (const key of keys) {
+    const { adapter, channelId } = keyToAC(key);
+    for (const t of tasks.load(adapter, channelId)) {
+      if (isOpen(t)) openTasks++;
+      if (t.status === "in_progress") inProgress++;
+    }
+  }
+  const allJobs = jobs.listAll();
+  return {
+    version: PKG_VERSION,
+    model: DEFAULT_CLAUDE_MODEL,
+    counts: {
+      tasksOpen: openTasks,
+      tasksInProgress: inProgress,
+      taskChannels: keys.length,
+      crons: allJobs.filter((j) => j.kind === "cron").length,
+      wakeups: allJobs.filter((j) => j.kind === "wakeup").length,
+      packs: safeLen(() => packs.listPacks()),
+      entities: safeLen(() => entities.listEntities()),
+      people: safeLen(() => people.list()),
+      lessons: safeLen(() => lessons.listLessons()),
+      ideas: safeLen(() => ideas.listIdeas()),
+    },
+  };
+}
+
+function safeLen(fn) { try { return (fn() || []).length; } catch (e) { return 0; } }
+
+// Aggregated task tree across every channel, grouped per channel and sorted
+// so the busiest channel (most open tasks) comes first.
+function allTasks() {
+  const groups = [];
+  for (const key of taskFileKeys()) {
+    const { adapter, channelId } = keyToAC(key);
+    const tree = tasks.tree(adapter, channelId);
+    const open = tree.filter((r) => isOpen(r) || (r.children || []).some(isOpen)).length;
+    if (tree.length === 0) continue;
+    groups.push({ key, label: channelLabel(key), adapter, channelId, open, total: tree.length, tasks: tree });
+  }
+  groups.sort((a, b) => b.open - a.open || b.total - a.total);
+  return { groups };
+}
+
+function allJobsView() {
+  const list = jobs.listAll().map((j) => ({
+    id: j.id,
+    kind: j.kind,
+    label: j.label || "",
+    prompt: j.prompt || "",
+    adapterType: j.adapterType || j.adapter || "",
+    channelId: j.channelId || "",
+    project: j.project || null,
+    source: j.source || "agent",
+    schedule: j.schedule || null,
+    fireAt: j.fireAt || null,
+    lastFireAt: j.lastFireAt || null,
+    lastFireOk: j.lastFireOk === undefined ? null : j.lastFireOk,
+    createdAt: j.createdAt || null,
+  }));
+  // Wakeups by soonest fire, then crons.
+  list.sort((a, b) => {
+    if (a.kind !== b.kind) return a.kind === "wakeup" ? -1 : 1;
+    if (a.kind === "wakeup") return (a.fireAt || 0) - (b.fireAt || 0);
+    return String(a.label).localeCompare(String(b.label));
+  });
+  return { jobs: list };
+}
+
+function packSummaries() {
+  return {
+    packs: (packs.listPacks() || []).map((p) => ({
+      dir: p.dir, name: p.name, description: p.description, tags: p.tags,
+      parent: p.parent, skill: p.skill, kind: p.kind, updated: p.updated,
+      usage_count: p.usage_count, archived: !!p.archived,
+    })),
+  };
+}
+
+function packDetail(dir) {
+  const p = packs.readPack(dir);
+  if (!p) return null;
+  return p; // includes sections {Stance, Procedure, State, Journal}
+}
+
+function entitySummaries() {
+  return {
+    entities: (entities.listEntities() || []).map((e) => ({
+      slug: e.slug, name: e.name, type: e.type, description: e.description,
+      aliases: e.aliases, updated: e.updated, last_seen: e.last_seen,
+    })),
+  };
+}
+
+function entityDetail(slug) {
+  const e = entities.readEntity(slug);
+  if (!e) return null;
+  // readEntity stores sections as parseSections(body) → { sections: {...} }.
+  const sections = e.sections && e.sections.sections ? e.sections.sections : e.sections;
+  return { ...e, sections };
+}
+
+function peopleView() {
+  return {
+    people: (people.list() || []).map((p) => ({
+      id: p.id, name: p.name, isOwner: !!p.isOwner, bio: p.bio || null,
+      handles: (p.handles || []).map((h) => ({ adapter: h.adapter, channelId: h.channelId })),
+      primaryChannel: p.primaryChannel || null,
+      notes: (p.notes || []).map((n) => (typeof n === "string" ? { text: n } : { text: n.text || "", at: n.at || n.createdAt || null })),
+    })),
+  };
+}
+
+function lessonsView() {
+  return { lessons: (lessons.listLessons() || []).map((l) => ({ id: l.id, text: l.text, src: l.src || "", origin: l.origin || "", created: l.created || "", reinforced: l.reinforced || 0 })) };
+}
+
+function ideasView() {
+  return { ideas: (ideas.listIdeas() || []).map((i) => ({ id: i.id, text: i.text, created: i.created || "" })) };
+}
+
+// ── router ─────────────────────────────────────────────────────────
+// helpers: { json(code, payload), readBody(cb) } supplied by the adapter so
+// we don't reach into its privates.
+
+function handle(req, res, url, helpers) {
+  const { json, readBody } = helpers;
+  const method = req.method;
+  const sub = url.pathname.slice("/v1/manage/".length).replace(/\/+$/, "");
+  const parts = sub.split("/").filter(Boolean);
+
+  try {
+    // GET reads
+    if (method === "GET") {
+      if (sub === "overview") return json(200, { ok: true, ...overview() });
+      if (sub === "tasks") return json(200, { ok: true, ...allTasks() });
+      if (sub === "jobs") return json(200, { ok: true, ...allJobsView() });
+      if (sub === "packs") return json(200, { ok: true, ...packSummaries() });
+      if (parts[0] === "packs" && parts[1]) {
+        const d = packDetail(decodeURIComponent(parts.slice(1).join("/")));
+        return d ? json(200, { ok: true, pack: d }) : json(404, { ok: false, error: "pack not found" });
+      }
+      if (sub === "entities") return json(200, { ok: true, ...entitySummaries() });
+      if (parts[0] === "entities" && parts[1]) {
+        const e = entityDetail(decodeURIComponent(parts.slice(1).join("/")));
+        return e ? json(200, { ok: true, entity: e }) : json(404, { ok: false, error: "entity not found" });
+      }
+      if (sub === "people") return json(200, { ok: true, ...peopleView() });
+      if (sub === "lessons") return json(200, { ok: true, ...lessonsView() });
+      if (sub === "ideas") return json(200, { ok: true, ...ideasView() });
+      return json(404, { ok: false, error: "unknown manage route" });
+    }
+
+    // POST /tasks — add a task (or subtask)
+    if (method === "POST" && sub === "tasks") {
+      return readBody((buf) => {
+        let body = {};
+        try { body = JSON.parse(buf.toString("utf-8") || "{}"); } catch (e) {}
+        const { adapter, channelId } = resolveTaskTarget(body);
+        const content = String(body.content || "").trim();
+        if (!content) return json(400, { ok: false, error: "content required" });
+        try {
+          const t = tasks.add(adapter, channelId, content, {
+            parentId: body.parentId || null,
+            description: body.description || null,
+          });
+          return json(201, { ok: true, task: t });
+        } catch (e) { return json(400, { ok: false, error: e.message }); }
+      });
+    }
+
+    // PATCH /tasks/:id — { key|adapter+channelId, action: start|done|remove|pending }
+    if (method === "PATCH" && parts[0] === "tasks" && parts[1]) {
+      const id = parts[1];
+      return readBody((buf) => {
+        let body = {};
+        try { body = JSON.parse(buf.toString("utf-8") || "{}"); } catch (e) {}
+        const { adapter, channelId } = resolveTaskTarget(body);
+        const action = String(body.action || "").toLowerCase();
+        try {
+          if (action === "start") {
+            const t = tasks.update(adapter, channelId, id, { status: "in_progress" });
+            return t ? json(200, { ok: true, task: t }) : json(404, { ok: false, error: "task not found" });
+          }
+          if (action === "pending") {
+            const t = tasks.update(adapter, channelId, id, { status: "pending" });
+            return t ? json(200, { ok: true, task: t }) : json(404, { ok: false, error: "task not found" });
+          }
+          if (action === "done") {
+            const r = tasks.complete(adapter, channelId, id);
+            if (!r) return json(404, { ok: false, error: "task not found" });
+            if (r.blocked) return json(409, { ok: false, error: "plan has open subtasks", openChildren: r.openChildren.map((c) => c.content) });
+            return json(200, { ok: true, removedCount: r.removedCount });
+          }
+          if (action === "remove") {
+            const r = tasks.remove(adapter, channelId, id);
+            return r ? json(200, { ok: true, alsoRemoved: r.alsoRemoved }) : json(404, { ok: false, error: "task not found" });
+          }
+          return json(400, { ok: false, error: "unknown action" });
+        } catch (e) { return json(400, { ok: false, error: e.message }); }
+      });
+    }
+
+    // DELETE /jobs/:id — cancel a wakeup or cron
+    if (method === "DELETE" && parts[0] === "jobs" && parts[1]) {
+      const removed = jobs.remove(parts[1]);
+      return removed ? json(200, { ok: true, removed: { id: removed.id, kind: removed.kind, label: removed.label } }) : json(404, { ok: false, error: "job not found" });
+    }
+
+    return json(404, { ok: false, error: "unknown manage route" });
+  } catch (e) {
+    return json(500, { ok: false, error: e.message });
+  }
+}
+
+// A task mutation needs the exact (adapter, channelId). The client passes the
+// channel "key" (file stem) it got from GET /tasks; fall back to explicit
+// adapter+channelId, then to the voice channel as a last resort.
+function resolveTaskTarget(body) {
+  if (body && body.key) return keyToAC(body.key);
+  if (body && body.adapter) return { adapter: body.adapter, channelId: body.channelId || "" };
+  return { adapter: "voice", channelId: "voice-owner" };
+}
+
+module.exports = { handle };

package/core/dream.js

@@ -681,6 +681,7 @@ function writeDreamReport(data) {
       sec.push("", "### Proposed (not applied — DREAM_SELF_APPLY=off)", "```json", JSON.stringify(data.introspection.proposed, null, 2), "```");
     }
     if (data.graphNote) sec.push("", data.graphNote);
+    if (data.toolNote) sec.push("", data.toolNote);
     if (data.staleNote) sec.push("", data.staleNote);
     if (data.backupRoot) sec.push("", `Backups: ${data.backupRoot}`);
     const block = sec.join("\n") + "\n\n---\n\n";
@@ -825,6 +826,25 @@ async function runDream({ trigger = "manual" } = {}) {
       }
     } catch (e) { /* graph is best-effort */ }
 
+    // Tool hygiene: tend the directed tool-graph (decay reinforced follows-edges,
+    // prune faded/orphaned ones) and flag tools whose --pack link now dangles.
+    // Read-only toward the tools themselves — a tool is never auto-deleted (that's
+    // destructive); we just surface the breakage for the user to re-link or remove.
+    let toolNote = "";
+    try {
+      const toolsLib = require("./tools");
+      const tg = require("./tool-graph").tend(toolsLib);
+      const bits = [];
+      if (tg.edges || tg.decayed || tg.pruned) {
+        bits.push(`🔧 Tool graph: ${tg.edges} edges / ${tg.nodes} nodes (decayed ${tg.decayed}, pruned ${tg.pruned}).`);
+      }
+      const dangling = toolsLib.listTools().filter((t) => t.pack && !packs.readPack(t.pack));
+      if (dangling.length) {
+        bits.push(`🔗 ${dangling.length} tool(s) link a missing skill pack: ${dangling.map((t) => `${t.name}→${t.pack}`).join(", ")} — re-link with --pack or remove.`);
+      }
+      toolNote = bits.join("\n");
+    } catch (e) { /* tool graph is best-effort (old node) */ }
+
     const staleNote = staleTaskReport();
     const dreamLines = consolidationLines.concat(introApplied);
 
@@ -832,7 +852,7 @@ async function runDream({ trigger = "manual" } = {}) {
       model: DREAM_MODEL, effort: DREAM_EFFORT, trigger,
       consolidation: { report: decision.report, lines: consolidationLines },
       introspection: { report: introReport, lines: introApplied, proposed: introProposed },
-      graphNote, staleNote, backupRoot,
+      graphNote, toolNote, staleNote, backupRoot,
     });
 
     // Richer chat summary: consolidation + introspection narrative + what
@@ -846,12 +866,13 @@ async function runDream({ trigger = "manual" } = {}) {
       if (n) parts.push(`📋 ${n} self-improvement change(s) staged for your OK (DREAM_SELF_APPLY=off) — see the log below.`);
     }
     if (graphNote) parts.push(graphNote);
+    if (toolNote) parts.push(toolNote);
     if (staleNote) parts.push(staleNote);
     if (dreamLines.length) parts.push(`🗄 Anything changed or merged away is backed up under ${backupRoot}`);
     if (reportPath) parts.push(`📔 Full dream log: ${reportPath}`);
     const message = parts.length ? parts.join("\n\n") : "";
 
-    return { applied: dreamLines, report, introReport, message, staleNote, graphNote, reportPath, trigger };
+    return { applied: dreamLines, report, introReport, message, staleNote, graphNote, toolNote, reportPath, trigger };
   } finally {
     _dreaming = false;
   }

package/core/handlers.js

@@ -1217,7 +1217,8 @@ register({
       `First check the already-injected packs and 'open-claudia pack list' for a pack this work belongs to; if one fits, fold the reusable how-to into that pack's Procedure section (exact commands in order, prerequisites, pitfalls) and append a dated Journal line — edit the PACK.md directly. ` +
       `Only if no pack fits, create a new one: 'open-claudia pack' has no create subcommand, so write ~/.open-claudia/packs/<kebab-name>/PACK.md following the four-section format (Stance, Procedure, State, Journal) with name + a when-to-use description in the frontmatter. Give it an ACTIVITY-oriented name and description (what you DO — the verbs, tools, and artifacts) so it is findable from other projects by the work being done, not by a project name; and if this how-to came from a specific project, add a 'learned_on: <project-pack-dir>' frontmatter line so its cross-project reuse can be tracked. ` +
       `Then mark that pack as a reusable skill so it is always surfaced in future conversations: run 'open-claudia pack skill <dir> on'. This flags it as a reusable ability and adds it to the always-on skill index (name + description); the Procedure still loads on demand. ` +
-      `No secrets or tokens. When done, reply with one short line naming the pack you created or updated and what it covers. ` +
+      `CRUCIAL — also crystallise the EXECUTABLE part: if the work involved a script, API call, or any repeatable command sequence you wrote inline (a heredoc, a one-off .py/.sh, a curl chain), turn it into a reusable tool instead of leaving it to be re-typed. Write the script to a file (parameterise the bits that vary; read any credential from the env as $NAME rather than hardcoding), then register it with 'open-claudia tool add <path> --pack <dir> --desc "..." [--requires "key1,key2"] [--usage "..."]', linking it to the pack you just touched. Reference creds by their keyring names (see 'open-claudia keyring list'); never write a secret into the tool. The tool is the runnable form of the pack's Procedure — save both. ` +
+      `No secrets or tokens in packs OR tools. When done, reply with one short line naming the pack you created or updated, any tool you saved, and what it covers. ` +
       `If the recent work is genuinely not reusable, say so instead of forcing a skill.`;
     await runClaude(prompt, currentState().currentSession.dir, env.messageId);
   },

package/core/io.js

@@ -35,6 +35,16 @@ async function sendVoice(oggPath) {
   return adapter.sendVoice(channelId, oggPath);
 }
 
+// Signal the end of a streamed multi-clip spoken reply. Only the voice channel
+// implements it (so the client knows the reply is complete and can re-arm the
+// mic); other adapters simply have no such method and this is a no-op.
+async function sendVoiceEnd() {
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  if (!adapter || !channelId || typeof adapter.sendVoiceEnd !== "function") return;
+  return adapter.sendVoiceEnd(channelId);
+}
+
 async function sendFile(filePath, caption) {
   const adapter = currentAdapter();
   const channelId = currentChannelId();
@@ -56,4 +66,4 @@ function splitMessage(text, maxLen = 4000) {
   return chunks;
 }
 
-module.exports = { send, editMessage, deleteMessage, sendVoice, sendFile, typing, splitMessage };
+module.exports = { send, editMessage, deleteMessage, sendVoice, sendVoiceEnd, sendFile, typing, splitMessage };