talon-agent 3.0.5 → 3.1.1

package/src/storage/session-record.ts

@@ -0,0 +1,220 @@
+/**
+ * Session record shapes + their constructors and normalisers — the
+ * vocabulary both the public store (storage/sessions.ts) and the
+ * repository (repositories/sessions-repo.ts) speak, extracted so the
+ * repo never has to import the store (which imports the repo).
+ *
+ * Mutation logic (fold/add/bucket) stays in the store; this module owns
+ * only "what a well-formed record looks like" and "how a raw JSON blob
+ * becomes one".
+ */
+
+export type SessionUsage = {
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCacheRead: number;
+  totalCacheWrite: number;
+  /** Last turn's total prompt tokens (cumulative across all API calls in the turn, including tool-use loops). */
+  lastPromptTokens: number;
+  /** Actual context window fill from the last API call (last iteration's prompt tokens). */
+  contextTokens: number;
+  /** Model's context window size in tokens (from SDK modelUsage). */
+  contextWindow: number;
+  /** Number of API round-trips in the last turn (tool-use steps). */
+  numApiCalls: number;
+  /** Estimated cost in USD. */
+  estimatedCostUsd: number;
+  /** Total response time in ms (for averaging). */
+  totalResponseMs: number;
+  /** Last response time in ms. */
+  lastResponseMs: number;
+  /** Fastest response time in ms. */
+  fastestResponseMs: number;
+};
+
+export type MetricsCounterSet = {
+  queries: number;
+  toolCalls: number;
+  turnsWithTools: number;
+  apiCalls: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  failedTurns: number;
+  flowViolationRetries: number;
+  flowViolationCapExhausted: number;
+  trailingTextDropped: number;
+};
+
+export type MetricsLatencyAgg = {
+  count: number;
+  sumMs: number;
+  minMs: number;
+  maxMs: number;
+};
+
+export type MetricsGrain = {
+  counters: MetricsCounterSet;
+  latency: MetricsLatencyAgg;
+  toolCallsByName: Record<string, number>;
+  backend: Record<string, MetricsCounterSet & { latency: MetricsLatencyAgg }>;
+  cacheHitPercent: MetricsLatencyAgg;
+  toolCallsPerTurn: MetricsLatencyAgg;
+  apiCallsPerTurn: MetricsLatencyAgg;
+};
+
+export type SessionMetrics = {
+  lifetime: MetricsGrain;
+  buckets: Record<string, MetricsGrain>;
+};
+
+export type SessionState = {
+  /** Backend server-side session ID. */
+  sessionId: string | undefined;
+  /** Turn count. */
+  turns: number;
+  /** Last activity timestamp. */
+  lastActive: number;
+  /** Created timestamp. */
+  createdAt: number;
+  /** Cumulative usage stats. */
+  usage: SessionUsage;
+  /** Persistent per-session metrics, bucketed by UTC day. */
+  metrics: SessionMetrics;
+  /** ID of the last message sent by the bot in this chat. */
+  lastBotMessageId?: number;
+  /** Descriptive session name derived from first message. */
+  sessionName?: string;
+  /** Model used for this session's cost tracking. */
+  lastModel?: string;
+};
+
+export const emptyUsage = (): SessionUsage => ({
+  totalInputTokens: 0,
+  totalOutputTokens: 0,
+  totalCacheRead: 0,
+  totalCacheWrite: 0,
+  lastPromptTokens: 0,
+  contextTokens: 0,
+  contextWindow: 0,
+  numApiCalls: 0,
+  estimatedCostUsd: 0,
+  totalResponseMs: 0,
+  lastResponseMs: 0,
+  fastestResponseMs: Infinity,
+});
+
+export const emptyCounters = (): MetricsCounterSet => ({
+  queries: 0,
+  toolCalls: 0,
+  turnsWithTools: 0,
+  apiCalls: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  failedTurns: 0,
+  flowViolationRetries: 0,
+  flowViolationCapExhausted: 0,
+  trailingTextDropped: 0,
+});
+
+export const emptyLatency = (): MetricsLatencyAgg => ({
+  count: 0,
+  sumMs: 0,
+  minMs: Infinity,
+  maxMs: 0,
+});
+
+export const emptyGrain = (): MetricsGrain => ({
+  counters: emptyCounters(),
+  latency: emptyLatency(),
+  toolCallsByName: {},
+  backend: {},
+  cacheHitPercent: emptyLatency(),
+  toolCallsPerTurn: emptyLatency(),
+  apiCallsPerTurn: emptyLatency(),
+});
+
+export const emptyMetrics = (): SessionMetrics => ({
+  lifetime: emptyGrain(),
+  buckets: {},
+});
+
+function normaliseLatency(raw: unknown): MetricsLatencyAgg {
+  const r = raw as Partial<MetricsLatencyAgg> | undefined;
+  const count =
+    typeof r?.count === "number" && Number.isFinite(r.count) ? r.count : 0;
+  return {
+    count,
+    sumMs:
+      typeof r?.sumMs === "number" && Number.isFinite(r.sumMs) ? r.sumMs : 0,
+    minMs:
+      typeof r?.minMs === "number" && Number.isFinite(r.minMs)
+        ? r.minMs
+        : count > 0
+          ? 0
+          : Infinity,
+    maxMs:
+      typeof r?.maxMs === "number" && Number.isFinite(r.maxMs) ? r.maxMs : 0,
+  };
+}
+
+function normaliseCounters(raw: unknown): MetricsCounterSet {
+  const base = emptyCounters();
+  const r = raw as Partial<MetricsCounterSet> | undefined;
+  for (const key of Object.keys(base) as Array<keyof MetricsCounterSet>) {
+    const value = r?.[key];
+    if (typeof value === "number" && Number.isFinite(value)) base[key] = value;
+  }
+  return base;
+}
+
+function normaliseGrain(raw: unknown): MetricsGrain {
+  const r = raw as Partial<MetricsGrain> | undefined;
+  const grain = emptyGrain();
+  grain.counters = normaliseCounters(r?.counters);
+  grain.latency = normaliseLatency(r?.latency);
+  grain.cacheHitPercent = normaliseLatency(r?.cacheHitPercent);
+  grain.toolCallsPerTurn = normaliseLatency(r?.toolCallsPerTurn);
+  grain.apiCallsPerTurn = normaliseLatency(r?.apiCallsPerTurn);
+  if (r?.toolCallsByName && typeof r.toolCallsByName === "object") {
+    for (const [key, value] of Object.entries(r.toolCallsByName)) {
+      if (typeof value === "number" && Number.isFinite(value)) {
+        grain.toolCallsByName[key] = value;
+      }
+    }
+  }
+  if (r?.backend && typeof r.backend === "object") {
+    for (const [key, value] of Object.entries(r.backend)) {
+      grain.backend[key] = {
+        ...normaliseCounters(value),
+        latency: normaliseLatency((value as { latency?: unknown }).latency),
+      };
+    }
+  }
+  return grain;
+}
+
+/**
+ * Coerce an untrusted/persisted metrics blob into a well-formed
+ * SessionMetrics: missing fields backfilled, non-finite numbers dropped,
+ * JSON's `minMs: null` (Infinity doesn't survive JSON.stringify) restored
+ * to the domain sentinel. Runs once at the load boundary (sessions-repo);
+ * in-memory metrics stay well-formed by construction after that.
+ */
+export function normaliseMetrics(metrics: unknown): SessionMetrics {
+  const raw = metrics as Partial<SessionMetrics> | undefined;
+  const result: SessionMetrics = {
+    lifetime: normaliseGrain(raw?.lifetime),
+    buckets: {},
+  };
+  if (raw?.buckets && typeof raw.buckets === "object") {
+    for (const [day, grain] of Object.entries(raw.buckets)) {
+      if (/^\d{4}-\d{2}-\d{2}$/.test(day))
+        result.buckets[day] = normaliseGrain(grain);
+    }
+  }
+  return result;
+}

