talon-agent 4.6.1 → 5.0.1

package/src/core/background/{plan-alerts.ts → pulse/plan-alerts.ts}

@@ -11,9 +11,9 @@
  * also what covers windows the plan reports no reset for).
  */
 
-import { getPooledBackend } from "../engine/backend-controller/index.js";
-import { log, logWarn } from "../../util/log.js";
-import { formatSmartTimestamp } from "../../util/time.js";
+import { getPooledBackend } from "../../engine/backend-controller/index.js";
+import { log, logWarn } from "../../../util/log.js";
+import { formatSmartTimestamp } from "../../../util/time.js";
 
 const CHECK_INTERVAL_MS = 5 * 60_000;
 

package/src/core/background/{pulse.ts → pulse/pulse.ts}

@@ -8,16 +8,19 @@
  * Knows nothing about the backend or frontend — uses the dispatcher.
  */
 
-import { execute, getActiveCount } from "../engine/dispatcher.js";
+import { execute, getActiveCount } from "../../engine/dispatcher.js";
 import {
   setChatPulse,
   getRegisteredPulseChats,
   getChatSettings,
   setPulseLastCheckMsgId,
-} from "../../storage/chat-settings.js";
-import { getRecentHistory, getLatestMessageId } from "../../storage/history.js";
-import { log, logError } from "../../util/log.js";
-import { formatSmartTimestamp } from "../../util/time.js";
+} from "../../../storage/chat-settings.js";
+import {
+  getRecentHistory,
+  getLatestMessageId,
+} from "../../../storage/history.js";
+import { log, logError } from "../../../util/log.js";
+import { formatSmartTimestamp } from "../../../util/time.js";
 
 // ── State ────────────────────────────────────────────────────────────────────
 

package/src/core/background/triggers/command.ts

@@ -6,8 +6,8 @@
 
 import { spawnSync } from "node:child_process";
 import type { Trigger } from "../../../storage/triggers.js";
-import { selfInvocation } from "../../../util/mcp-launcher.js";
-import { LUA_RUN_SUBCOMMAND } from "../../scripting/lua-runner.js";
+import { selfInvocation } from "../../mcp-hub/launcher.js";
+import { LUA_RUN_SUBCOMMAND } from "../../scripts/lua.js";
 
 export function commandForLanguage(
   lang: Trigger["language"],

package/src/{util → core/config}/harden.ts

@@ -14,7 +14,7 @@
  */
 
 import { chmodSync } from "node:fs";
-import { dirs, files } from "./paths.js";
+import { dirs, files } from "../../util/paths.js";
 
 const OWNER_DIR = 0o700;
 const OWNER_FILE = 0o600;

package/src/core/config/index.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, mkdirSync } from "node:fs";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { dirs, files as pathFiles } from "../../util/paths.js";
-import { hardenTalonPermissions } from "../../util/harden.js";
+import { hardenTalonPermissions } from "./harden.js";
 import { setTimezone } from "../../util/time.js";
 import { BACKEND_IDS } from "../agent-runtime/model-ref.js";
 import { REASONING_LEVEL_ORDER } from "../models/reasoning-levels.js";
