@jeffober/thatch 0.1.48 → 0.2.0

package/src/os-args.ts

@@ -0,0 +1,99 @@
+import { readFileSync } from "node:fs";
+
+/**
+ * Parses the session id a harness was started to continue from an argument
+ * list (`opencode -s <id>` / `--session <id>` / `--session=<id>`). Pure:
+ * the caller supplies the list (see startupSessionId for where it comes
+ * from). The framework passes no session id to plugins and resuming a
+ * session fires no events, so the command line is the only signal that a
+ * fresh harness is the new home of a continued session.
+ */
+export function startupSessionIdFromArgv(argv: string[]): string | null {
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-s" || arg === "--session") return argv[i + 1] ?? null;
+    if (arg.startsWith("--session=")) return arg.slice("--session=".length) || null;
+  }
+  return null;
+}
+
+/**
+ * Whether the harness was started with `-c`/`--continue` (continue the most
+ * recent session). Pure. Yargs-style boolean flags only: `--continue=false`
+ * reads as the negation, everything else as a plain switch. The session id
+ * itself is not on the command line - the harness resolves "most recent
+ * top-level session" at startup, which the plugin replicates via the SDK
+ * (continuesLastSessionId).
+ */
+export function continuesLastSessionFromArgv(argv: string[]): boolean {
+  for (const arg of argv) {
+    if (arg === "-c" || arg === "--continue") return true;
+    if (arg.startsWith("--continue=")) return arg.slice("--continue=".length) !== "false";
+  }
+  return false;
+}
+
+/**
+ * Picks the session `opencode -c` continues: the most recently updated
+ * top-level session. Pure; the caller supplies the session list from
+ * client.session.list() (directory-scoped, like the plugin's own client).
+ * The server's list order is not trusted - the TUI re-sorts by
+ * time.updated before picking, and so does this.
+ */
+export function continuesLastSessionId(
+  sessions: { id: string; parentID?: string; time?: { updated?: number } }[],
+): string | null {
+  return (
+    [...sessions]
+      .sort((a, b) => (b.time?.updated ?? 0) - (a.time?.updated ?? 0))
+      .find((s) => !s.parentID)?.id ?? null
+  );
+}
+
+// The plugin does not run in the process's main thread: opencode's TUI
+// spawns a worker thread (cli/tui/worker.js) to host the server, and worker
+// threads get their own argv (just the worker script) with none of the CLI
+// flags. The thread still shares the process's pid, so the OS-level command
+// line for our own pid is the real `opencode -s ses_...` invocation. Read it
+// from /proc on Linux or via ps on macOS. Returns [] when unavailable;
+// callers treat that as "no session flag". The readers are injectable so
+// tests can drive each branch without a real /proc or ps.
+export interface OsArgsDeps {
+  /** Reads a file as UTF-8, throwing when it does not exist. */
+  readFile: (path: string) => string;
+  /** Runs `ps -p <pid> -o args=`; returns its exit code and stdout. */
+  ps: (pid: number) => { exitCode: number; stdout: string };
+}
+
+const defaultOsArgsDeps: OsArgsDeps = {
+  readFile: (path) => readFileSync(path, "utf8"),
+  ps: (pid) => {
+    const res = Bun.spawnSync(["ps", "-p", String(pid), "-o", "args="]);
+    return { exitCode: res.exitCode, stdout: res.stdout.toString() };
+  },
+};
+
+export function osProcessArgs(deps: OsArgsDeps = defaultOsArgsDeps, pid = process.pid): string[] {
+  try {
+    // Linux: cmdline is NUL-separated argv, exact and cheap.
+    return deps.readFile("/proc/self/cmdline").split("\0").filter(Boolean);
+  } catch {
+    // macOS has no /proc; ask ps for this pid's full command. Splitting on
+    // whitespace is safe for our purpose: session ids never contain spaces.
+    try {
+      const res = deps.ps(pid);
+      if (res.exitCode !== 0) return [];
+      return res.stdout.trim().split(/\s+/).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+}
+
+// Resolve the session id this harness was launched to resume, if any:
+// prefer the thread-local argv (covers tests and any non-worker host), then
+// fall back to the process's OS-level command line (the real harness path).
+// The caller passes the OS command line in so it is read once per init.
+export function startupSessionId(osArgs: string[]): string | null {
+  return startupSessionIdFromArgv(process.argv) ?? startupSessionIdFromArgv(osArgs);
+}

package/src/prompts.ts

@@ -50,6 +50,29 @@ auto-reply unless the message bears on a task you are already doing; do not
 forward or chain messages reflexively. Name the sender when relaying a
 message to the user, and let the user decide when coordination is ambiguous.`;
 
+// Class-lesson guidance, shared verbatim by both prompt variants (the
+// paragraphs name no tools, so the twins need no per-host spellings). See
+// the LLM-alerts review loop (Sept 2026): class-level lessons go into the
+// memory/behavior/prediction systems with matchers worded for the broadest
+// semantic trigger surface.
+const classLessonPredictionSection = `
+The same class discipline applies to judgment errors: when a review round,
+bug, or incident reveals a class of bad calls (not just one), record the
+pattern as a prediction. Word the matcher for semantic matching - describe
+the situation a future decision will be in - then re-read it against
+everything that ought to trigger it and widen the wording until it does.`;
+
+const classLessonBehaviorSection = `
+When a review round, bug fix, or incident reveals a CLASS of mistake you are
+prone to (rather than a one-off), persist the class so it resurfaces where
+the work happens: save a memory stating the class and how to detect it, and
+codify a behavior whose situation text describes the context a future
+session will be in when that class of trouble starts. Word the situation for
+semantic matching: after writing it, re-read it against everything that
+ought to trigger it and widen the wording to the broadest surface of the
+class - a matcher that only names this incident never fires for the next
+one.`;
+
 export function systemPrompt(repo: string, chatEnabled = true): string {
   return `# Persistence
 
@@ -225,6 +248,8 @@ reviewing your changes, or asked you to review their changes or another LLM's
 changes. Before creating a new prediction, query for an existing one and
 reinforce or adjust it when possible.
 
+${classLessonPredictionSection}
+
 ## Situational Behaviors
 
 A model of your own operational rules is maintained by the behavior engine.
@@ -245,6 +270,8 @@ way that is about your own operational discipline (not a user preference):
 2. Use thatch_behavior_feedback when surfaced behaviors fire to ham/spam them
 3. Use thatch_behavior_delete to remove a rule created in error
 
+${classLessonBehaviorSection}
+
 Do not codify rules that make you lazier or less thorough. Rules should encode
 discipline, not shortcuts.
 
@@ -489,6 +516,8 @@ reviewing your changes, or asked you to review their changes or another LLM's
 changes. Before creating a new prediction, query for an existing one and
 reinforce or adjust it when possible.
 
+${classLessonPredictionSection}
+
 ## Situational Behaviors
 
 A model of your own operational rules is maintained by the behavior engine.
@@ -509,6 +538,8 @@ way that is about your own operational discipline (not a user preference):
 2. Use behavior_feedback when surfaced behaviors fire to ham/spam them
 3. Use behavior_delete to remove a rule created in error
 
+${classLessonBehaviorSection}
+
 Do not codify rules that make you lazier or less thorough. Rules should encode
 discipline, not shortcuts.
 
@@ -622,6 +653,17 @@ export function versionWarningNudge(message: string): string {
   return `[thatch] ${message} This is a system nudge, not user input. After informing the user, continue with their request.`;
 }
 
+/**
+ * The version-skew message: the on-disk package version is newer than the
+ * running one (the user upgraded but the host kept the old plugin loaded).
+ * Standalone so the wording is testable. Host-specific remedies (v2's
+ * "opencode plugin update", a shim-shape reminder) are planned but not yet
+ * appended by any caller - see docs/dev/features/opencode-plugin.md.
+ */
+export function skewWarningText(onDisk: string, running: string): string {
+  return `thatch was upgraded to v${onDisk} but this session is running v${running}. Restart opencode to apply the update.`;
+}
+
 // ---------------------------------------------------------------------------
 // Prompt cores - behavior instruction bodies shared by nudges and /thatch
 // command files (src/commands.ts). A core is the host-agnostic instruction
@@ -676,7 +718,7 @@ export function reflectCore(tool: ToolNamer): string {
 }
 
 /**
- * Extraction nudge with escalation. Both the opencode plugin (src/index.ts)
+ * Extraction nudge with escalation. Both the opencode plugin (src/runtime.ts)
  * and the Claude Code/Cursor CLI (bin/thatch flush-tools) call this with
  * their respective tool name prefix. The missedCount parameter tracks
  * consecutive nudges delivered without any memory_remember call in between,
@@ -884,6 +926,40 @@ ${lines.join("\n")}
 This is a system notification, not user input. Decide whether to act now or keep waiting - the user's instructions from when the watch was created govern how to handle it.${detailHint} This notification is not approval to advance other pending work, with one exception: if this watch was created to gate work the user already greenlit (for example "wait for CI, then merge"), it is the continuation signal for exactly that work - proceed with it.${cadence} If you act, tell the user what you did and why; if not, stop and wait.`;
 }
 
+/**
+ * Watcher re-arm notice for a session resuming after a restart. The session's
+ * own dormant watcher definitions were re-armed into the live registry;
+ * delivered as a synthetic part on the session's first message so the model
+ * knows proactive notifications will resume without a re-registration step.
+ * Expired definitions (TTL passed while the session was away) are reported,
+ * not silently dropped - a watch the user expected to be waiting should be
+ * known to be gone.
+ */
+export function watcherRearmNotice(targets: string[], expiredCount: number, failedCount = 0): string {
+  const list = targets.join(", ");
+  const expired = expiredCount > 0
+    ? `\n${expiredCount} earlier watcher${expiredCount === 1 ? "" : "s"} expired while the session was away and were not re-armed.`
+    : "";
+  const failed = failedCount > 0
+    ? `\n${failedCount} watcher${failedCount === 1 ? "" : "s"} could not be re-armed (the watched target is gone or unreachable) and was dropped.`
+    : "";
+  return `[thatch] ${targets.length} watcher${targets.length === 1 ? "" : "s"} re-armed after the restart: ${list}.${expired}${failed}
+No re-registration is needed; notifications will arrive here as usual. This is a system notice, not user input - carry on with the user's request.`;
+}
+
+/**
+ * Watcher death notice: a dormant watcher's owning session died with its
+ * harness and has not been resumed. Delivered as a synthetic part to a live
+ * session in the same project, so a watch that will never fire is at least
+ * heard about instead of silently vanishing. Pointer-only: target labels,
+ * never event content.
+ */
+export function watcherDeathNotice(targets: string[]): string {
+  const list = targets.join(", ");
+  return `[thatch] ${targets.length} watcher${targets.length === 1 ? " died" : "s died"} with session${targets.length === 1 ? "" : "s"} that are no longer running: ${list}.
+${targets.length === 1 ? "It" : "They"} will re-arm automatically if ${targets.length === 1 ? "that session is" : "those sessions are"} resumed. This is a system notice, not user input - carry on with the user's request.`;
+}
+
 /**
  * Chat wake-up notification for the poller's promptAsync delivery. Injected
  * as a synthetic part that triggers a model turn. Pointer-only like watcher