package/src/storage/sessions.ts

@@ -24,87 +24,28 @@ import { files } from "../util/paths.js";
 import { importLegacyJson } from "./legacy-import.js";
 import * as repo from "./repositories/sessions-repo.js";
 
-export type SessionUsage = {
-  totalInputTokens: number;
-  totalOutputTokens: number;
-  totalCacheRead: number;
-  totalCacheWrite: number;
-  /** Last turn's total prompt tokens (cumulative across all API calls in the turn, including tool-use loops). */
-  lastPromptTokens: number;
-  /** Actual context window fill from the last API call (last iteration's prompt tokens). */
-  contextTokens: number;
-  /** Model's context window size in tokens (from SDK modelUsage). */
-  contextWindow: number;
-  /** Number of API round-trips in the last turn (tool-use steps). */
-  numApiCalls: number;
-  /** Estimated cost in USD. */
-  estimatedCostUsd: number;
-  /** Total response time in ms (for averaging). */
-  totalResponseMs: number;
-  /** Last response time in ms. */
-  lastResponseMs: number;
-  /** Fastest response time in ms. */
-  fastestResponseMs: number;
-};
-
-export type MetricsCounterSet = {
-  queries: number;
-  toolCalls: number;
-  turnsWithTools: number;
-  apiCalls: number;
-  inputTokens: number;
-  outputTokens: number;
-  cacheReadTokens: number;
-  cacheWriteTokens: number;
-  failedTurns: number;
-  flowViolationRetries: number;
-  flowViolationCapExhausted: number;
-  trailingTextDropped: number;
-};
-
-export type MetricsLatencyAgg = {
-  count: number;
-  sumMs: number;
-  minMs: number;
-  maxMs: number;
-};
-
-export type MetricsGrain = {
-  counters: MetricsCounterSet;
-  latency: MetricsLatencyAgg;
-  toolCallsByName: Record<string, number>;
-  backend: Record<string, MetricsCounterSet & { latency: MetricsLatencyAgg }>;
-  cacheHitPercent: MetricsLatencyAgg;
-  toolCallsPerTurn: MetricsLatencyAgg;
-  apiCallsPerTurn: MetricsLatencyAgg;
-};
-
-export type SessionMetrics = {
-  lifetime: MetricsGrain;
-  buckets: Record<string, MetricsGrain>;
-};
-
-export type SessionState = {
-  /** Backend server-side session ID. */
-  sessionId: string | undefined;
-  /** Turn count. */
-  turns: number;
-  /** Last activity timestamp. */
-  lastActive: number;
-  /** Created timestamp. */
-  createdAt: number;
-  /** Cumulative usage stats. */
-  usage: SessionUsage;
-  /** Persistent per-session metrics, bucketed by UTC day. */
-  metrics: SessionMetrics;
-  /** ID of the last message sent by the bot in this chat. */
-  lastBotMessageId?: number;
-  /** Descriptive session name derived from first message. */
-  sessionName?: string;
-  /** Model used for this session's cost tracking. */
-  lastModel?: string;
-};
-
+export type {
+  MetricsCounterSet,
+  MetricsGrain,
+  MetricsLatencyAgg,
+  SessionMetrics,
+  SessionState,
+  SessionUsage,
+} from "./session-record.js";
+export { emptyMetrics, normaliseMetrics } from "./session-record.js";
+import {
+  emptyCounters,
+  emptyGrain,
+  emptyLatency,
+  emptyMetrics,
+  emptyUsage,
+  type MetricsCounterSet,
+  type MetricsGrain,
+  type MetricsLatencyAgg,
+  type SessionMetrics,
+  type SessionState,
+  type SessionUsage,
+} from "./session-record.js";
 // In-memory cache over the sessions table. Reads serve live references
 // from here; writes go through persist() so each mutation commits.
 const cache = new Map<string, SessionState>();