@@ -557,16 +557,11 @@ const configSchema = z.object({
   // Playwright — headless browser automation via MCP
   playwright: playwrightConfigSchema.optional(),
 
-  // Soul — compiled, self-organizing identity kernel (experimental).
-  // Off by default; when enabled, the projected identity surface is injected
-  // into the system prompt and the organic pass runs on the dream cadence.
-  soul: z
-    .object({
-      enabled: z.boolean().default(false),
-      /** Kernel persistence path (default: ~/.talon/data/soul.json) */
-      path: z.string().min(1).optional(),
-    })
-    .optional(),
+  // Soul — the compiled identity kernel, removed in #953. The root schema
+  // is `.strict()`, so a key that simply disappeared would make every
+  // existing config.json fail to parse; accepted and ignored instead, with
+  // one warning at load so the operator knows to drop it.
+  soul: z.unknown().optional(),
 
   // Discord — discord.js v14-based frontend
   discord: discordConfigSchema.optional(),
@@ -741,6 +736,15 @@ export function loadConfig(): TalonConfig {
 
   const parsed = configSchema.parse(fileConfig);
 
+  // The soul kernel is gone (#953). Its config block still parses so an
+  // existing config.json keeps loading, but it no longer does anything —
+  // say so once rather than silently ignoring it.
+  if (parsed.soul !== undefined) {
+    console.warn(
+      `Ignoring "soul" in ${CONFIG_FILE}: the soul kernel was removed; its message taps now write to the memory store. Remove the key.`,
+    );
+  }
+
   // Unified memory section: mirror the selected backend onto the per-plugin
   // section the loaders consume (builtins.ts reads config.mempalace /
   // config.mem0). The memory section wins over a legacy section when both
@@ -827,7 +831,7 @@ export function primaryFrontend(config: TalonConfig): string {
  * the config. Multi-frontend deployments need per-chat prompt
  * flavours (a native-app chat must get native.md guidance, not the
  * telegram.md that `frontends[0]` happens to be) — the per-session
- * snapshot layer (backend/shared/system-prompt.ts) calls this with the
+ * snapshot layer (backend/runtime/prompt/system-prompt.ts) calls this with the
  * chat's owning frontend and freezes the result per session.
  */
 export function buildSystemPromptPartsFor(

package/src/{util → core/daemon}/boot-timer.ts

@@ -4,7 +4,9 @@
  * has an answer in the log instead of a profiler session.
  */
 
-const phases: { label: string; ms: number }[] = [];
+export type BootPhaseSample = { label: string; ms: number };
+
+const phases: BootPhaseSample[] = [];
 
 /** Run one startup phase and remember how long it took. */
 export async function bootPhase<T>(
@@ -25,6 +27,18 @@ export function bootReport(now = Math.round(process.uptime() * 1000)): string {
   return parts.length ? `${now}ms (${parts.join(", ")})` : `${now}ms`;
 }
 
+/**
+ * The recorded phases, in the order they completed.
+ *
+ * `util/` is a leaf (.dependency-cruiser.cjs: util-is-a-leaf), so this
+ * module cannot write to the metrics store itself. It hands the samples
+ * out instead and `core/daemon/resource-sampler.ts` turns them into
+ * `boot.<phase>_ms` histograms.
+ */
+export function bootPhases(): readonly BootPhaseSample[] {
+  return phases;
+}
+
 /** Test seam. */
 export function resetBootPhases(): void {
   phases.length = 0;

package/src/core/daemon/pidfile.ts

@@ -11,7 +11,7 @@
  *     gateway may fall back to a different port on EADDRINUSE, so the
  *     port is only known at runtime).
  *   - Removal is guarded by pid. During a `/restart` handoff
- *     (util/respawn.ts) the successor overwrites the file with its own
+ *     (./respawn.ts) the successor overwrites the file with its own
  *     pid *before* the dying parent finishes its graceful shutdown — an
  *     unconditional unlink there would orphan the new daemon, making
  *     `talon stop`/`talon restart` report "not running" and spawn

package/src/core/daemon/resource-sampler.ts

@@ -0,0 +1,121 @@
+/**
+ * The daemon's accounting of its own resources — boot cost and resident
+ * memory. Measurement only: nothing here changes a prompt byte or a
+ * turn's behaviour.
+ *
+ * Why these numbers exist (docs/ts-migration-plan.md, Phase 0 — Measure):
+ * the migration plan's entry gate is "numbers in hand", and its kill
+ * criterion is stated in terms of the control plane's share of a turn plus
+ * "RSS is acceptable". Neither can be argued without a baseline, and the
+ * metrics store had latency and tokens but nothing about the process
+ * itself.
+ *
+ *   - `boot.total_ms` — process start → frontends listening. The figure
+ *     `Ready in …` already logs, kept as a distribution so successive
+ *     restarts can be compared instead of grepped.
+ *   - `boot.<phase>_ms` — each awaited startup phase (`./boot-timer.ts`
+ *     records them), so a slow boot names its own culprit.
+ *   - `boot.rss_mb` / `boot.heap_mb` — what the process costs the moment
+ *     it is serving, before any turn has run. The floor an alternative
+ *     runtime or language would have to beat.
+ *   - `rss.mb`, `heap_used.mb`, `external.mb`, `handles.count` — the same
+ *     picture sampled every minute for the process lifetime, which is what
+ *     answers "idle RSS" and "does it creep?" (the Phase 1 soak log asks
+ *     exactly this and is currently filled in by hand).
+ *
+ * Sampling must never throw: this runs on a timer inside a live daemon,
+ * and a metric that can take the process down is worse than no metric.
+ */
+
+import { bootPhases } from "./boot-timer.js";
+import { recordHistogram } from "../../storage/metrics.js";
+
+/** One minute. Idle RSS moves slowly; a tighter loop would only add noise. */
+const SAMPLE_INTERVAL_MS = 60_000;
+
+const BYTES_PER_MB = 1024 * 1024;
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+function mb(bytes: number): number {
+  return Math.round(bytes / BYTES_PER_MB);
+}
+
+/**
+ * `frontends start` → `boot.frontends_start_ms`. Phase labels are prose
+ * ("backend + dispatcher"), metric names are not.
+ */
+function slug(label: string): string {
+  return (
+    label
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "_")
+      .replace(/^_+|_+$/g, "") || "unnamed"
+  );
+}
+
+/** How many active handles the runtime reports, when it can report it. */
+function activeResourceCount(): number | undefined {
+  // Node 18.11+ / Bun. Absent on older runtimes, and there is no cheap
+  // supported substitute — the metric is simply skipped there.
+  const read = (process as { getActiveResourcesInfo?: () => readonly string[] })
+    .getActiveResourcesInfo;
+  if (typeof read !== "function") return undefined;
+  const info = read.call(process);
+  return Array.isArray(info) ? info.length : undefined;
+}
+
+/** Record one resident-memory sample. Safe to call at any time. */
+function sampleResources(): void {
+  try {
+    const mem = process.memoryUsage();
+    recordHistogram("rss.mb", mb(mem.rss));
+    recordHistogram("heap_used.mb", mb(mem.heapUsed));
+    recordHistogram("external.mb", mb(mem.external));
+    const handles = activeResourceCount();
+    if (handles !== undefined) recordHistogram("handles.count", handles);
+  } catch {
+    // A failed sample is a missing data point, never a failed daemon.
+  }
+}
+
+/**
+ * Fold the boot into the metrics store: the total, every phase the boot
+ * timer recorded, and the memory the process holds now that it is serving.
+ *
+ * `totalMs` defaults to process uptime — the same figure `bootReport()`
+ * prints, so the log line and the histogram cannot disagree.
+ */
+export function recordBootMetrics(
+  totalMs = Math.round(process.uptime() * 1000),
+): void {
+  try {
+    recordHistogram("boot.total_ms", totalMs);
+    for (const phase of bootPhases()) {
+      recordHistogram(`boot.${slug(phase.label)}_ms`, phase.ms);
+    }
+    const mem = process.memoryUsage();
+    recordHistogram("boot.rss_mb", mb(mem.rss));
+    recordHistogram("boot.heap_mb", mb(mem.heapUsed));
+  } catch {
+    // As above: measurement never breaks the boot it is measuring.
+  }
+}
+
+/**
+ * Start the idle sampler. Unref'd, so it never holds the event loop open
+ * and never keeps a daemon alive that is otherwise done. Idempotent —
+ * a second call is a no-op rather than a second timer.
+ */
+export function startResourceSampler(): void {
+  if (timer) return;
+  timer = setInterval(sampleResources, SAMPLE_INTERVAL_MS);
+  timer.unref();
+}
+
+/** Stop the idle sampler (shutdown, and the test seam). */
+export function stopResourceSampler(): void {
+  if (!timer) return;
+  clearInterval(timer);
+  timer = null;
+}

package/src/{util → core/daemon}/respawn.ts

@@ -29,7 +29,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { log, logError } from "./log.js";
+import { log, logError } from "../../util/log.js";
 
 let pendingReason: string | null = null;
 

package/src/core/doctor/index.ts

@@ -423,7 +423,7 @@ export async function collectDoctorReport(opts: {
   // is which is the difference between "why didn't my prompt update?"
   // and a one-line answer.
   {
-    const { promptSeedReport } = await import("../../util/workspace.js");
+    const { promptSeedReport } = await import("../vfs/workspace.js");
     try {
       const { tracking, edited } = promptSeedReport();
       if (tracking.length + edited.length > 0) {

package/src/core/engine/dispatcher.ts

@@ -10,6 +10,7 @@
 
 import type { ExecuteParams, ExecuteResult } from "../types.js";
 import { formatRelayBlock, takePendingRelay } from "./cross-chat-relay.js";
+import { recordMessageSignal } from "../memory/taps.js";
 import { log } from "../../util/log.js";
 import { taskTable, type KillOutcome } from "../tasks/index.js";
 import { initWeaver, type Weaver, type WeaverDeps } from "../weaver/index.js";
@@ -71,9 +72,24 @@ export function stopAllTurns(): number {
  * Every turn for every frontend and every source funnels through here,
  * which makes it the one place a cross-chat reply can be folded in
  * without teaching each frontend about the relay.
+ *
+ * It is also where the memory tap lives, for the same reason: a
+ * directive is a directive whether it arrives over Telegram, Discord,
+ * WhatsApp, Teams, the native bridge or the terminal, and the tap used
+ * to see only one of them. Only `source: "message"` is tapped — a pulse,
+ * a cron job or a trigger is Talon prompting itself, and "always reply
+ * in one line" written by a scheduler is not standing human intent.
  */
 export async function execute(params: ExecuteParams): Promise<ExecuteResult> {
   if (!weaver) throw new Error("Dispatcher not initialized");
+  // Fire-and-forget: the tap is a synchronous store write that must not
+  // be able to delay or fail the turn (it swallows its own errors).
+  if (params.source === "message")
+    recordMessageSignal({
+      text: params.prompt,
+      chatKey: params.chatId,
+      ...(params.senderName ? { actor: params.senderName } : {}),
+    });
   const relayed = takePendingRelay(params.chatId);
   const prompt = relayed.length
     ? formatRelayBlock(relayed) + params.prompt

package/src/core/engine/gateway-actions/cron.ts

@@ -12,8 +12,8 @@ import {
   describeSchedule,
   nextRunAt,
 } from "../../../storage/cron.js";
-import { runJobNow } from "../../background/cron.js";
-import { parseCronSpec } from "../../background/cron-spec.js";
+import { runJobNow } from "../../background/cron/scheduler.js";
+import { parseCronSpec } from "../../background/cron/spec.js";
 import { log } from "../../../util/log.js";
 import type { Backend } from "../../agent-runtime/capabilities.js";
 import {

package/src/core/engine/gateway-actions/fetch-url.ts

@@ -18,7 +18,7 @@ import {
   isHtmlContent,
   isTextContent,
   matchesBinaryKind,
-} from "../../../util/web-content.js";
+} from "../../tools/content/web-content.js";
 import { dirs } from "../../../util/paths.js";
 import type { SharedActionHandlers } from "./types.js";
 

package/src/core/engine/gateway-actions/index.ts

@@ -12,6 +12,7 @@
  *   - `cron`      — scheduled-job CRUD
  *   - `triggers`  — long-running watcher-script CRUD
  *   - `goals`     — persistent multi-turn objectives
+ *   - `memory`    — remember / recall / forget over the typed memory store
  *   - `scripts`   — reusable agent-authored scripts
  *   - `skills`    — markdown workflows
  *   - `plugins`   — plugin hot-reload
@@ -28,6 +29,7 @@ import { fetchUrlHandlers } from "./fetch-url.js";
 import { cronHandlers } from "./cron.js";
 import { triggerHandlers } from "./triggers.js";
 import { goalHandlers } from "./goals.js";
+import { memoryHandlers } from "./memory.js";
 import { scriptHandlers } from "./scripts.js";
 import { skillHandlers } from "./skills.js";
 import { pluginHandlers } from "./plugins.js";
@@ -41,7 +43,7 @@ import {
   whatsappAccountHandlers,
   whatsappAccountChatFreeActions,
 } from "./whatsapp-account.js";
-import { nativeHandlers } from "./native.js";
+import { nativeHandlers } from "./native/index.js";
 
 // Null-prototype so a request `action` of "toString" / "constructor" / etc.
 // can't resolve an inherited Object.prototype method — `handlers[action]` only
@@ -52,6 +54,7 @@ const handlers: SharedActionHandlers = Object.assign(Object.create(null), {
   ...cronHandlers,
   ...triggerHandlers,
   ...goalHandlers,
+  ...memoryHandlers,
   ...scriptHandlers,
   ...skillHandlers,
   ...pluginHandlers,