@inetafrica/open-claudia 3.0.35 → 3.0.40

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## v3.0.40 — Sharper recall: surfaces the actual matched facts, drops weakly-relevant ones (third cut of the Pass-4 release)
+
+- **On-open pack/entity injection is now extractive, not a headline.** Opening a pack used to inject its one-line description, hiding the facts that actually matched in State/Procedure/Journal. It now injects the Stance verbatim plus the specific fuzzy-matched lines (section-tagged), so the model sees the real matched content rather than a summary of it. Toggle with `RECALL_EXTRACTIVE` (default on).
+- **A walker score-gate drops weakly-relevant nodes.** The cheap recall walker is a pure router now — it emits `{id, why, score 0-100}` and never paraphrases. Nodes it keeps below the relevance floor (`RECALL_MIN_RELEVANCE_SCORE`, default 55) are gated out on full-tier walks, and the cascade is tightened so sticky auto-keeps are routed back to the judge instead of leaking in. Fails open (a garbled walk bypasses the gate).
+- **A KPI ruler stamps each version.** Per-turn recall records now carry kept-node scores, gate activity, and warmings; the KPI table/HTML report aggregate them per version so each release freezes as a comparable baseline (`relevance`, `gate`, `warm` columns).
+- **Co-kept Hebbian warming ships dark (default OFF).** A weaker-than-co-open reinforcement for pairs the walker co-injected, guarded by score floor + a message-grounded endpoint + a top-N cap. It writes persistent graph state so it can't be validated in one session — left off (`RECALL_COKEPT_WARMING`) pending real-traffic evaluation.
+- **Escape hatch + measurement caveat.** `/engine classic` reverts to the prior behaviour if anything regresses. Two reviewer-side measurement refinements (used-the-right-fact line-level adjudication, and shadow-delta scoring) were deferred to the separate in-flight shadow-delta task — they change how recall is *measured*, not what ships here.
+- **Agent-space / OpenClaw:** no new deps, no new env required (all `RECALL_*` knobs have defaults), no schema change; Docker image builds FROM the existing `:base`. Covered by new `test-pack-search.js`, `test-walker-score.js`, `test-extractive-injection.js`, `test-score-gate.js`, and `test-cokept-warming.js`. Existing pods pick this up on their next approved upgrade. (Two earlier cuts failed CI before publishing anything: v3.0.38 bumped the version but not the release-pin guard in `test-provider-language.js`; v3.0.39 fixed that but `test-cokept-warming.js` asserted a sqlite-graph write that no-ops on CI's `node:20` — it now skips that path when `node:sqlite` is absent, like `test-recall-graph.js`. Both were verified locally by running the suite with `node:sqlite` simulated absent, reproducing the CI environment.)
+
+## v3.0.37 — Silent background watches, and pasted secrets are accepted on any provider
+
+- **You can now arm a watch: a background poll that stays out of the chat and only wakes me when its condition is actually met.** A watch is just a cron carrying a shell `check` command — each tick runs the check with output discarded, and *only* an exit 0 wakes the agent (with a `🔔 Watch "<label>" triggered` notice and a normal reply). A non-zero exit is the idle case: nothing hits the chat, the poll's activity goes to an append-only `watch.log`, and the job stays pending for the next tick. Watches default to **one-shot** (fire once, then remove) so a matched condition can't spam you; add `--repeat` to keep polling. Create/manage from the CLI (`open-claudia watch-add "<check>" "<wake-prompt>" [--every "<cron>"] [--repeat]`, `watch-list`, `watch-remove`), and the owner can flip the global master switch with **`/watch on|off`** (watches are owner-gated because the check is raw shell). Rides the migration-verified jobs store untouched — `check`/`repeat` survive as extra fields, zero schema change.
+- **Pasting a credential into the chat now stores it out-of-band regardless of which provider is active.** Codex refuses secrets in its prompt, so a pasted key under the Codex backend used to be rejected — and being told to re-paste it through keyring commands *in the same chat* was no safer and plain annoying. A loose paste is now classified (`core/credential-detect.js`) and captured **before** the turn reaches the model: a Claude OAuth token → `.env`+vault, an OpenAI key → handed to the Codex CLI, a recognised service token → the operational keyring, an ambiguous long token → scrubbed from chat. Every captured secret is registered for redaction and the original message deleted. The capture is provider-agnostic and never forwards the secret to any model.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds FROM the existing `:base`. Covered by new `test-credential-capture.js` and watch probes in `test-provider-scheduler.js`. Existing pods pick this up on their next approved upgrade.
+
+## v3.0.36 — Picking a Claude model no longer forces a re-login
+
+- **Selecting any Claude model claimed Claude wasn't connected and started a login — even while Claude was working fine.** The model-button handler (and the `/login` picker) decided "connected?" from a shallow token probe (`getClaudeOAuthToken().value`) that only sees an OAuth token in `.env`, the process env, or an unlocked vault. Anyone whose Claude login lives in the Claude CLI's own credential store (the normal `claude` login, no bot token) therefore read as *disconnected*, so every model tap answered "Claude isn't connected yet. Starting login…". The re-login it launched (`claude auth login --claudeai`) never stores a bot token, so the shallow check stayed false and the prompt returned on the very next tap — an unbreakable loop.
+- **Both surfaces now resolve Claude's real auth state via `claudeProviderAuthStatus()`** — the same probe agent runs rely on, which counts a bot OAuth token *and* a `claude auth status` CLI-store login as authenticated. A model tap only starts a login when Claude is genuinely unauthenticated, mirroring the Codex branch beside it. Codex was never affected (it already checked `codex login status`). Cost: one `claude auth status` (~1s) on a model tap when no bot token exists — fine for a settings screen, and skipped entirely when a bot token is present.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds FROM the existing `:base`. Existing pods pick this up on their next approved upgrade.
+
 ## v3.0.35 — Spaces comments are readable rich text, not a run-on wall
 
 - **The bot's Spaces replies rendered as unreadable walls.** `buildCommentContent` posted the entire reply as one text node inside one paragraph. Spaces comments are TipTap/ProseMirror docs: inside a single text node newlines don't render, so paragraphs, numbered lists and `---` separators collapsed into one run-on blob — and the model's markdown (`**bold**`, `*italic*`, backticks) printed its asterisks literally.

package/bin/cli.js

@@ -306,6 +306,26 @@ switch (command) {
     require("./schedule").runCronRemove(args.slice(1));
     break;
   }
+  case "watch-add": {
+    require("./schedule").runWatchAdd(args.slice(1));
+    break;
+  }
+  case "watch-list": {
+    require("./schedule").runWatchList();
+    break;
+  }
+  case "watch-remove": {
+    require("./schedule").runWatchRemove(args.slice(1));
+    break;
+  }
+  case "watch-on": {
+    require("./schedule").runWatchToggle(true);
+    break;
+  }
+  case "watch-off": {
+    require("./schedule").runWatchToggle(false);
+    break;
+  }
 
   case "task": {
     require("./task").run(args.slice(1));
@@ -440,6 +460,10 @@ Background work (only inside an active bot-spawned task):
   open-claudia cron-add "<sched>" "<prompt>"       Recurring job pinned to the selected provider session
   open-claudia cron-list                           List all wakeups + crons on this channel
   open-claudia cron-remove <id>                    Remove a scheduled job
+  open-claudia watch-add "<check>" "<prompt>"      Silent monitor: poll a shell check, wake only when it exits 0
+  open-claudia watch-list                          List watches on this channel + master switch state
+  open-claudia watch-remove <id>                   Remove a watch
+  open-claudia watch-on | watch-off                Global master switch for all watches (owner)
   open-claudia task add|list|start|done|remove     Per-channel todo (survives restarts)
   open-claudia agent "<prompt>" [--role X] [--provider active|claude|codex]  Spawn a provider-isolated sub-agent
 

package/bin/pack.js

@@ -1,7 +1,8 @@
 // CLI: inspect and manage context packs (living skills+memory docs).
 //   open-claudia pack list
 //   open-claudia pack show <dir>
-//   open-claudia pack match "<text>"        — debug the router
+//   open-claudia pack match "<text>"        — debug the router (whole-pack)
+//   open-claudia pack search "<query>"      — per-line extractive search
 //   open-claudia pack migrate               — fold ~/.claude/skills into packs
 //   open-claudia pack remove <dir>
 //   open-claudia pack reindex
@@ -124,6 +125,22 @@ function run(args) {
       break;
     }
 
+    case "search": {
+      let dir = null, k = 8;
+      const words = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--pack") { dir = rest[++i]; continue; }
+        if (rest[i] === "--k") { k = Math.max(1, parseInt(rest[++i], 10) || 8); continue; }
+        words.push(rest[i]);
+      }
+      const query = words.join(" ");
+      if (!query) { console.error('Usage: pack search "<query>" [--pack <dir>] [--k N]'); process.exitCode = 1; return; }
+      const hits = packs.searchLines(query, { dir, k });
+      if (hits.length === 0) return console.log("No matching lines.");
+      for (const h of hits) console.log(`${String(h.score).padStart(3)}  ${h.dir}/${h.section}:${h.lineno}  ${h.text}`);
+      break;
+    }
+
     case "remove": {
       const removed = packs.removePack(rest[0]);
       if (!removed) { console.error(`No pack: ${rest[0]}`); process.exitCode = 1; return; }
@@ -176,7 +193,7 @@ function run(args) {
     }
 
     default:
-      console.log("Usage: open-claudia pack [list|skills|abilities|skill <dir> [on|off]|kind <dir> <ability|context>|show <dir>|match \"<text>\"|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
+      console.log("Usage: open-claudia pack [list|skills|abilities|skill <dir> [on|off]|kind <dir> <ability|context>|show <dir>|match \"<text>\"|search \"<query>\" [--pack <dir>] [--k N]|migrate|remove <dir>|archive <dir>|restore <dir>|archived|reindex]");
   }
 }
 

package/bin/schedule.js

@@ -15,8 +15,19 @@ Crons (recurring):
   open-claudia cron-list                         # all wakeups + crons for this channel
   open-claudia cron-remove <id>                  # remove by id from cron-list
 
-Each fire wakes the agent in the same channel and resumes the selected provider
-session captured when the schedule was created. Provider/project switches made
+Watches (silent background monitor — polls a shell check, wakes you only on a hit):
+  open-claudia watch-add "<check-cmd>" "<wake-prompt>" [--label "<label>"] [--every "<cron>"] [--repeat]
+    <check-cmd>: a shell command polled on a schedule (default every minute).
+                 exit 0 = condition met → wake the agent with <wake-prompt>.
+                 non-zero = still idle → nothing happens, nothing hits the chat.
+    --repeat: keep polling after it fires (default: fire once, then remove).
+  open-claudia watch-list                        # watches on this channel + master switch state
+  open-claudia watch-remove <id>                 # remove a watch by id
+  open-claudia watch-on / watch-off              # global master switch for ALL watches (owner)
+
+The poll itself never touches the chat — only a real trigger wakes the agent
+and produces a normal reply. Each fire resumes the selected provider session
+captured when the schedule/watch was created. Provider/project switches made
 later do not retarget already-scheduled work.
 `;
 
@@ -123,10 +134,68 @@ async function runCronRemove(args) {
   } catch (e) { console.error(e.message); process.exit(1); }
 }
 
+async function runWatchAdd(args) {
+  if (args.length < 2 || args[0] === "--help") { console.log(HELP); process.exit(args[0] === "--help" ? 0 : 2); }
+  const rest = args.slice();
+  const label = takeFlag(rest, "label");
+  const schedule = takeFlag(rest, "every");
+  const project = takeFlag(rest, "project");
+  const repeatIdx = rest.indexOf("--repeat");
+  const repeat = repeatIdx >= 0;
+  if (repeat) rest.splice(repeatIdx, 1);
+  const check = rest[0];
+  const prompt = rest.slice(1).join(" ");
+  if (!check || !prompt) { console.error("Usage: watch-add \"<check-cmd>\" \"<wake-prompt>\" [--every \"<cron>\"] [--repeat]"); process.exit(2); }
+  try {
+    const request = { check, prompt, repeat, label: label || prompt.slice(0, 60) };
+    if (schedule) request.schedule = schedule;
+    if (project) request.project = project;
+    const res = await postJson("watch-add", request);
+    console.log(`Added watch ${res.job.id} (${repeat ? "repeating" : "one-shot"}, polls "${res.job.schedule}"). Silent until the check passes.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runWatchList() {
+  try {
+    const res = await postJson("watch-list", {});
+    const list = res.watches || [];
+    console.log(`Watches: master switch is ${res.enabled ? "ON" : "OFF"}.`);
+    if (list.length === 0) { console.log("No watches on this channel."); process.exit(0); }
+    for (const w of list) {
+      const mode = w.repeat ? "repeating" : "one-shot";
+      console.log(`${w.id}  ${mode}  polls "${w.schedule}"  check: ${w.check}  → ${w.label || "(no label)"}`);
+    }
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runWatchRemove(args) {
+  const id = args[0];
+  if (!id) { console.error("Usage: watch-remove <id>"); process.exit(2); }
+  try {
+    const res = await postJson("watch-remove", { id });
+    console.log(res.ok ? `Removed watch ${id}.` : `Not found: ${id}.`);
+    process.exit(res.ok ? 0 : 1);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runWatchToggle(enabled) {
+  try {
+    const res = await postJson("watch-toggle", { enabled });
+    console.log(`Watches ${res.enabled ? "ENABLED" : "DISABLED"} globally.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
 module.exports = {
   HELP,
   runScheduleWakeup,
   runCronAdd,
   runCronList,
   runCronRemove,
+  runWatchAdd,
+  runWatchList,
+  runWatchRemove,
+  runWatchToggle,
 };

package/core/actions.js

@@ -28,7 +28,7 @@ const jobs = require("./jobs");
 const scheduler = require("./scheduler");
 const { sideChatCoordinator } = require("./side-chat");
 const {
-  getClaudeOAuthToken, runClaudeAuthCommand, runCodexLoginStatus, runCodexDeviceLogin,
+  claudeProviderAuthStatus, runClaudeAuthCommand, runCodexLoginStatus, runCodexDeviceLogin,
 } = require("./auth-flow");
 
 const REMOVED_PROVIDER_CALLBACK_MESSAGE = "This button is from an older Open Claudia release. Cursor Agent support has been removed. Open /backend to choose Claude Code or OpenAI Codex.";
@@ -335,7 +335,7 @@ async function handleAction(envelope) {
     const beLabel = provider.label;
     // Auth-aware: if the chosen provider isn't connected, start its login flow
     // now. The model is already set, so once auth completes the user is on it.
-    if (be === "claude" && !getClaudeOAuthToken().value) {
+    if (be === "claude" && claudeProviderAuthStatus().state !== "authenticated") {
       if (!isChatOwner(envelope.channelId)) { await send("Claude isn't connected and only the owner can sign it in."); return; }
       await send(`Set to ${model}, but Claude isn't connected yet. Starting login — open the URL I send, then paste the code here.`);
       await runClaudeAuthCommand(["auth", "login", "--claudeai"], "Claude login");

package/core/auth-flow.js

@@ -393,12 +393,14 @@ function codexAuthHelp(reason = "Codex authentication failed") {
 }
 
 // Quick "is this provider usable non-interactively" check for the unified
-// /login model picker. Claude is cheap (token presence is what the bot relies
-// on). Codex spawns `codex login status` once — fine for a setup screen.
+// /login model picker. Each provider resolves its real auth state once (Claude
+// via a bot token or the CLI credential store; Codex via `codex login status`)
+// — fine for a setup screen, and it stops a CLI-store login from looking
+// disconnected.
 function providerAuthStatus() {
   const binary = codexExecutable();
   return {
-    claude: !!getClaudeOAuthToken().value,
+    claude: claudeProviderAuthStatus().state === "authenticated",
     codex: binary ? runCodexLoginStatus().ok : false,
   };
 }

package/core/credential-detect.js

@@ -0,0 +1,55 @@
+"use strict";
+
+// Pure classification of a pasted chat message into a credential disposition.
+// No side effects — the router performs the actual store/delete/confirm. Kept
+// standalone (no requires) so it can be unit-tested without loading the
+// router's dependency graph, and so the ordering rules live in one place.
+//
+// Disposition kinds:
+//   claude  — a Claude Code OAuth token   → saved to .env + vault
+//   openai  — an OpenAI API key           → handed to the Codex CLI
+//   keyring — another recognised secret   → operational keyring (name provided)
+//   scrub   — an ambiguous long token     → delete from chat but still answer
+//   none    — ordinary text               — leave the message alone
+//
+// A recognised service prefix is claimed BEFORE the generic long-opaque Claude
+// heuristic, otherwise a long GitHub/GitLab token would be mistaken for a
+// Claude token. sk-ant- is claimed before the generic OpenAI sk- shape.
+
+function classifyPastedCredential(raw) {
+  const text = String(raw || "").trim();
+  if (!text) return { kind: "none" };
+
+  if (/^sk-ant-[A-Za-z0-9._-]+$/.test(text)) return { kind: "claude" };
+  if (/^sk-(?:proj-)?[A-Za-z0-9._-]{20,}$/.test(text)) return { kind: "openai" };
+
+  const byPrefix = [
+    [/^glpat-[A-Za-z0-9._-]{8,}$/, "gitlab_token"],
+    [/^(?:ghp_|gho_|github_pat_)[A-Za-z0-9._-]{8,}$/, "github_token"],
+    [/^(?:xoxb-|xoxp-)[A-Za-z0-9-]{8,}$/, "slack_token"],
+    [/^AKIA[0-9A-Z]{8,}$/, "aws_access_key_id"],
+    [/^AIza[0-9A-Za-z._-]{10,}$/, "google_api_key"],
+  ];
+  for (const [re, name] of byPrefix) if (re.test(text)) return { kind: "keyring", name, value: text };
+
+  // A labelled secret ("token: <value>", "Bearer <value>") — only when the
+  // value is a single secret-shaped token, so "key: the answer is 42" is left
+  // as ordinary text rather than swallowed.
+  const labeled = text.match(/^(Bearer)\s+(\S{12,})$/i)
+    || text.match(/^(token|key|secret|password)\s*:\s*(\S{12,})$/i);
+  if (labeled) {
+    const name = labeled[1].toLowerCase() === "bearer" ? "bearer_token" : labeled[1].toLowerCase();
+    return { kind: "keyring", name, value: labeled[2] };
+  }
+
+  // Long opaque token with no sk- prefix → Claude OAuth token shape.
+  if (!/^sk-/.test(text) && text.length >= 80 && /^[A-Za-z0-9._=-]+$/.test(text)) return { kind: "claude" };
+
+  // Ambiguous long single token: scrub it from the chat (it may be a secret)
+  // but let the turn proceed so the agent can still respond.
+  if (/^[A-Za-z0-9_-]{20,}$/.test(text)) return { kind: "scrub" };
+
+  return { kind: "none" };
+}
+
+module.exports = { classifyPastedCredential };

package/core/handlers.js

@@ -2105,6 +2105,79 @@ register({
   },
 });
 
+// ── Watch (silent background monitor) ──────────────────────────────
+// A watch is a cron carrying a shell `check`. The scheduler polls the check
+// silently — nothing reaches the chat — and wakes the agent with `prompt`
+// only when the check exits 0. Owner-only: the check is arbitrary shell on
+// the bot host.
+
+register({
+  name: "watch", description: "Silent background monitor: poll a shell check, ping you only on a hit", args: "[add \"<check>\" \"<prompt>\" [repeat] | remove <#> | on | off]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return send("Owner only — a watch runs shell commands on my host.");
+    const channelWatches = () => jobs.listForChannel(env.adapter.id, env.channelId).filter((j) => !!j.check);
+
+    if (!tail) {
+      const list = channelWatches();
+      const master = scheduler.watchesEnabled() ? "ON" : "OFF";
+      if (list.length === 0) {
+        return send([
+          `No watches. Master switch: ${master}.`,
+          "",
+          "A watch silently polls a shell check and only pings you when it passes — nothing hits the chat until then.",
+          "",
+          'Add: /watch add "<check-cmd>" "<wake-prompt>"',
+          'e.g. /watch add "curl -sf https://myapp/health || exit 1" "myapp health check failed — take a look"',
+          "Add `repeat` at the end to keep polling after it fires (default: one-shot).",
+        ].join("\n"));
+      }
+      return send(
+        `Watches (master switch: ${master}):\n\n` +
+        list.map((w, i) => `${i + 1}. ${w.label} — polls "${w.schedule}"${w.repeat ? " (repeating)" : " (one-shot)"}\n   check: ${w.check}`).join("\n") +
+        "\n\nRemove: /watch remove <#>\nToggle all: /watch on | /watch off",
+      );
+    }
+
+    if (/^on$/i.test(tail)) {
+      scheduler.setWatchesEnabled(true);
+      return send("✅ Watches ENABLED. Existing watches resume polling.");
+    }
+    if (/^off$/i.test(tail)) {
+      scheduler.setWatchesEnabled(false);
+      return send("⏸️ Watches DISABLED globally. Polling is paused and nothing will fire until /watch on. Your watches are kept.");
+    }
+
+    const addMatch = tail.match(/^add\s+"([^"]+)"\s+"([^"]+)"(?:\s+(repeat))?$/i);
+    if (addMatch) {
+      const job = scheduler.addWatch({
+        adapter: env.adapter.id,
+        adapterType: env.adapter.type,
+        channelId: String(env.channelId),
+        canonicalUserId: env.canonicalUserId,
+        project: "Workspace",
+        projectDir: WORKSPACE,
+        check: addMatch[1],
+        prompt: addMatch[2],
+        label: addMatch[2].slice(0, 50),
+        source: "user",
+        repeat: !!addMatch[3],
+      });
+      return send(`👁️ Watching (${addMatch[3] ? "repeating" : "one-shot"}, polls "${job.schedule}"). I'll stay quiet until the check passes, then ping you.`);
+    }
+
+    const removeMatch = tail.match(/^remove\s+(\d+)$/);
+    if (removeMatch) {
+      const list = channelWatches();
+      const idx = parseInt(removeMatch[1], 10) - 1;
+      if (idx < 0 || idx >= list.length) return send("Invalid number.");
+      const removed = scheduler.removeJob(list[idx].id);
+      return send(`Removed watch: ${removed ? removed.label : "(unknown)"}`);
+    }
+
+    send('Usage: /watch | /watch add "<check-cmd>" "<wake-prompt>" [repeat] | /watch remove <#> | /watch on | /watch off');
+  },
+});
+
 // ── Channels ───────────────────────────────────────────────────────
 
 register({

package/core/loopback.js

@@ -74,6 +74,7 @@ function readBodyToFile(req, dest) {
 const SEND_KINDS = new Set(["send-file", "send-voice", "send-photo"]);
 const JSON_KINDS = new Set([
   "schedule-wakeup", "cron-add", "cron-remove", "job-list",
+  "watch-add", "watch-list", "watch-remove", "watch-toggle",
   "task-add", "task-plan", "task-update", "task-remove", "task-list", "task-get", "task-tree", "task-clear-completed",
   "people-list", "people-show", "people-add", "people-note", "people-link", "people-unlink",
   "people-remove", "people-set-primary",
@@ -238,6 +239,57 @@ async function handleJson(req, res, url, kind) {
     return reply(res, 200, { ok: true, jobs: list, archived });
   }
 
+  // A watch is a cron carrying a shell `check`; the scheduler polls the check
+  // silently and only wakes the agent (with `prompt`) when it exits 0.
+  if (kind === "watch-add") {
+    if (!payload.check || !payload.prompt) return reply(res, 400, { error: "missing check/prompt" });
+    const job = scheduler.addWatch({
+      adapter: adapterId,
+      adapterType: adapter.type,
+      channelId,
+      canonicalUserId: payload.canonicalUserId || null,
+      userId: payload.userId || null,
+      provider: payload.provider || null,
+      providerSettings: payload.providerSettings || {},
+      project: payload.project || null,
+      projectDir: payload.projectDir || null,
+      check: String(payload.check),
+      prompt: String(payload.prompt),
+      label: String(payload.label || payload.prompt).slice(0, 60),
+      schedule: payload.schedule ? String(payload.schedule) : undefined,
+      repeat: !!payload.repeat,
+      source: payload.source || "agent",
+      sessionId: payload.sessionId || null,
+      previousSessionId: payload.previousSessionId || null,
+      originRunId: payload.originRunId || null,
+      sessionLineage: {
+        originRunId: payload.originRunId || null,
+        originSessionId: payload.sessionId || null,
+        previousSessionId: payload.previousSessionId || null,
+        originProject: payload.originProject || payload.project || null,
+      },
+    });
+    return reply(res, 200, { ok: true, job });
+  }
+
+  if (kind === "watch-list") {
+    const list = jobsStore.listForChannel(adapterId, channelId).filter((job) => !!job.check);
+    return reply(res, 200, { ok: true, watches: list, enabled: scheduler.watchesEnabled() });
+  }
+
+  if (kind === "watch-remove") {
+    const id = payload.id || url.searchParams.get("id");
+    if (!id) return reply(res, 400, { error: "missing id" });
+    const removed = scheduler.removeJob(id);
+    return reply(res, removed ? 200 : 404, { ok: !!removed, removed });
+  }
+
+  if (kind === "watch-toggle") {
+    if (typeof payload.enabled !== "boolean") return reply(res, 400, { error: "missing enabled boolean" });
+    const enabled = scheduler.setWatchesEnabled(payload.enabled);
+    return reply(res, 200, { ok: true, enabled });
+  }
+
   if (kind === "task-add") {
     if (!payload.content) return reply(res, 400, { error: "missing content" });
     try {

package/core/packs.js

@@ -641,11 +641,61 @@ function matchPacks(text, { limit = 3, threshold = null } = {}) {
     .map(([dir, score]) => ({ dir, name: names.get(dir) || dir, score }));
 }
 
+// Extractive per-line search. Where matchPacks routes whole packs, this
+// returns the individual lines that best match the query, tagged by section,
+// so the injector can surface a verbatim fact from anywhere in a pack — not
+// just Stance. Deliberately JS-side (no second FTS table) so it can never
+// disturb the load-bearing whole-pack index in reindex(). Fuzz comes from
+// substring matching: term "deploy" also hits "deployment"/"deployed".
+function searchLines(query, { dir = null, k = 8, minScore = 1 } = {}) {
+  const terms = queryTerms(query);
+  if (terms.length === 0) return [];
+  let packs;
+  if (dir) {
+    const p = readPack(dir);
+    packs = p ? [p] : [];
+  } else {
+    packs = listPacks().filter((p) => !p.archived);
+  }
+  const hits = [];
+  for (const p of packs) {
+    for (const section of SECTIONS) {
+      const body = p.sections?.[section] || "";
+      if (!body) continue;
+      const lines = body.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.length < 3) continue; // skip blanks / stray punctuation
+        const low = trimmed.toLowerCase();
+        let distinct = 0;
+        let total = 0;
+        for (const t of terms) {
+          let idx = low.indexOf(t);
+          if (idx === -1) continue;
+          distinct++;
+          let occ = 0;
+          while (idx !== -1 && occ < 3) { occ++; idx = low.indexOf(t, idx + t.length); }
+          total += occ;
+        }
+        if (distinct < 1) continue;
+        const score = distinct * 10 + Math.min(total - distinct, 5);
+        if (score < minScore) continue;
+        hits.push({ dir: p.dir, section, lineno: i + 1, text: trimmed, score });
+      }
+    }
+  }
+  hits.sort((a, b) => b.score - a.score
+    || a.dir.localeCompare(b.dir)
+    || SECTIONS.indexOf(a.section) - SECTIONS.indexOf(b.section)
+    || a.lineno - b.lineno);
+  return hits.slice(0, Math.max(1, Math.min(50, k)));
+}
+
 module.exports = {
   PACKS_DIR, SECTIONS, slugify,
   listPacks, findPack, readPack, writePack, createPack, updatePack, removePack, isNearDupJournal,
   listSkillPacks, setSkill, listAbilities, setKind, parentByPrefix, setParent, recordApplied, recordCoUse,
-  touchUsed, packNameFromPath, matchPacks, reindex, markIndexDirty,
+  touchUsed, packNameFromPath, matchPacks, searchLines, reindex, markIndexDirty,
   archivePack, restorePack, listArchived,
   readProvenance, provenanceOf, setProvenance, recordForegroundWrite,
 };