@@ -273,135 +214,6 @@ function persist(chatId: string, session: SessionState): void {
 
 // ── Core operations ─────────────────────────────────────────────────────────
 
-const emptyUsage = (): SessionUsage => ({
-  totalInputTokens: 0,
-  totalOutputTokens: 0,
-  totalCacheRead: 0,
-  totalCacheWrite: 0,
-  lastPromptTokens: 0,
-  contextTokens: 0,
-  contextWindow: 0,
-  numApiCalls: 0,
-  estimatedCostUsd: 0,
-  totalResponseMs: 0,
-  lastResponseMs: 0,
-  fastestResponseMs: Infinity,
-});
-
-const emptyCounters = (): MetricsCounterSet => ({
-  queries: 0,
-  toolCalls: 0,
-  turnsWithTools: 0,
-  apiCalls: 0,
-  inputTokens: 0,
-  outputTokens: 0,
-  cacheReadTokens: 0,
-  cacheWriteTokens: 0,
-  failedTurns: 0,
-  flowViolationRetries: 0,
-  flowViolationCapExhausted: 0,
-  trailingTextDropped: 0,
-});
-
-const emptyLatency = (): MetricsLatencyAgg => ({
-  count: 0,
-  sumMs: 0,
-  minMs: Infinity,
-  maxMs: 0,
-});
-
-const emptyGrain = (): MetricsGrain => ({
-  counters: emptyCounters(),
-  latency: emptyLatency(),
-  toolCallsByName: {},
-  backend: {},
-  cacheHitPercent: emptyLatency(),
-  toolCallsPerTurn: emptyLatency(),
-  apiCallsPerTurn: emptyLatency(),
-});
-
-export const emptyMetrics = (): SessionMetrics => ({
-  lifetime: emptyGrain(),
-  buckets: {},
-});
-
-function normaliseLatency(raw: unknown): MetricsLatencyAgg {
-  const r = raw as Partial<MetricsLatencyAgg> | undefined;
-  const count =
-    typeof r?.count === "number" && Number.isFinite(r.count) ? r.count : 0;
-  return {
-    count,
-    sumMs:
-      typeof r?.sumMs === "number" && Number.isFinite(r.sumMs) ? r.sumMs : 0,
-    minMs:
-      typeof r?.minMs === "number" && Number.isFinite(r.minMs)
-        ? r.minMs
-        : count > 0
-          ? 0
-          : Infinity,
-    maxMs:
-      typeof r?.maxMs === "number" && Number.isFinite(r.maxMs) ? r.maxMs : 0,
-  };
-}
-
-function normaliseCounters(raw: unknown): MetricsCounterSet {
-  const base = emptyCounters();
-  const r = raw as Partial<MetricsCounterSet> | undefined;
-  for (const key of Object.keys(base) as Array<keyof MetricsCounterSet>) {
-    const value = r?.[key];
-    if (typeof value === "number" && Number.isFinite(value)) base[key] = value;
-  }
-  return base;
-}
-
-function normaliseGrain(raw: unknown): MetricsGrain {
-  const r = raw as Partial<MetricsGrain> | undefined;
-  const grain = emptyGrain();
-  grain.counters = normaliseCounters(r?.counters);
-  grain.latency = normaliseLatency(r?.latency);
-  grain.cacheHitPercent = normaliseLatency(r?.cacheHitPercent);
-  grain.toolCallsPerTurn = normaliseLatency(r?.toolCallsPerTurn);
-  grain.apiCallsPerTurn = normaliseLatency(r?.apiCallsPerTurn);
-  if (r?.toolCallsByName && typeof r.toolCallsByName === "object") {
-    for (const [key, value] of Object.entries(r.toolCallsByName)) {
-      if (typeof value === "number" && Number.isFinite(value)) {
-        grain.toolCallsByName[key] = value;
-      }
-    }
-  }
-  if (r?.backend && typeof r.backend === "object") {
-    for (const [key, value] of Object.entries(r.backend)) {
-      grain.backend[key] = {
-        ...normaliseCounters(value),
-        latency: normaliseLatency((value as { latency?: unknown }).latency),
-      };
-    }
-  }
-  return grain;
-}
-
-/**
- * Coerce an untrusted/persisted metrics blob into a well-formed
- * SessionMetrics: missing fields backfilled, non-finite numbers dropped,
- * JSON's `minMs: null` (Infinity doesn't survive JSON.stringify) restored
- * to the domain sentinel. Runs once at the load boundary (sessions-repo);
- * in-memory metrics stay well-formed by construction after that.
- */
-export function normaliseMetrics(metrics: unknown): SessionMetrics {
-  const raw = metrics as Partial<SessionMetrics> | undefined;
-  const result: SessionMetrics = {
-    lifetime: normaliseGrain(raw?.lifetime),
-    buckets: {},
-  };
-  if (raw?.buckets && typeof raw.buckets === "object") {
-    for (const [day, grain] of Object.entries(raw.buckets)) {
-      if (/^\d{4}-\d{2}-\d{2}$/.test(day))
-        result.buckets[day] = normaliseGrain(grain);
-    }
-  }
-  return result;
-}
-
 function addLatency(agg: MetricsLatencyAgg, value: number): void {
   if (!Number.isFinite(value)) return;
   agg.count += 1;

package/src/storage/trigger-store.ts

@@ -27,66 +27,12 @@ import * as repo from "./repositories/triggers-repo.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
-export type TriggerLanguage = "bash" | "python" | "node" | "lua";
-
-export type TriggerStatus =
-  | "pending" // created, not yet spawned (transient)
-  | "running" // child process alive
-  | "fired" // exited 0 — fired final wake message
-  | "errored" // exited non-zero — fired error wake message
-  | "cancelled" // killed by user (trigger_cancel)
-  | "timed_out" // killed by hard timeout
-  | "terminated"; // killed by Talon shutdown / restart
-
-export type Trigger = {
-  id: string;
-  chatId: string;
-  numericChatId: number;
-  name: string;
-  language: TriggerLanguage;
-  /** Absolute path to the script body on disk. */
-  scriptPath: string;
-  /** Absolute path to the run log (interleaved stdout+stderr). */
-  logPath: string;
-  description?: string;
-  status: TriggerStatus;
-  createdAt: number;
-  startedAt?: number;
-  endedAt?: number;
-  /** PID of the child process while running (cleared on exit). */
-  pid?: number;
-  /** Linux /proc/<pid>/stat field 22 (start time in jiffies) captured at
-   *  spawn. Used by killOrphan to defend against PID reuse — start time is
-   *  monotonic per boot and unchanged by exec(), so a match guarantees the
-   *  current owner of the PID is the same process we spawned. Undefined on
-   *  non-Linux platforms. */
-  pidStarttime?: number;
-  /** Hard timeout in seconds. Default 24h, max 7d. */
-  timeoutSeconds: number;
-  /** Exit code on terminal status. */
-  exitCode?: number;
-  /** Total wake-ups fired for this trigger — sum of mid-run TALON_FIRE: lines
-   *  plus the terminal exit fire. Incremented every time fireWake() runs. */
-  fireCount: number;
-  lastFireAt?: number;
-  /** Truncated tail of the most recent fire payload (for diagnostics). */
-  lastFirePayload?: string;
-  lastError?: string;
-  /** If true, the trigger is respawned on Talon startup if it was still
-   *  active when Talon went down. Triggers in any terminal state
-   *  (fired/errored/cancelled) are NOT respawned — only ones interrupted
-   *  by Talon shutdown or crash. (Persistent triggers have no hard timeout,
-   *  so timed_out is unreachable for them — see spawnTrigger.) */
-  persistent?: boolean;
-  /**
-   * Optional model override for the wake-up turn — a model id valid on the
-   * chat's own backend. Unset = inherit the chat's model (preferred). When set,
-   * the fired wake-up runs on this (typically cheaper) model instead, while
-   * still resuming the chat session (restricted to the same backend so
-   * continuity is preserved).
-   */
-  model?: string;
-};
+export type {
+  Trigger,
+  TriggerLanguage,
+  TriggerStatus,
+} from "./repositories/triggers-repo.js";
+import type { Trigger, TriggerLanguage } from "./repositories/triggers-repo.js";
 
 // ── Constants ────────────────────────────────────────────────────────────────
 

package/src/types/assets.d.ts

@@ -0,0 +1,9 @@
+// Ambient declaration for prompt file-asset imports. The Bun-only
+// `import x from "./foo.md" with { type: "file" }` form (used only by the
+// generated embedded-prompts.ts, reached through the `bun` condition of
+// the `#prompt-assets` package import) resolves to the embedded file path
+// as a string. tsx/node never load that module — they use disk-prompts.ts.
+declare module "*.md" {
+  const path: string;
+  export default path;
+}

package/src/types/effort.ts

@@ -0,0 +1,12 @@
+/**
+ * Reasoning-effort vocabulary — a dependency-free primitive shared by
+ * every layer (storage persists it, core resolves it, backends map it
+ * to provider knobs, frontends render pickers over it).
+ *
+ * Lives in src/types/ (a leaf: imports nothing from src/) so the layers
+ * below core/ can name the type without importing upward. core/types.ts
+ * re-exports it for the engine-side importers.
+ */
+
+export type ReasoningEffortLevel =
+  "off" | "minimal" | "low" | "medium" | "high" | "max" | "xhigh";

package/src/util/config.ts

@@ -2,6 +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 "./paths.js";
+import { hardenTalonPermissions } from "./harden.js";
 import { setTimezone } from "./time.js";
 import { BACKEND_IDS } from "../core/agent-runtime/model-ref.js";
 import {
@@ -137,6 +138,8 @@ const frontendEnum = z.enum([
  * Defaults are loopback-only and unauthenticated (single-machine use). To
  * reach Talon remotely, set `host: "0.0.0.0"` and a `token` — the bridge
  * then requires `Authorization: Bearer <token>` (or `?token=` for SSE).
+ * A non-loopback bind with no token auto-mints a persistent one
+ * (~/.talon/keys/bridge-token) rather than serving the LAN open.
  */
 const nativeConfigSchema = z
   .object({
@@ -150,8 +153,9 @@ const nativeConfigSchema = z
     host: z.string().default("127.0.0.1"),
     /**
      * Optional shared secret. When set, every request must present it as a
-     * bearer token (header) or `?token=` query param (SSE). Required in
-     * practice whenever `host` is not loopback.
+     * bearer token (header) or `?token=` query param (SSE). When unset on a
+     * non-loopback `host`, the bridge mints and persists one automatically
+     * (~/.talon/keys/bridge-token) — the network never gets an open bridge.
      */
     token: z.string().optional(),
     /**
@@ -596,9 +600,11 @@ function ensureConfigFile(): boolean {
   if (!existsSync(dirs.root)) mkdirSync(dirs.root, { recursive: true });
   if (!existsSync(dirs.data)) mkdirSync(dirs.data, { recursive: true });
   if (!existsSync(CONFIG_FILE)) {
+    // Owner-only from birth: the config accumulates bot tokens and API keys.
     writeFileAtomic.sync(
       CONFIG_FILE,
       JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n",
+      { mode: 0o600 },
     );
     return true;
   }
@@ -613,6 +619,7 @@ function ensureConfigFile(): boolean {
 
 export function loadConfig(): TalonConfig {
   ensureConfigFile();
+  hardenTalonPermissions();
   const fileConfig = normalizeDeprecatedFrontendConfig(loadConfigFile());
 
   // Runtime frontend override (TALON_FRONTEND_OVERRIDE). Lets the native

package/src/util/harden.ts

@@ -0,0 +1,50 @@
+/**
+ * At-rest permission hardening for ~/.talon/.
+ *
+ * The tree holds credentials (config.json carries bot tokens, API keys and
+ * the bridge token; .user-session is a full Telegram login) plus chat
+ * history and logs. Node creates most of it with umask defaults, so on a
+ * multi-user machine everything is group/world readable. This pass clamps
+ * the sensitive surface to owner-only on every boot — idempotent, cheap,
+ * and it repairs installs created before the tightened modes existed.
+ *
+ * Best-effort by design: a missing path just hasn't been created yet, and
+ * a chmod failure (read-only mount, foreign owner) must never block boot.
+ * Windows has no POSIX modes worth mapping, so the pass is a no-op there.
+ */
+
+import { chmodSync } from "node:fs";
+import { dirs, files } from "./paths.js";
+
+const OWNER_DIR = 0o700;
+const OWNER_FILE = 0o600;
+
+/** Owner-only directories: everything under them inherits the protection. */
+const HARDENED_DIRS: readonly string[] = [dirs.root, dirs.data, dirs.keys];
+
+/** Belt-and-braces owner-only files, should they ever move out of the tree. */
+const HARDENED_FILES: readonly string[] = [
+  files.config,
+  files.log,
+  files.database,
+  files.userSession,
+];
+
+/** Clamp permissions on the sensitive parts of ~/.talon/. */
+export function hardenTalonPermissions(): void {
+  if (process.platform === "win32") return;
+  for (const dir of HARDENED_DIRS) {
+    try {
+      chmodSync(dir, OWNER_DIR);
+    } catch {
+      // absent or not ours — nothing to protect yet
+    }
+  }
+  for (const file of HARDENED_FILES) {
+    try {
+      chmodSync(file, OWNER_FILE);
+    } catch {
+      // absent or not ours — nothing to protect yet
+    }
+  }
+}

package/src/util/log.ts

@@ -137,7 +137,8 @@ if (!quiet) {
 if (!IS_VITEST) {
   streams.push({
     level: "trace",
-    stream: createWriteStream(LOG_FILE, { flags: "a" }),
+    // 0600: turns and tool output land here — same sensitivity as history.
+    stream: createWriteStream(LOG_FILE, { flags: "a", mode: 0o600 }),
   });
 }
 

package/tsconfig.json

@@ -5,6 +5,12 @@
     "moduleResolution": "bundler",
     "resolveJsonModule": true,
     "strict": true,
+    // Beyond-strict gates. Two more are measured but not yet on — the fix
+    // waves are their own PRs: noUncheckedIndexedAccess (666 errors),
+    // exactOptionalPropertyTypes (303 errors).
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "verbatimModuleSyntax": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
     "outDir": "dist",