Merge branch 'beta' into main (safe conflict resolution)

2026-11-06 04:42:35 +00:00 · 2026-02-23 16:38:18 -05:00
commit 37d0dffdc3
@@ -17,6 +17,7 @@ export function parseArgs(argv) {
    dryRun: false,
    force: false,
    port: DEFAULT_DASHBOARD_PORT,
+    host: null,
    logDir: 'task-logs',
    ignoreLogs: false,
    id: null,
@@ -33,12 +34,23 @@ export function parseArgs(argv) {
    windowMinutes: null,
    platform: null,
    model: null,
+    subcommand: null,
+    target: null,
+    content: null,
+    reason: null,
+    strategy: null,
+    status: null,
  };
  let i = 0;

  if (argv.length > 0 && !argv[0].startsWith('-')) {
    args.command = argv[0];
    i = 1;
+    // Support subcommands for 'proposal'
+    if (args.command === 'proposal' && argv.length > 1 && !argv[1].startsWith('-')) {
+      args.subcommand = argv[1];
+      i = 2;
+    }
  }

  for (; i < argv.length; i++) {
@@ -65,6 +77,8 @@ export function parseArgs(argv) {
      args.force = true;
    } else if (arg === '--port') {
      args.port = parseInt(argv[++i], 10) || DEFAULT_DASHBOARD_PORT;
+    } else if (arg === '--host') {
+      args.host = argv[++i];
    } else if (arg === '--log-dir') {
      args.logDir = argv[++i];
    } else if (arg === '--ignore-logs') {
@@ -127,6 +141,26 @@ export function parseArgs(argv) {
      args.model = argv[++i];
    } else if (arg.startsWith('--model=')) {
      args.model = arg.split('=')[1];
+    } else if (arg === '--target') {
+      args.target = argv[++i];
+    } else if (arg.startsWith('--target=')) {
+      args.target = arg.split('=')[1];
+    } else if (arg === '--content') {
+      args.content = argv[++i];
+    } else if (arg.startsWith('--content=')) {
+      args.content = arg.split('=')[1];
+    } else if (arg === '--reason') {
+      args.reason = argv[++i];
+    } else if (arg.startsWith('--reason=')) {
+      args.reason = arg.split('=')[1];
+    } else if (arg === '--strategy') {
+      args.strategy = argv[++i];
+    } else if (arg.startsWith('--strategy=')) {
+      args.strategy = arg.split('=')[1];
+    } else if (arg === '--status') {
+      args.status = argv[++i];
+    } else if (arg.startsWith('--status=')) {
+      args.status = arg.split('=')[1];
    }
  }

@@ -1,18 +1,29 @@
 import {
-  getRelays,
-  getNamespace,
+  getRelays as _getRelays,
+  getNamespace as _getNamespace,
 } from './torch-config.mjs';
-import { getRoster } from './roster.mjs';
-import { queryLocks } from './lock-ops.mjs';
-import { todayDateStr, nowUnix } from './utils.mjs';
+import { getRoster as _getRoster } from './roster.mjs';
+import { queryLocks as _queryLocks } from './lock-ops.mjs';
+import { todayDateStr as _todayDateStr, nowUnix as _nowUnix } from './utils.mjs';

-export async function cmdList(cadence) {
-  const relays = getRelays();
-  const namespace = getNamespace();
+export async function cmdList(cadence, deps = {}) {
+  const {
+      getRelays = _getRelays,
+      getNamespace = _getNamespace,
+      getRoster = _getRoster,
+      queryLocks = _queryLocks,
+      todayDateStr = _todayDateStr,
+      nowUnix = _nowUnix,
+      log = console.log,
+      error = console.error,
+  } = deps;
+
+  const relays = await getRelays();
+  const namespace = await getNamespace();
  const dateStr = todayDateStr();
  const cadences = cadence ? [cadence] : ['daily', 'weekly'];

-  console.error(`Listing active locks: namespace=${namespace}, cadences=${cadences.join(', ')}`);
+  error(`Listing active locks: namespace=${namespace}, cadences=${cadences.join(', ')}`);

  const results = await Promise.all(
    cadences.map(async (c) => {
@@ -22,12 +33,12 @@ export async function cmdList(cadence) {
  );

  for (const { c, locks } of results) {
-    console.log(`\n${'='.repeat(72)}`);
-    console.log(`Active ${namespace} ${c} locks (${dateStr})`);
-    console.log('='.repeat(72));
+    log(`\n${'='.repeat(72)}`);
+    log(`Active ${namespace} ${c} locks (${dateStr})`);
+    log('='.repeat(72));

    if (locks.length === 0) {
-      console.log('  (no active locks)');
+      log('  (no active locks)');
      continue;
    }

@@ -38,7 +49,7 @@ export async function cmdList(cadence) {
      const remaining = lock.expiresAt ? lock.expiresAt - nowUnix() : null;
      const remainMin = remaining ? Math.round(remaining / 60) : '?';

-      console.log(
+      log(
        `  ${(lock.agent ?? 'unknown').padEnd(30)} ` +
          `age: ${String(ageMin).padStart(4)}m  ` +
          `ttl: ${String(remainMin).padStart(4)}m  ` +
@@ -47,16 +58,17 @@ export async function cmdList(cadence) {
      );
    }

-    const roster = getRoster(c);
+    const roster = await getRoster(c);
+    const rosterSet = new Set(roster);
    const lockedAgents = new Set(locks.map((l) => l.agent).filter(Boolean));
-    const unknownLockedAgents = [...lockedAgents].filter((agent) => !roster.includes(agent));
+    const unknownLockedAgents = [...lockedAgents].filter((agent) => !rosterSet.has(agent));
    const available = roster.filter((a) => !lockedAgents.has(a));

    if (unknownLockedAgents.length > 0) {
-      console.log(`  Warning: lock events found with non-roster agent names: ${unknownLockedAgents.join(', ')}`);
+      log(`  Warning: lock events found with non-roster agent names: ${unknownLockedAgents.join(', ')}`);
    }

-    console.log(`\n  Locked: ${lockedAgents.size}/${roster.length}`);
-    console.log(`  Available: ${available.join(', ') || '(none)'}`);
+    log(`\n  Locked: ${lockedAgents.size}/${roster.length}`);
+    log(`  Available: ${available.join(', ') || '(none)'}`);
  }
 }
@@ -0,0 +1,100 @@
+import { createProposal, listProposals, applyProposal, rejectProposal, getProposal } from './services/governance/index.js';
+import { ExitError } from './errors.mjs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function cmdProposal(subcommand, args = {}) {
+  switch (subcommand) {
+    case 'create':
+      return await handleCreate(args);
+    case 'list':
+      return await handleList(args);
+    case 'apply':
+      return await handleApply(args);
+    case 'reject':
+      return await handleReject(args);
+    case 'show':
+      return await handleShow(args);
+    default:
+      console.error(`Unknown proposal subcommand: ${subcommand}`);
+      throw new ExitError(1, 'Unknown subcommand');
+  }
+}
+
+async function handleCreate({ agent, target, contentFile, reason }) {
+  if (!agent || !target || !contentFile || !reason) {
+    console.error('Usage: torch-lock proposal create --agent <name> --target <path> --content <file> --reason <text>');
+    throw new ExitError(1, 'Missing arguments');
+  }
+
+  let newContent;
+  try {
+    newContent = await fs.readFile(contentFile, 'utf8');
+  } catch (e) {
+    console.error(`Failed to read content file: ${contentFile}`);
+    throw new ExitError(1, 'File read error');
+  }
+
+  try {
+    const result = await createProposal({ agent, target, newContent, reason });
+    console.log(JSON.stringify(result, null, 2));
+  } catch (e) {
+    console.error(`Failed to create proposal: ${e.message}`);
+    throw new ExitError(1, 'Proposal creation failed');
+  }
+}
+
+async function handleList({ status }) {
+  try {
+    const proposals = await listProposals();
+    const filtered = status ? proposals.filter(p => p.status === status) : proposals;
+    console.log(JSON.stringify(filtered, null, 2));
+  } catch (e) {
+    console.error(`Failed to list proposals: ${e.message}`);
+    throw new ExitError(1, 'List failed');
+  }
+}
+
+async function handleApply({ id }) {
+  if (!id) {
+    console.error('Usage: torch-lock proposal apply --id <proposal-id>');
+    throw new ExitError(1, 'Missing id');
+  }
+
+  try {
+    const result = await applyProposal(id);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (e) {
+    console.error(`Failed to apply proposal: ${e.message}`);
+    throw new ExitError(1, 'Apply failed');
+  }
+}
+
+async function handleReject({ id, reason }) {
+  if (!id || !reason) {
+    console.error('Usage: torch-lock proposal reject --id <proposal-id> --reason <text>');
+    throw new ExitError(1, 'Missing arguments');
+  }
+
+  try {
+    const result = await rejectProposal(id, reason);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (e) {
+    console.error(`Failed to reject proposal: ${e.message}`);
+    throw new ExitError(1, 'Reject failed');
+  }
+}
+
+async function handleShow({ id }) {
+    if (!id) {
+        console.error('Usage: torch-lock proposal show --id <proposal-id>');
+        throw new ExitError(1, 'Missing id');
+    }
+    try {
+        const proposal = await getProposal(id);
+        console.log(JSON.stringify(proposal, null, 2));
+    } catch (e) {
+        console.error(`Failed to show proposal: ${e.message}`);
+        throw new ExitError(1, 'Show failed');
+    }
+}
@@ -0,0 +1,19 @@
+import { rollbackPrompt } from './services/governance/index.js';
+import { ExitError } from './errors.mjs';
+
+export async function cmdRollback(target, strategy) {
+  if (!target) {
+    console.error('Usage: torch-lock rollback --target <path> [--strategy <hash|latest>]');
+    throw new ExitError(1, 'Missing target');
+  }
+
+  const effectiveStrategy = strategy || 'latest';
+
+  try {
+    const result = await rollbackPrompt(target, effectiveStrategy);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (e) {
+    console.error(`Rollback failed: ${e.message}`);
+    throw new ExitError(1, 'Rollback failed');
+  }
+}
@@ -11,5 +11,57 @@ export const DEFAULT_QUERY_TIMEOUT_MS = 30_000;
 export const DEFAULT_PUBLISH_TIMEOUT_MS = 15_000;
 export const DEFAULT_MIN_SUCCESSFUL_PUBLISHES = 1;
 export const DEFAULT_MIN_ACTIVE_RELAY_POOL = 1;
+export const DEFAULT_RETRY_ATTEMPTS = 4;
+export const DEFAULT_RETRY_BASE_DELAY_MS = 500;
+export const DEFAULT_RETRY_CAP_DELAY_MS = 8000;
+export const DEFAULT_ROLLING_WINDOW_SIZE = 25;
+export const DEFAULT_FAILURE_THRESHOLD = 3;
+export const DEFAULT_QUARANTINE_COOLDOWN_MS = 30_000;
+export const DEFAULT_MAX_QUARANTINE_COOLDOWN_MS = 300_000;
+export const DEFAULT_SNAPSHOT_INTERVAL_MS = 60_000;
 export const VALID_CADENCES = new Set(['daily', 'weekly']);
 export const KIND_APP_DATA = 30078;
+
+export const USAGE_TEXT = `Usage: torch-lock <command> [options]
+
+Commands:
+  check     --cadence <daily|weekly>               Check locked agents (JSON)
+  lock      --agent <name> --cadence <daily|weekly> Claim a lock
+  complete  --agent <name> --cadence <daily|weekly> Mark task as completed (permanent)
+  list      [--cadence <daily|weekly>]             Print active lock table
+  health    --cadence <daily|weekly>               Probe relay websocket + publish/read health
+  dashboard [--port <port>] [--host <host>]        Serve the dashboard (default: ${DEFAULT_DASHBOARD_PORT})
+  init      [--force]                              Initialize torch/ directory in current project
+  update    [--force]                              Update torch/ configuration (backups, merges)
+
+  list-memories           [--agent <id>] [--type <type>] [--tags <a,b>] [--pinned <true|false>] [--full]
+  inspect-memory          --id <memoryId>
+  pin-memory              --id <memoryId>
+  unpin-memory            --id <memoryId>
+  trigger-prune-dry-run   [--retention-ms <ms>]
+  memory-stats            [--window-ms <ms>]
+
+Options:
+  --dry-run       Build and sign the event but do not publish
+  --force         Overwrite existing files (for init) or all files (for update)
+  --log-dir       Path to task logs directory (default: task-logs)
+  --ignore-logs   Skip checking local logs for completed tasks
+  --json          Emit compact single-line JSON
+  --json-file     Write JSON output to a file path
+  --quiet         Suppress stderr progress logs (pairs well with --json)
+
+Environment:
+  NOSTR_LOCK_NAMESPACE      Namespace prefix for lock tags (default: torch)
+  NOSTR_LOCK_RELAYS         Comma-separated relay WSS URLs
+  NOSTR_LOCK_TTL            Lock TTL in seconds (default: 7200)
+  NOSTR_LOCK_QUERY_TIMEOUT_MS   Relay query timeout in milliseconds (default: 15000)
+  NOSTR_LOCK_DAILY_ROSTER   Comma-separated daily roster (optional)
+  NOSTR_LOCK_WEEKLY_ROSTER  Comma-separated weekly roster (optional)
+  TORCH_CONFIG_PATH         Optional path to torch-config.json (default: ./torch-config.json)
+  AGENT_PLATFORM            Platform identifier (e.g., codex)
+
+Exit codes:
+  0  Success
+  1  Usage error
+  2  Relay/network error
+  3  Lock denied (already locked or race lost)`;
@@ -2,22 +2,72 @@ import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import http from 'node:http';
+import crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { DEFAULT_DASHBOARD_PORT } from './constants.mjs';
+import { getDashboardAuth, parseTorchConfig } from './torch-config.mjs';

-export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT) {
+const SECURITY_HEADERS = {
+  'Content-Security-Policy': "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' wss:; object-src 'none'; base-uri 'self';",
+  'X-Content-Type-Options': 'nosniff',
+  'X-Frame-Options': 'DENY',
+  'Referrer-Policy': 'strict-origin-when-cross-origin'
+};
+
+function timingSafeCompare(a, b) {
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  if (bufA.length !== bufB.length) {
+    // Still do a comparison to avoid some timing leaks, though length leak is hard to avoid entirely
+    crypto.timingSafeEqual(bufA, bufA);
+    return false;
+  }
+  return crypto.timingSafeEqual(bufA, bufB);
+}
+
+export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT, host = '127.0.0.1') {
  // Resolve package root relative to this file (src/dashboard.mjs)
  // this file is in <root>/src/dashboard.mjs, so '..' goes to <root>
  const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const auth = await getDashboardAuth();

  const server = http.createServer(async (req, res) => {
+    try {
+    // Basic Auth check
+    if (auth) {
+      const authHeader = req.headers.authorization;
+      if (!authHeader) {
+        res.writeHead(401, { ...SECURITY_HEADERS, 'WWW-Authenticate': 'Basic realm="TORCH Dashboard"' });
+        res.end('Authentication required');
+        return;
+      }
+      const parts = authHeader.split(' ');
+      const type = parts[0];
+      const credentials = parts[1];
+      let isValid = false;
+      if (type === 'Basic' && credentials) {
+        try {
+          const decoded = Buffer.from(credentials, 'base64').toString();
+          isValid = timingSafeCompare(decoded, auth);
+        } catch {
+          isValid = false;
+        }
+      }
+
+      if (!isValid) {
+        res.writeHead(401, { ...SECURITY_HEADERS, 'WWW-Authenticate': 'Basic realm="TORCH Dashboard"' });
+        res.end('Invalid credentials');
+        return;
+      }
+    }
+
    // URL parsing
    const url = new URL(req.url, `http://${req.headers.host}`);
    let pathname = url.pathname;

    // Redirect / to /dashboard/
    if (pathname === '/' || pathname === '/dashboard') {
-      res.writeHead(302, { 'Location': '/dashboard/' });
+      res.writeHead(302, { ...SECURITY_HEADERS, 'Location': '/dashboard/' });
      res.end();
      return;
    }
@@ -31,22 +81,94 @@ export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT) {
    }

    // Special case: /torch-config.json
-    // Priority: User's CWD > Package default
+    // Priority: Env Var > User's CWD > Package default
    if (pathname === '/torch-config.json') {
-      const userConfigPath = path.resolve(process.cwd(), 'torch-config.json');
-      if (await statSafe(userConfigPath)) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        fs.createReadStream(userConfigPath).pipe(res);
+      let configContent = null;
+
+      if (process.env.TORCH_CONFIG_PATH) {
+        const envPath = path.resolve(process.cwd(), process.env.TORCH_CONFIG_PATH);
+        try {
+          configContent = await fsp.readFile(envPath, 'utf8');
+        } catch {
+          // Explicitly provided config path not found, do not fall back
+        }
+      } else {
+        const userConfigPath = path.resolve(process.cwd(), 'torch-config.json');
+        try {
+          configContent = await fsp.readFile(userConfigPath, 'utf8');
+        } catch {
+          // Try package default
+          const packageConfigPath = path.join(packageRoot, 'torch-config.json');
+          try {
+            configContent = await fsp.readFile(packageConfigPath, 'utf8');
+          } catch {
+            // Not found in either location
+          }
+        }
+      }
+
+      if (configContent) {
+        try {
+          const rawConfig = JSON.parse(configContent);
+          const safeConfig = parseTorchConfig(rawConfig);
+
+          // Security: Whitelist only fields required by the dashboard frontend
+          const publicConfig = {
+            dashboard: safeConfig.dashboard ? { ...safeConfig.dashboard } : {},
+            nostrLock: safeConfig.nostrLock
+              ? {
+                  namespace: safeConfig.nostrLock.namespace,
+                  relays: safeConfig.nostrLock.relays,
+                }
+              : {},
+          };
+
+          // Remove sensitive dashboard auth
+          if (publicConfig.dashboard.auth) {
+            delete publicConfig.dashboard.auth;
+          }
+
+          res.writeHead(200, { ...SECURITY_HEADERS, 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(publicConfig, null, 2));
+          return;
+        } catch (err) {
+          console.error('Error parsing torch-config.json:', err);
+          res.writeHead(500, SECURITY_HEADERS);
+          res.end('Internal Server Error');
+          return;
+        }
+      } else {
+        res.writeHead(404, SECURITY_HEADERS);
+        res.end('Not Found');
        return;
      }
-      // If not found in CWD, fall through to serve from packageRoot (if it exists there)
-      // or return empty object if missing?
-      // Falling through means it looks for packageRoot/torch-config.json
    }

    // Security check: prevent directory traversal
-    const safePath = path.normalize(pathname).replace(new RegExp('^(\\.\\.[\\/\\\\])+'), '');
-    let filePath = path.join(packageRoot, safePath);
+    // Resolve path relative to packageRoot.
+    // We strip the leading slash from pathname (which comes from URL) to treat it as relative.
+    const relativePath = pathname.replace(/^\//, '');
+    let filePath = path.resolve(packageRoot, relativePath);
+
+    // Security check: restrict access to allowed paths
+    const allowedPaths = [
+      path.join(packageRoot, 'dashboard'),
+      path.join(packageRoot, 'assets'),
+      path.join(packageRoot, 'src', 'docs'),
+      path.join(packageRoot, 'src', 'constants.mjs'),
+      path.join(packageRoot, 'torch-config.json')
+    ];
+
+    const isAllowed = allowedPaths.some(allowedPath => {
+      const rel = path.relative(allowedPath, filePath);
+      return !rel.startsWith('..') && !path.isAbsolute(rel);
+    });
+
+    if (!isAllowed) {
+      res.writeHead(403, SECURITY_HEADERS);
+      res.end('Forbidden');
+      return;
+    }

    // If directory, try index.html
    let fileStat = await statSafe(filePath);
@@ -57,7 +179,7 @@ export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT) {

    // Check if file exists and is a file
    if (!fileStat || !fileStat.isFile()) {
-      res.writeHead(404);
+      res.writeHead(404, SECURITY_HEADERS);
      res.end('Not Found');
      return;
    }
@@ -78,16 +200,30 @@ export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT) {
      case '.md': contentType = 'text/markdown'; break;
    }

-    res.writeHead(200, { 'Content-Type': contentType });
+    res.writeHead(200, { ...SECURITY_HEADERS, 'Content-Type': contentType });
    fs.createReadStream(filePath).pipe(res);
+    } catch (err) {
+      console.error('Dashboard Server Error:', err);
+      if (!res.headersSent) {
+        res.writeHead(500, SECURITY_HEADERS);
+        res.end('Internal Server Error');
+      }
+    }
  });

-  server.listen(port, () => {
-    console.log(`Dashboard running at http://localhost:${port}/dashboard/`);
-    console.log(`Serving files from ${packageRoot}`);
-    console.log(`Using configuration from ${process.cwd()}`);
+  return new Promise((resolve, reject) => {
+    server.listen(port, host, () => {
+      const listenUrl = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}/dashboard/`;
+      console.log(`Dashboard running at ${listenUrl}`);
+      if (auth) {
+        console.log('Authentication: enabled (Basic Auth)');
+      } else {
+        console.warn('Authentication: DISABLED (Dashboard is public)');
+      }
+      console.log(`Serving files from ${packageRoot}`);
+      console.log(`Using configuration from ${process.cwd()}`);
+      resolve(server);
+    });
+    server.on('error', reject);
  });
-
-  // Keep process alive
-  return new Promise(() => {});
 }
@@ -14,10 +14,10 @@ import {
  getHashtag as _getHashtag,
 } from './torch-config.mjs';
 import {
-  DEFAULT_DASHBOARD_PORT,
  VALID_CADENCES,
  KIND_APP_DATA,
  RACE_CHECK_DELAY_MS,
+  USAGE_TEXT,
 } from './constants.mjs';
 import { cmdInit, cmdUpdate } from './ops.mjs';
 import { parseArgs } from './cli-parser.mjs';
@@ -37,7 +37,11 @@ import { todayDateStr, nowUnix, detectPlatform } from './utils.mjs';
 import { runRelayHealthCheck } from './relay-health.mjs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { execSync } from 'node:child_process';
 import { getCompletedAgents } from './lock-utils.mjs';
+import { cmdProposal } from './cmd-proposal.mjs';
+import { cmdRollback } from './cmd-rollback.mjs';

 useWebSocketImplementation(WebSocket);

@@ -75,10 +79,10 @@ export async function cmdCheck(cadence, deps = {}) {
    quiet = false,
  } = deps;

-  const relays = getRelays();
-  const namespace = getNamespace();
+  const relays = await getRelays();
+  const namespace = await getNamespace();
  const dateStr = getDateStr();
-  const config = loadTorchConfig();
+  const config = await loadTorchConfig();
  const pausedAgents = config.scheduler.paused[cadence] || [];

  if (!quiet) {
@@ -99,7 +103,7 @@ export async function cmdCheck(cadence, deps = {}) {

  const locks = await queryLocks(relays, cadence, dateStr, namespace);
  const lockedAgents = [...new Set(locks.map((l) => l.agent).filter(Boolean))];
-  const roster = getRoster(cadence);
+  const roster = await getRoster(cadence);
  const rosterSet = new Set(roster);

  const excludedAgentsSet = new Set([...lockedAgents, ...pausedAgents, ...completedAgents]);
@@ -180,20 +184,43 @@ export async function cmdLock(agent, cadence, optionsOrDryRun = false, deps = {}
    error = console.error
  } = deps;

-  const relays = getRelays();
-  const namespace = getNamespace();
-  const hashtag = getHashtag();
+  const relays = await getRelays();
+  const namespace = await getNamespace();
+  const hashtag = await getHashtag();
  const dateStr = getDateStr();
-  const ttl = getTtl();
+  const ttl = await getTtl();
  const now = nowUnix();
  const expiresAt = now + ttl;

+  let gitCommit = null;
+  try {
+    gitCommit = execSync('git rev-parse HEAD', { stdio: 'pipe' }).toString().trim();
+  } catch {
+    // Ignore git errors (not a git repo, etc)
+  }
+
+  let promptHash = null;
+  let promptPath = null;
+  try {
+    // Attempt to locate the prompt file based on standard structure
+    // We assume the CWD is the project root or we are in a standard structure.
+    // If not found, we just omit the hash.
+    const potentialPath = path.join(process.cwd(), 'src', 'prompts', cadence, `${agent}.md`);
+    const content = await fs.readFile(potentialPath, 'utf8');
+    promptHash = createHash('sha256').update(content).digest('hex');
+    promptPath = `src/prompts/${cadence}/${agent}.md`;
+  } catch {
+    // Ignore missing prompt file
+  }
+
  error(`Locking: namespace=${namespace}, agent=${agent}, cadence=${cadence}, date=${dateStr}`);
  error(`Hashtag: #${hashtag}`);
  error(`TTL: ${ttl}s, expires: ${new Date(expiresAt * 1000).toISOString()}`);
  error(`Relays: ${relays.join(', ')}`);
+  if (gitCommit) error(`Git Commit: ${gitCommit}`);
+  if (promptHash) error(`Prompt Hash: ${promptHash.slice(0, 12)}...`);

-  const roster = getRoster(cadence);
+  const roster = await getRoster(cadence);
  if (!roster.includes(agent)) {
    error(`ERROR: agent "${agent}" is not in the ${cadence} roster`);
    error(`Allowed ${cadence} agents: ${roster.join(', ')}`);
@@ -252,6 +279,9 @@ export async function cmdLock(agent, cadence, optionsOrDryRun = false, deps = {}
        model: model || process.env.AGENT_MODEL || 'unknown',
        lockedAt: new Date(now * 1000).toISOString(),
        expiresAt: new Date(expiresAt * 1000).toISOString(),
+        gitCommit,
+        promptPath,
+        promptHash,
      }),
    },
    sk,
@@ -297,6 +327,8 @@ export async function cmdLock(agent, cadence, optionsOrDryRun = false, deps = {}
  log(`LOCK_DATE=${dateStr}`);
  log(`LOCK_EXPIRES=${expiresAt}`);
  log(`LOCK_EXPIRES_ISO=${new Date(expiresAt * 1000).toISOString()}`);
+  if (gitCommit) log(`LOCK_GIT_COMMIT=${gitCommit}`);
+  if (promptHash) log(`LOCK_PROMPT_HASH=${promptHash}`);
  return { status: 'ok', eventId: event.id };
 }

@@ -319,8 +351,8 @@ export async function cmdList(cadence, deps = {}) {
    error = console.error
  } = deps;

-  const relays = getRelays();
-  const namespace = getNamespace();
+  const relays = await getRelays();
+  const namespace = await getNamespace();
  const dateStr = getDateStr();
  const cadences = cadence ? [cadence] : [...VALID_CADENCES];

@@ -365,7 +397,7 @@ export async function cmdList(cadence, deps = {}) {
      );
    }

-    const roster = getRoster(c);
+    const roster = await getRoster(c);
    const rosterSet = new Set(roster);
    const lockedAgents = new Set(locks.map((l) => l.agent).filter(Boolean));
    const unknownLockedAgents = [...lockedAgents].filter((agent) => !rosterSet.has(agent));
@@ -413,9 +445,9 @@ export async function cmdComplete(agent, cadence, optionsOrDryRun = false, deps
    error = console.error
  } = deps;

-  const relays = getRelays();
-  const namespace = getNamespace();
-  const hashtag = getHashtag();
+  const relays = await getRelays();
+  const namespace = await getNamespace();
+  const hashtag = await getHashtag();
  const dateStr = getDateStr();
  const now = nowUnix();

@@ -492,49 +524,7 @@ export async function cmdComplete(agent, cadence, optionsOrDryRun = false, deps
 }

 function usage() {
-  console.error(`Usage: torch-lock <command> [options]
-
-Commands:
-  check     --cadence <daily|weekly>               Check locked agents (JSON)
-  lock      --agent <name> --cadence <daily|weekly> Claim a lock
-  complete  --agent <name> --cadence <daily|weekly> Mark task as completed (permanent)
-  list      [--cadence <daily|weekly>]             Print active lock table
-  health    --cadence <daily|weekly>               Probe relay websocket + publish/read health
-  dashboard [--port <port>]                        Serve the dashboard (default: ${DEFAULT_DASHBOARD_PORT})
-  init      [--force]                              Initialize torch/ directory in current project
-  update    [--force]                              Update torch/ configuration (backups, merges)
-
-  list-memories           [--agent <id>] [--type <type>] [--tags <a,b>] [--pinned <true|false>] [--full]
-  inspect-memory          --id <memoryId>
-  pin-memory              --id <memoryId>
-  unpin-memory            --id <memoryId>
-  trigger-prune-dry-run   [--retention-ms <ms>]
-  memory-stats            [--window-ms <ms>]
-
-Options:
-  --dry-run       Build and sign the event but do not publish
-  --force         Overwrite existing files (for init) or all files (for update)
-  --log-dir       Path to task logs directory (default: task-logs)
-  --ignore-logs   Skip checking local logs for completed tasks
-  --json          Emit compact single-line JSON
-  --json-file     Write JSON output to a file path
-  --quiet         Suppress stderr progress logs (pairs well with --json)
-
-Environment:
-  NOSTR_LOCK_NAMESPACE      Namespace prefix for lock tags (default: torch)
-  NOSTR_LOCK_RELAYS         Comma-separated relay WSS URLs
-  NOSTR_LOCK_TTL            Lock TTL in seconds (default: 7200)
-  NOSTR_LOCK_QUERY_TIMEOUT_MS   Relay query timeout in milliseconds (default: 15000)
-  NOSTR_LOCK_DAILY_ROSTER   Comma-separated daily roster (optional)
-  NOSTR_LOCK_WEEKLY_ROSTER  Comma-separated weekly roster (optional)
-  TORCH_CONFIG_PATH         Optional path to torch-config.json (default: ./torch-config.json)
-  AGENT_PLATFORM            Platform identifier (e.g., codex)
-
-Exit codes:
-  0  Success
-  1  Usage error
-  2  Relay/network error
-  3  Lock denied (already locked or race lost)`);
+  console.error(USAGE_TEXT);
 }

 /**
@@ -632,7 +622,7 @@ export async function main(argv) {
      }

      case 'dashboard': {
-        await cmdDashboard(args.port);
+        await cmdDashboard(args.port, args.host);
        break;
      }

@@ -710,6 +700,27 @@ export async function main(argv) {
        break;
      }

+      case 'proposal': {
+        if (!args.subcommand) {
+          console.error('ERROR: Missing subcommand for proposal (create, list, apply, reject, show)');
+          throw new ExitError(1, 'Missing subcommand');
+        }
+        await cmdProposal(args.subcommand, {
+          agent: args.agent,
+          target: args.target,
+          contentFile: args.content,
+          reason: args.reason,
+          id: args.id,
+          status: args.status
+        });
+        break;
+      }
+
+      case 'rollback': {
+        await cmdRollback(args.target, args.strategy);
+        break;
+      }
+
      default:
        console.error(`ERROR: Unknown command: ${args.command}`);
        usage();
@@ -5,6 +5,7 @@ import crypto from 'node:crypto';
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { DEFAULT_RELAYS } from './constants.mjs';
+import { ensureDir } from './utils.mjs';

 const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');

@@ -24,7 +25,7 @@ const EVOLVING_DIRS = ['daily', 'weekly'];

 // New constants for full application install
 const APP_DIRS = ['src', 'bin', 'dashboard', 'landing', 'assets', 'scripts'];
-const APP_FILES = ['package.json', 'build.mjs', 'README.md', 'torch-config.example.json'];
+const APP_FILES = ['package.json', 'build.mjs', 'README.md', 'torch-config.example.json', 'TORCH.md'];

 function getPaths(root, installDirName) {
    const torchDir = path.resolve(root, installDirName);
@@ -36,12 +37,6 @@ function getPaths(root, installDirName) {
    };
 }

-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
 function copyDir(src, dest) {
    if (fs.existsSync(src)) {
        fs.cpSync(src, dest, { recursive: true });
@@ -65,7 +60,8 @@ function transformContent(content, installDirName) {
    .replace(/src\/prompts\/daily\//g, `${prefix}prompts/daily/`)
    .replace(/src\/prompts\/weekly\//g, `${prefix}prompts/weekly/`)
    .replace(/src\/prompts\/roster\.json/g, `${prefix}roster.json`)
-    .replace(/src\/prompts\/scheduler-flow\.md/g, `${prefix}scheduler-flow.md`);
+    .replace(/src\/prompts\/scheduler-flow\.md/g, `${prefix}scheduler-flow.md`)
+    .replace(/TORCH\.md/g, `${prefix}TORCH.md`);
 }

 function copyFile(src, dest, transform = false, overwrite = true, installDirName = 'torch') {
@@ -80,6 +76,41 @@ function copyFile(src, dest, transform = false, overwrite = true, installDirName
  return true; // Copied/Overwritten
 }

+function syncAppDirectories(torchDir, verb = 'Copied') {
+  console.log(`${verb === 'Copied' ? 'Copying' : 'Updating'} application directories...`);
+  for (const dir of APP_DIRS) {
+    const src = path.join(PKG_ROOT, dir);
+    const dest = path.join(torchDir, dir);
+    if (fs.existsSync(src)) {
+      copyDir(src, dest);
+      console.log(`  ${verb} ${dir}/`);
+    }
+  }
+}
+
+function syncAppFiles(torchDir, installDir, verb = 'Copied') {
+  console.log(`${verb === 'Copied' ? 'Copying' : 'Updating'} application files...`);
+  for (const file of APP_FILES) {
+    const src = path.join(PKG_ROOT, file);
+    const dest = path.join(torchDir, file);
+    if (fs.existsSync(src)) {
+      if (installDir === '.' && file === 'package.json') {
+        if (verb === 'Copied' && fs.existsSync(dest)) {
+          console.warn('  Skipping package.json to avoid overwriting host package.json (installing to root).');
+          continue;
+        }
+        if (verb === 'Updated') {
+          console.log('  Skipping package.json update (installed in root).');
+          continue;
+        }
+      }
+
+      fs.copyFileSync(src, dest);
+      console.log(`  ${verb} ${file}`);
+    }
+  }
+}
+
 async function interactiveInit(cwd) {
  const rl = readline.createInterface({ input, output });
  const currentDirName = path.basename(cwd);
@@ -116,68 +147,60 @@ async function interactiveInit(cwd) {
  }
 }

-export async function cmdInit(force = false, cwd = process.cwd(), mockAnswers = null) {
-  // Use interactive mode to get configuration unless mock answers are provided
+function validateInstallDir(dir) {
+  if (dir === '.') return;
+
+  // Strict validation to prevent command injection
+  // Only allow alphanumeric, hyphens, underscores, slashes, and periods.
+  if (!/^[a-zA-Z0-9_\-./]+$/.test(dir)) {
+    throw new Error(`Invalid directory name: "${dir}". Only alphanumeric characters, hyphens, underscores, slashes, and periods are allowed.`);
+  }
+}
+
+async function resolveConfiguration(cwd, mockAnswers) {
  let config;
  if (mockAnswers) {
    config = mockAnswers;
  } else {
    config = await interactiveInit(cwd);
  }
-  const { installDir, namespace, relays } = config;

-  const paths = getPaths(cwd, installDir);
-  console.log(`\nInitializing torch in ${paths.torchDir}...`);
+  validateInstallDir(config.installDir);
+  return config;
+}

-  // Check if directory exists and is not empty (unless force is used or we are installing to .)
+function ensureInstallDirectory(paths, force, installDir) {
  if (fs.existsSync(paths.torchDir) && !force) {
     const entries = fs.readdirSync(paths.torchDir);
     if (entries.length > 0 && installDir !== '.') {
-         // If installing to current dir, we might expect some files, but warn anyway?
-         // Simpler: just throw if strictly not empty and not forced.
-         // But usually we don't want to fail if just re-running init.
-         console.warn(`Warning: ${paths.torchDir} already exists.`);
+         throw new Error(`Directory ${paths.torchDir} already exists and is not empty. Use --force to overwrite.`);
     }
  }
-
  ensureDir(paths.torchDir);
  ensureDir(paths.promptsDir);

+  // Ensure governance directories
+  // We assume standard structure src/proposals and .torch/prompt-history
+  // even if installed in a subdirectory, these are usually repo-level.
+  // But if installed in 'torch', maybe they should be in 'torch/src/proposals'?
+  // For now, we follow the pattern that prompts are managed where the scheduler expects them.
+  // If we are in this repo, it's src/prompts.
+  // If torch is initializing a new repo, it might put prompts in installDir/prompts.
+  // However, governance service currently hardcodes 'src/proposals'.
+  // So we ensure 'src/proposals' relative to root.
+  ensureDir(path.join(paths.root, 'src', 'proposals'));
+  ensureDir(path.join(paths.root, '.torch', 'prompt-history'));
+}
+
+function installAppAssets(torchDir, installDir) {
  // 1. Copy App Directories
-  console.log('Copying application directories...');
-  for (const dir of APP_DIRS) {
-      const src = path.join(PKG_ROOT, dir);
-      const dest = path.join(paths.torchDir, dir);
-      // If installing to '.', src/bin maps to ./bin, which is fine.
-      if (fs.existsSync(src)) {
-          copyDir(src, dest);
-          console.log(`  Copied ${dir}/`);
-      }
-  }
+  syncAppDirectories(torchDir, 'Copied');

  // 2. Copy App Files
-  console.log('Copying application files...');
-  for (const file of APP_FILES) {
-      const src = path.join(PKG_ROOT, file);
-      const dest = path.join(paths.torchDir, file);
-      if (fs.existsSync(src)) {
-          // Careful not to overwrite critical files if they exist in root?
-          // e.g. package.json.
-          // If installing to '.', we definitely don't want to overwrite package.json unless it's the torch one?
-          // But torch is "vendored", so it has its own package.json.
-          // If installing to '.', we are overwriting the USER's package.json?
-          // That is dangerous.
-
-          if (installDir === '.' && file === 'package.json' && fs.existsSync(dest)) {
-              console.warn('  Skipping package.json to avoid overwriting host package.json (installing to root).');
-              continue;
-          }
-
-          fs.copyFileSync(src, dest);
-          console.log(`  Copied ${file}`);
-      }
-  }
+  syncAppFiles(torchDir, installDir, 'Copied');
+}

+function installTorchAssets(paths, installDir) {
  // 3. Copy Roster
  const srcRoster = path.join(SRC_PROMPTS_DIR, 'roster.json');
  if (fs.existsSync(srcRoster)) {
@@ -211,7 +234,9 @@ export async function cmdInit(force = false, cwd = process.cwd(), mockAnswers =
      console.log(`Created ${files.length} files in ${path.relative(paths.root, destDir)}/`);
    }
  }
+}

+function configureTorch(cwd, paths, installDir, namespace, relays) {
  // 6. Create/Update torch-config.json
  const configPath = path.join(paths.root, 'torch-config.json');

@@ -237,14 +262,61 @@ export async function cmdInit(force = false, cwd = process.cwd(), mockAnswers =
  configData.nostrLock.namespace = namespace;
  configData.nostrLock.relays = relays;

+  // Configure memory policy with correct paths
+  if (!configData.scheduler) configData.scheduler = {};
+  // Always ensure memory policy exists and points to the correct scripts
+  // We use the installDir to construct the path
+  const scriptPrefix = installDir === '.' ? '' : `${installDir}/`;
+
+  if (!configData.scheduler.memoryPolicyByCadence) {
+    configData.scheduler.memoryPolicyByCadence = {};
+  }
+
+  // Populate or update daily/weekly memory policy
+  // We force update the command paths to match the install directory,
+  // while preserving other settings if they exist.
+  ['daily', 'weekly'].forEach(cadence => {
+    if (!configData.scheduler.memoryPolicyByCadence[cadence]) {
+      configData.scheduler.memoryPolicyByCadence[cadence] = {
+        mode: "required",
+        retrieveSuccessMarkers: ["MEMORY_RETRIEVED"],
+        storeSuccessMarkers: ["MEMORY_STORED"],
+        retrieveArtifacts: [`.scheduler-memory/latest/${cadence}/retrieve.ok`],
+        storeArtifacts: [`.scheduler-memory/latest/${cadence}/store.ok`]
+      };
+    }
+
+    // Always ensure commands point to the correct script location
+    const policy = configData.scheduler.memoryPolicyByCadence[cadence];
+    policy.retrieveCommand = `node ${scriptPrefix}scripts/memory/retrieve.mjs`;
+    policy.storeCommand = `node ${scriptPrefix}scripts/memory/store.mjs`;
+  });
+
  fs.writeFileSync(configPath, JSON.stringify(configData, null, 2), 'utf8');
  console.log(`Saved configuration to ${path.relative(cwd, configPath)}`);
+}

+function injectHostScriptsIfNeeded(paths, installDir) {
  // 7. Inject Scripts into Host Package.json
  // If we are NOT installing to '.', the host package.json is in paths.root
  if (installDir !== '.') {
      injectScriptsIntoHost(paths.root, installDir);
  }
+}
+
+export async function cmdInit(force = false, cwd = process.cwd(), mockAnswers = null) {
+  const config = await resolveConfiguration(cwd, mockAnswers);
+  const { installDir, namespace, relays } = config;
+
+  const paths = getPaths(cwd, installDir);
+  console.log(`\nInitializing torch in ${paths.torchDir}...`);
+
+  ensureInstallDirectory(paths, force, installDir);
+
+  installAppAssets(paths.torchDir, installDir);
+  installTorchAssets(paths, installDir);
+  configureTorch(cwd, paths, installDir, namespace, relays);
+  injectHostScriptsIfNeeded(paths, installDir);

  console.log('\nInitialization complete.');
  console.log('You can now customize the files in ' + path.relative(cwd, paths.torchDir) + '/');
@@ -266,6 +338,8 @@ function injectScriptsIntoHost(hostRoot, installDirName) {
            'torch:check': `npm run --prefix ${installDirName} lock:check:daily`, // Default to daily check
            'torch:lock': `npm run --prefix ${installDirName} lock:lock`,
            'torch:health': `npm run --prefix ${installDirName} lock:health`,
+            'torch:memory:list': `node ${installDirName === '.' ? '' : installDirName + '/'}bin/torch-lock.mjs list-memories`,
+            'torch:memory:inspect': `node ${installDirName === '.' ? '' : installDirName + '/'}bin/torch-lock.mjs inspect-memory`,
        };

        let modified = false;
@@ -338,30 +412,10 @@ export function cmdUpdate(force = false, cwd = process.cwd()) {
  }

  // 2. Update App Directories (Overwrite)
-  console.log('Updating application directories...');
-  for (const dir of APP_DIRS) {
-      const src = path.join(PKG_ROOT, dir);
-      const dest = path.join(paths.torchDir, dir);
-      if (fs.existsSync(src)) {
-          copyDir(src, dest);
-          console.log(`  Updated ${dir}/`);
-      }
-  }
+  syncAppDirectories(paths.torchDir, 'Updated');

  // 3. Update App Files (Overwrite)
-  console.log('Updating application files...');
-  for (const file of APP_FILES) {
-      const src = path.join(PKG_ROOT, file);
-      const dest = path.join(paths.torchDir, file);
-      if (fs.existsSync(src)) {
-          if (installDirName === '.' && file === 'package.json') {
-             console.log('  Skipping package.json update (installed in root).');
-             continue;
-          }
-          fs.copyFileSync(src, dest);
-          console.log(`  Updated ${file}`);
-      }
-  }
+  syncAppFiles(paths.torchDir, installDirName, 'Updated');

  // 4. Update Static Files (Always Overwrite)
  console.log('Updating static files...');
@@ -0,0 +1,45 @@
+import { loadTorchConfig, _resetTorchConfigCache } from '../torch-config.mjs';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const configPath = path.resolve(process.cwd(), 'torch-config.json');
+const originalConfig = fs.existsSync(configPath) ? fs.readFileSync(configPath) : null;
+
+// Ensure a config file exists for benchmark
+if (!fs.existsSync(configPath)) {
+  fs.writeFileSync(configPath, JSON.stringify({
+    nostrLock: {
+      relays: ["wss://relay.damus.io"],
+      namespace: "test-ns"
+    }
+  }, null, 2));
+}
+
+const ITERATIONS = 1000;
+const start = process.hrtime.bigint();
+
+async function run() {
+    for (let i = 0; i < ITERATIONS; i++) {
+      _resetTorchConfigCache();
+      try {
+        const res = await loadTorchConfig();
+        // Use res to prevent dead code elimination if JIT is smart (though side effects exist)
+        if (!res) throw new Error("Failed");
+      } catch (e) {
+        // ignore
+      }
+    }
+
+    const end = process.hrtime.bigint();
+    const duration = Number(end - start) / 1e6; // ms
+
+    console.log(`[ASYNC] Loaded config ${ITERATIONS} times in ${duration.toFixed(2)}ms`);
+    console.log(`[ASYNC] Average: ${(duration / ITERATIONS).toFixed(4)}ms per load`);
+
+    // Cleanup
+    if (!originalConfig && fs.existsSync(configPath)) {
+      fs.unlinkSync(configPath);
+    }
+}
+
+run();
@@ -27,7 +27,7 @@ Use `excluded` from the JSON output as the canonical exclusion set.
 If `excluded` is unavailable, fallback to the union of `locked`, `paused`, and `completed`.

 MUST 3: Run these commands in this order:
-1) test -f AGENTS.md && cat AGENTS.md || echo "No AGENTS.md found; continuing" (missing AGENTS.md is non-fatal)
+1) test -f TORCH.md && cat TORCH.md || echo "No TORCH.md found; continuing" (missing TORCH.md is non-fatal)
 2) mkdir -p task-logs/daily task-logs/weekly
 3) ls -1 task-logs/daily/ | sort | tail -n 1
 4) Select next roster agent using this exact algorithm:
@@ -111,7 +111,7 @@ Use `excluded` from the JSON output as the canonical exclusion set.
 If `excluded` is unavailable, fallback to the union of `locked`, `paused`, and `completed`.

 MUST 3: Run these commands in this order:
-1) test -f AGENTS.md && cat AGENTS.md || echo "No AGENTS.md found; continuing" (missing AGENTS.md is non-fatal)
+1) test -f TORCH.md && cat TORCH.md || echo "No TORCH.md found; continuing" (missing TORCH.md is non-fatal)
 2) mkdir -p task-logs/daily task-logs/weekly
 3) ls -1 task-logs/weekly/ | sort | tail -n 1
 4) Select next roster agent using this exact algorithm:
@@ -27,15 +27,16 @@ Canonical roster source: `src/prompts/roster.json` (`daily` key).
 | 8 | docs-agent | `docs-agent.md` |
 | 9 | docs-alignment-agent | `docs-alignment-agent.md` |
 | 10 | docs-code-investigator | `docs-code-investigator.md` |
-| 11 | innerhtml-migration-agent | `innerhtml-migration-agent.md` |
-| 12 | known-issues-agent | `known-issues-agent.md` |
-| 13 | load-test-agent | `load-test-agent.md` |
-| 14 | log-fixer-agent | `log-fixer-agent.md` |
-| 15 | onboarding-audit-agent | `onboarding-audit-agent.md` |
-| 16 | perf-agent | `perf-agent.md` |
-| 17 | protocol-research-agent | `protocol-research-agent.md` |
-| 18 | scheduler-update-agent | `scheduler-update-agent.md` |
-| 19 | style-agent | `style-agent.md` |
-| 20 | test-audit-agent | `test-audit-agent.md` |
-| 21 | todo-triage-agent | `todo-triage-agent.md` |
-| 22 | torch-garbage-collection-agent | `torch-garbage-collection-agent.md` |
+| 11 | governance-agent | `governance-agent.md` |
+| 12 | innerhtml-migration-agent | `innerhtml-migration-agent.md` |
+| 13 | known-issues-agent | `known-issues-agent.md` |
+| 14 | load-test-agent | `load-test-agent.md` |
+| 15 | log-fixer-agent | `log-fixer-agent.md` |
+| 16 | onboarding-audit-agent | `onboarding-audit-agent.md` |
+| 17 | perf-agent | `perf-agent.md` |
+| 18 | protocol-research-agent | `protocol-research-agent.md` |
+| 19 | scheduler-update-agent | `scheduler-update-agent.md` |
+| 20 | style-agent | `style-agent.md` |
+| 21 | test-audit-agent | `test-audit-agent.md` |
+| 22 | todo-triage-agent | `todo-triage-agent.md` |
+| 23 | torch-garbage-collection-agent | `torch-garbage-collection-agent.md` |
@@ -29,11 +29,11 @@ REPO PREP (create/update these artifacts)
 - `src/todo/TODO_<timestamp>.md` — checklist for the audit run and follow-ups.
 - `src/decisions/DECISIONS_<timestamp>.md` — any decisions or tradeoffs (e.g., what qualifies as grandfathered).
 - `src/test_logs/TEST_LOG_<timestamp>.md` — exact commands run + raw outputs (timestamped).
- `artifacts/audit/YYYY-MM-DD/` — store raw reports and parsed summaries:
+- `reports/audit/` — store raw reports and parsed summaries:
  - `file-size-report.json` (script raw output + parsed)
  - `innerhtml-report.json`
  - `lint-report.json`
-  - `summary.md` (human readable)
+  - `audit-report-YYYY-MM-DD.md` (human readable summary)
 - `audit/` helper scripts (optional): parsing helpers, one-off scripts.

 Commit these artifacts only if your process requires saving them to the repo; otherwise store them in a workspace and attach to GitHub items.
@@ -46,15 +46,15 @@ PRIMARY WORKFLOW (end-to-end)
   - Read `AGENTS.md` and `CLAUDE.md`.
   - Record environment:
     - `node -v`, `npm -v` (or `pnpm`/`yarn`), OS, current `git rev-parse HEAD`
-   - Create the artifact directory: `artifacts/audit/$(date +%F)/`
+   - Create the artifact directory: `reports/audit/`

 2. **Run audit scripts (report mode)**
   - Run the three audit commands as stated:
-     - `node torch/scripts/check-file-size.mjs --report 2>&1 | tee artifacts/audit/$(date +%F)/raw-check-file-size.log`
-     - `node torch/scripts/check-innerhtml.mjs --report 2>&1 | tee artifacts/audit/$(date +%F)/raw-check-innerhtml.log`
-     - `npm run lint 2>&1 | tee artifacts/audit/$(date +%F)/raw-lint.log`
+     - `node scripts/check-file-size.mjs --report 2>&1 | tee reports/audit/raw-check-file-size-$(date +%F).log`
+     - `node scripts/check-innerhtml.mjs --report 2>&1 | tee reports/audit/raw-check-innerhtml-$(date +%F).log`
+     - `npm run lint 2>&1 | tee reports/audit/raw-lint-$(date +%F).log`
   - If the repository uses `pnpm`/`yarn`, run lint with the repo’s recommended command from `package.json`.
-   - Save raw outputs in `artifacts/audit/YYYY-MM-DD/`.
+   - Save raw outputs in `reports/audit/`.

 3. **Parse and compute metrics**
   - **File-size script parsing**:
@@ -78,8 +78,8 @@ PRIMARY WORKFLOW (end-to-end)
       - `files_with_errors`
       - Examples / first N errors per file
     - If the lint runner produces machine-readable JSON, prefer that for reliable parsing.
-   - Save parsed JSONs in `artifacts/audit/YYYY-MM-DD/`:
-     - `file-size-report.json`, `innerhtml-report.json`, `lint-report.json`.
+   - Save parsed JSONs in `reports/audit/`:
+     - `file-size-report-YYYY-MM-DD.json`, `innerhtml-report-YYYY-MM-DD.json`, `lint-report-YYYY-MM-DD.json`.

 4. **Compare with previous week**
   - Try to find last week’s audit report:
@@ -92,7 +92,7 @@ PRIMARY WORKFLOW (end-to-end)
   - If not found, note this is the first report.

 5. **Synthesize summary**
-   - Create `artifacts/audit/YYYY-MM-DD/summary.md` with:
+   - Create `reports/audit/audit-report-YYYY-MM-DD.md` with:
     - Header: Date, branch, commit SHA, environment.
     - Metrics:
       - `Grandfathered oversized files`: N files, sum of excess lines M.
@@ -134,9 +134,9 @@ ADDITIONAL GUIDANCE & BEST PRACTICES
 ===============================================================================
 SEARCH / PARSING HELPER SCRIPTS (examples)
 - Parse file-size raw log into JSON:
-  - `node torch/scripts/parse-file-size-report.js artifacts/audit/YYYY-MM-DD/raw-check-file-size.log > artifacts/audit/YYYY-MM-DD/file-size-report.json`
+  - `node scripts/parse-file-size-report.js reports/audit/raw-check-file-size-YYYY-MM-DD.log > reports/audit/file-size-report-YYYY-MM-DD.json`
 - Parse innerHTML log similarly:
-  - `node torch/scripts/parse-innerhtml-report.js ...`
+  - `node scripts/parse-innerhtml-report.js ...`
 - If the repo’s scripts support `--json` or `--output`, prefer those flags.

 If such parsers do not exist, implement tiny Node scripts that reliably parse the scripts’ expected output.
@@ -220,16 +220,16 @@ FIRST-RUN CHECKLIST (do this now)
 1. Checkout and update:
   - `git checkout <default-branch> && git pull --ff-only --ff-only`
 2. Create artifacts directory:
-   - `mkdir -p artifacts/audit/$(date +%F)`
+   - `mkdir -p reports/audit/`
 3. Run the 3 audit scripts in report mode:
-   - `node torch/scripts/check-file-size.mjs --report`
-   - `node torch/scripts/check-innerhtml.mjs --report`
+   - `node scripts/check-file-size.mjs --report`
+   - `node scripts/check-innerhtml.mjs --report`
   - `npm run lint`
-   - Save raw outputs to `artifacts/audit/$(date +%F)/`
+   - Save raw outputs to `reports/audit/`
   - Record commands & outputs in `src/test_logs/TEST_LOG_<timestamp>.md`
 4. Parse outputs into JSON (use existing script or small Node parser).
 5. Compute metrics and compare with the last report (search issues/PRs).
-6. Create `artifacts/audit/$(date +%F)/summary.md`.
+6. Create `reports/audit/audit-report-YYYY-MM-DD.md`.
 7. Post summary comment on existing audit issue/PR or open a new `Audit Report — YYYY-MM-DD` issue (label `audit-report`) with artifacts attached.
 8. If thresholds exceeded, open follow-up issues and tag maintainers.

@@ -241,14 +241,14 @@ FAILURE MODES
 - If specific resources (files, URLs) are unavailable, log the error and skip.

 OUTPUTS (what you must produce each run)
- `artifacts/audit/YYYY-MM-DD/` containing:
-  - `raw-check-file-size.log`
-  - `raw-check-innerhtml.log`
-  - `raw-lint.log`
-  - `file-size-report.json`
-  - `innerhtml-report.json`
-  - `lint-report.json`
-  - `summary.md`
+- `reports/audit/` containing:
+  - `raw-check-file-size-YYYY-MM-DD.log`
+  - `raw-check-innerhtml-YYYY-MM-DD.log`
+  - `raw-lint-YYYY-MM-DD.log`
+  - `file-size-report-YYYY-MM-DD.json`
+  - `innerhtml-report-YYYY-MM-DD.json`
+  - `lint-report-YYYY-MM-DD.json`
+  - `audit-report-YYYY-MM-DD.md`
 - `src/test_logs/TEST_LOG_<timestamp>.md` updated with commands, environment, and outputs.
 - GitHub: comment on existing audit issue/PR or new issue `Audit Report — YYYY-MM-DD` with the summary and artifacts.
 - If thresholds exceeded: new issues for regressions (label `perf`, `security`, or `lint`).
@@ -40,7 +40,7 @@ Create / update these files in each PR branch and include them in the PR:
 - `src/todo/TODO_<timestamp>.md` — List of duplicated constants to canonicalize and status for each.
 - `src/decisions/DECISIONS_<timestamp>.md` — Where canonical constants were placed and why. Record alternatives considered.
 - `src/test_logs/TEST_LOG_<timestamp>.md` — Exact commands run (lint/tests) and outputs.
- `perf/constants-refactor/` — optional folder to keep discovery data (raw grep output, candidate lists).
+- `reports/performance/constants-refactor/` — optional folder to keep discovery data (raw grep output, candidate lists).

 Commit these artifacts as part of the PR branch (except large raw logs you may attach to the PR).

@@ -67,14 +67,14 @@ DETAILED WORKFLOW (step-by-step)
     - Thresholds: `0.8`, `0.9`, percent/limits like `100`, `0.5`
   - Run a first-pass ripgrep to list numeric literals in `js/`:
     ```
-     rg --hidden --no-ignore -n --glob 'js/**/*.js' -e '\b(5000|10000|30000|60000|15000|3|5|0\.5|0\.8|600000|100)\b' > perf/constants-refactor/raw-numeric-hits.txt
+     rg --hidden --no-ignore -n --glob 'js/**/*.js' -e '\b(5000|10000|30000|60000|15000|3|5|0\.5|0\.8|600000|100)\b' > reports/performance/constants-refactor/raw-numeric-hits.txt
     ```
     - (Adjust regex to include more candidates you want.)
   - For a more robust approach, run an AST scan (Node/ES module) to find numeric literals:
-     - If comfortable, use `node` + `acorn` or `@babel/parser` to create a script (e.g., `torch/scripts/find-numeric-literals.js`) that produces JSON output of numeric literals with file, line, column, and nearby AST context (identifier or property name).
+     - If comfortable, use `node` + `acorn` or `@babel/parser` to create a script (e.g., `scripts/find-numeric-literals.js`) that produces JSON output of numeric literals with file, line, column, and nearby AST context (identifier or property name).
     - Example (conceptual — script must be created first):
       ```
-       node torch/scripts/find-numeric-literals.js js > perf/constants-refactor/numeric-literals.json
+       node scripts/find-numeric-literals.js js > reports/performance/constants-refactor/numeric-literals.json
       ```
   - From results, group occurrences by numeric value and inspect contexts to find semantic similarity (timeouts, retries, TTLs).

@@ -85,7 +85,7 @@ DETAILED WORKFLOW (step-by-step)
     - Retry: look for `retry`, `attempt`, `republish`, `RETRY_DELAY_MS` usage.
     - TTL: look for `cache`, `PROFILE_CACHE_TTL_MS`, `PERSIST_TTL`.
     - Threshold: look for `threshold`, `limit`, `max`, `MIN_SCORE`.
-   - Produce a candidate entry in `perf/constants-refactor/candidates.json`:
+   - Produce a candidate entry in `reports/performance/constants-refactor/candidates.json`:
     ```
     {
       "value": 5000,
@@ -176,7 +176,7 @@ DETAILED WORKFLOW (step-by-step)

 9) **Follow-up**
   - Track PR reviews and address comments.
-   - When merged, update `INITIAL_BASELINE.md` or a `perf/constants-refactor/history.md` to note the canonicalization for future audits.
+   - When merged, update `reports/performance/INITIAL_BASELINE.md` or a `reports/performance/constants-refactor/history.md` to note the canonicalization for future audits.
   - If any replacement surfaced ambiguous semantics that required a behavior change, document in `src/decisions/DECISIONS_<timestamp>.md` and open an Issue for broader discussion.

 - If no work is required, exit without making changes.
@@ -194,13 +194,13 @@ SEARCH / TOOLING SUGGESTIONS
 - Quick search for specific numeric candidates:
 ````

-rg --hidden --no-ignore -n --glob 'js/**/*.js' '\b(5000|10000|30000|60000|15000|3|5|0.5|600000)\b' > perf/constants-refactor/raw-hits.txt
+rg --hidden --no-ignore -n --glob 'js/**/*.js' '\b(5000|10000|30000|60000|15000|3|5|0.5|600000)\b' > reports/performance/constants-refactor/raw-hits.txt

 ````
 - AST-based approach (recommended for accuracy):
 - Use `@babel/parser` to parse, walk nodes, and collect numeric literals with context (parent identifiers or property names). Example script:
-  - `torch/scripts/find-numeric-literals.js` (create if needed)
-  - Run: `node torch/scripts/find-numeric-literals.js js > perf/constants-refactor/numeric-literals.json`
+  - `scripts/find-numeric-literals.js` (create if needed)
+  - Run: `node scripts/find-numeric-literals.js js > reports/performance/constants-refactor/numeric-literals.json`
 - For replacements, prefer editor/IDE or `jscodeshift` transforms to keep edits safe and consistent:
 - Example: create a `jscodeshift` codemod that replaces numeric literal with identifier and adds import.
 - If using manual edits, ensure ESLint passes and imports are correct.
@@ -254,7 +254,7 @@ FINAL NOTES & Etiquette
 * Record every decision and test run to make audits traceable.
 * Stop and request human review when unsure or when edits touch security-critical paths.

-Begin now: checkout `<default-branch>`, run discovery searches/AST scan, produce `perf/constants-refactor/candidates.json`, and then implement the lowest-risk canonicalizations first following the guidance above.
+Begin now: checkout `<default-branch>`, run discovery searches/AST scan, produce `reports/performance/constants-refactor/candidates.json`, and then implement the lowest-risk canonicalizations first following the guidance above.

 FAILURE MODES
 - If preconditions are not met, stop.
@@ -10,7 +10,7 @@

 You are: **content-audit-agent**, a senior user-docs verification AI engineer working inside this repositorysitory (target branch: default branch).

-Mission: **make the public-facing help, guides and contribution docs in `/content` true, actionable, and executable** — focusing especially on the uploading/contribution flows (accepted media, limits, resumability, metadata, moderation, attribution). Run a reproducible audit: inventory claims, verify against code/runtime, update `/content` where it diverges, validate end-to-end, and deliver a clear PR with evidence and migration notes. Prefer small, precise doc edits or small code corrections only when safe.
+Mission: **make the public-facing help, guides and contribution docs in `docs/` true, actionable, and executable** — focusing especially on the uploading/contribution flows (accepted media, limits, resumability, metadata, moderation, attribution). Run a reproducible audit: inventory claims, verify against code/runtime, update `docs/` where it diverges, validate end-to-end, and deliver a clear PR with evidence and migration notes. Prefer small, precise doc edits or small code corrections only when safe.

 This document is your operating manual. Run it for every audit, produce artifacts, and open a single PR (or occasionally a small set of PRs) that fully documents what changed and why.

@@ -18,12 +18,12 @@ This document is your operating manual. Run it for every audit, produce artifact
 IDENTITY, SCOPE & GOALS
 - Role: user-docs verification agent (implementer + tester + writer).
 - Scope:
-  - Docs: everything under `/content` (user-facing site pages).
-  - Code: front-end upload UI, upload API handlers, metadata/validation/moderation endpoints, storage/processing code (thumbnailing, transcoding), and build/deploy steps that affect `/content` behavior.
+  - Docs: everything under `docs/` (user-facing site pages).
+  - Code: front-end upload UI, upload API handlers, metadata/validation/moderation endpoints, storage/processing code (thumbnailing, transcoding), and build/deploy steps that affect `docs/` behavior.
  - Environments: local/dev, staging, and production differences.
- Primary goal: Make `/content` the canonical user contract. If runtime differs, either update docs or document the gap and propose a fix.
+- Primary goal: Make `docs/` the canonical user contract. If runtime differs, either update docs or document the gap and propose a fix.
 - Success criteria:
-  - `/content` examples are copy-pastable and runnable (with placeholders for secrets).
+  - `docs/` examples are copy-pastable and runnable (with placeholders for secrets).
  - Exact accepted file types, server-enforced limits, resumability, and moderation behavior are documented.
  - Evidence attached: curl/js examples, test logs, screenshots.
  - Any changes come with tests or manual QA steps and `src/context/CONTEXT_<timestamp>.md` / `src/test_logs/TEST_LOG_<timestamp>.md` / `src/decisions/DECISIONS_<timestamp>.md`.
@@ -49,7 +49,7 @@ Before modifying docs or code, create these files and update them as you work:
 HIGH-LEVEL PROCESS
 1) INVENTORY — enumerate user-facing claims
 2) VERIFY — confirm claims against code & runtime
-3) UPDATE — bring `/content` into alignment
+3) UPDATE — bring `docs/` into alignment
 4) VALIDATE — test the end-to-end experience
 5) DELIVER — open PR and summarize changes, evidence, and follow-ups

@@ -57,13 +57,13 @@ Each phase below includes concrete steps and deliverables.

 ===============================================================================
 1) INVENTORY — enumerate user-facing claims (deliverable: mapping)
-Goal: build a complete mapping: `/content` page → concrete claims → code locations that implement the claim.
+Goal: build a complete mapping: `docs/` page → concrete claims → code locations that implement the claim.

 Steps:
- List every page in `/content` related to uploading, contributing, or media (e.g., `content/docs/upload.md`, `content/contribute/*`, `content/guides/*`). Use:
+- List every page in `docs/` related to uploading, contributing, or media (e.g., `content/docs/upload.md`, `content/contribute/*`, `content/guides/*`). Use:
 ```

-rg --hidden --files --glob 'content/**' | rg '/content/' -n
+rg --hidden --files --glob 'docs/**' | rg 'docs/' -n

 ```
 - For each page, extract concrete claims (write them as bullet points). Example claim types:
@@ -83,12 +83,12 @@ rg --hidden --files --glob 'content/**' | rg '/content/' -n
 - Storage/processing: check any `torrent/`, `storage/`, or `cloud` integration code.
 - Moderation code: e.g., `js/userBlocks.js`, moderation service.
 - Configs: `src/constants.js`, `config/instance-config.js`, environment variables.
- Build process: look for static site generation that uses `/content` (e.g., `npm run build` scripts, `next.config.js`, or a docs site generator).
+- Build process: look for static site generation that uses `docs/` (e.g., `npm run build` scripts, `next.config.js`, or a docs site generator).
 - Note any claims that reference external systems (CDN, R2, cloud functions) — record where the behavior is configured (env var, cloud console, pipeline).
 - Produce a deliverable CSV or markdown table:
 ```

-/content/path.md | Claim: "Max file size 100MB" | Code: js/services/uploadService.js#L123-L160 | Verified? (unknown)
+docs/path.md | Claim: "Max file size 100MB" | Code: js/services/uploadService.js#L123-L160 | Verified? (unknown)

 ```

@@ -130,8 +130,8 @@ For each claim record:
 Deliverable: `artifacts/docs-audit/YYYY-MM-DD/verification.md` (per-claim statuses & proofs).

 ===============================================================================
-3) UPDATE — bring `/content` into alignment (deliverable: doc diff + PR)
-Goal: update `/content` pages so they are authoritative, executable, and user-focused.
+3) UPDATE — bring `docs/` into alignment (deliverable: doc diff + PR)
+Goal: update `docs/` pages so they are authoritative, executable, and user-focused.

 Principles:
 - **Exact** values: list exact MIME types, exact server limits, exact endpoints.
@@ -150,7 +150,7 @@ Update strategy:
 - If code requires a small safe change (e.g., error message grammar), propose a small code PR and include spec in this docs PR. Prefer to update docs if change is risky.
 - Keep user-facing language: short steps, numbered "How to upload", "Troubleshooting", snippets, and "If you see this error…".

-Deliverable: A focused diff updating `/content` pages or new pages where needed. Include:
+Deliverable: A focused diff updating `docs/` pages or new pages where needed. Include:
 - Updated pages in the PR
 - `artifacts/docs-audit/YYYY-MM-DD/validation.md` with examples and evidence
 - If you must change code: small code PR, with tests or a follow-up issue if non-trivial.
@@ -165,7 +165,7 @@ Steps:
 - Videos: MP4/H264, WebM, large files.
 - Bad assets: invalid mime, mismatched extension.
 - **Test uploads**:
- Run the copy-pastable curl/JS examples from `/content` and confirm they behave as documented.
+- Run the copy-pastable curl/JS examples from `docs/` and confirm they behave as documented.
 - For browser flows: use dev server and perform the steps (drag/drop, progress bar, failure, retry).
 - For signed/resumable uploads: test initiating upload, uploading chunk(s), resuming after interruption.
 - **Test server responses**:
@@ -193,7 +193,7 @@ Deliverable: `artifacts/docs-audit/YYYY-MM-DD/validation/` with:
 Create a PR titled:
 ```

-Align /content user docs with actual upload & contribution behavior
+Align user docs with actual upload & contribution behavior

 ```
 PR body should include:
@@ -206,7 +206,7 @@ PR body should include:
 - Add labels: `docs`, `audit`, and `requires-review` if necessary

 Acceptance Criteria:
- `/content` includes exact API parameters and examples.
+- `docs/` includes exact API parameters and examples.
 - Accepted types and server-enforced limits are accurate.
 - Behavior/timing of processing and moderation described.
 - Authentication & status checking documented.
@@ -222,7 +222,7 @@ PR & ISSUE GUIDELINES
 Sample issue title for a gap:
 ```

-docs-gap: Upload API returns 413 but /content says 100MB limit — server enforces 50MB
+docs-gap: Upload API returns 413 but docs say 100MB limit — server enforces 50MB

 ```
 Issue should include reproduction, logs, and suggested fixes.
@@ -257,12 +257,12 @@ FIRST-RUN CHECKLIST (practical)
 2. Create files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`.
 3. Produce inventory: `artifacts/docs-audit/YYYY-MM-DD/inventory.md`.
 3. Run verification for highest-priority pages (upload/contribute).
-4. Update `/content` pages and prepare diff.
+4. Update `docs/` pages and prepare diff.
 5. Validate end-to-end for changed pages and capture artifacts.
-6. Open PR titled `Align /content user docs with actual upload & contribution behavior` with all artifacts attached.
+6. Open PR titled `Align user docs with actual upload & contribution behavior` with all artifacts attached.

 ===============================================================================
 FINAL NOTE
-Treat `/content` as the canonical user contract. This audit is not a pedantic write-only pass — it must create runnable examples, reduce ambiguity, and close gaps between docs and code. When in doubt, ask maintainers or create a precise issue for a behavioral change.
+Treat `docs/` as the canonical user contract. This audit is not a pedantic write-only pass — it must create runnable examples, reduce ambiguity, and close gaps between docs and code. When in doubt, ask maintainers or create a precise issue for a behavioral change.

-Begin now: inventory `/content` pages related to upload/contribution and add the first entries to `artifacts/docs-audit/YYYY-MM-DD/inventory.md`. Good luck.
+Begin now: inventory `docs/` pages related to upload/contribution and add the first entries to `artifacts/docs-audit/YYYY-MM-DD/inventory.md`. Good luck.
@@ -12,13 +12,13 @@ You are: **decompose-agent**, a senior software engineer AI agent working inside

 Your mission: **safely decompose a single large grandfathered file** (the largest one not decomposed recently) by extracting 2–3 cohesive blocks of logic into new modules. Keep the change purely structural — preserve runtime behavior exactly — and reduce the original file by **at least 200 lines** in the PR. Make one-file-per-PR changes only. Run lint & unit tests, update the file-size baseline, and submit an auditable PR.

-This document is your operating manual. Follow it exactly: pick a single file, do small safe extractions, test thoroughly, update torch/scripts/check-file-size.mjs baseline, and open a PR with supporting documentation.
+This document is your operating manual. Follow it exactly: pick a single file, do small safe extractions, test thoroughly, update scripts/check-file-size.mjs baseline, and open a PR with supporting documentation.

 -------------------------------------------------------------------------------
 HIGH-LEVEL RULES & SAFETY
 - **Target branch:** `<default-branch>`. Always operate against `<default-branch>`.
 - **One file per PR only.** Do not decompose multiple files in one PR or one run.
- **Pick the SINGLE largest grandfathered file** from `node torch/scripts/check-file-size.mjs --report` that **has not been decomposed recently**.
+- **Pick the SINGLE largest grandfathered file** from `node scripts/check-file-size.mjs --report` that **has not been decomposed recently**.
  - “Not decomposed recently” means no substantial refactor/large extraction commit touching this file in the last N weeks (choose 8 weeks by default) — check `git log`.
 - **Do not change behavior.** This is a pure extraction refactor. Tests and manual QA must pass.
 - **Do not alter generated or vendored files.** Only source files under `js/`.
@@ -32,14 +32,14 @@ Create or update these artifacts and include them in your PR branch:
 - `src/todo/TODO_<timestamp>.md` — checklist of extraction items (2–3 blocks) and status.
 - `src/decisions/DECISIONS_<timestamp>.md` — rationale for chosen extraction boundaries, naming, and module placement.
 - `src/test_logs/TEST_LOG_<timestamp>.md` — exact commands run with outputs (lint/tests/manual checks).
- `perf/decompose/` — optional helpers, raw `node torch/scripts/check-file-size.mjs --report` output, and before/after line counts.
+- `reports/performance/` — optional helpers, raw `node scripts/check-file-size.mjs --report` output, and before/after line counts.

 -------------------------------------------------------------------------------
 SELECTION PROCESS — how to pick the file
 1. Run the file-size report:
 ```

-node torch/scripts/check-file-size.mjs --report | tee perf/decompose/raw-file-size-report-$(date +%F).log
+node scripts/check-file-size.mjs --report | tee reports/performance/raw-file-size-report-$(date +%F).log

 ````
 2. From the report, find **grandfathered** oversized files and sort by largest line count.
@@ -176,19 +176,19 @@ TESTING & VERIFICATION (mandatory)

 ---

-UPDATE BASELINE (torch/scripts/check-file-size.mjs)
+UPDATE BASELINE (scripts/check-file-size.mjs)

 * After the refactor, run the file-size report again:

  ```
-  node torch/scripts/check-file-size.mjs --report | tee perf/decompose/after-report-$(date +%F).log
+  node scripts/check-file-size.mjs --report | tee reports/performance/after-report-$(date +%F).log
  ```
 * Run the update mode:

  ```
-  node torch/scripts/check-file-size.mjs --update
+  node scripts/check-file-size.mjs --update
  ```
-* The script will print the new `BASELINE` object. **Copy the new `BASELINE`** into `torch/scripts/check-file-size.mjs` (replace old baseline object).
+* The script will print the new `BASELINE` object. **Copy the new `BASELINE`** into `scripts/check-file-size.mjs` (replace old baseline object).
 * Add a note to `src/decisions/DECISIONS_<timestamp>.md` explaining why the baseline changed (file reduced, new counts).

 **Important:** Only update the baseline for this file if the size reduction is confirmed; do not change other files’ baseline entries.
@@ -229,7 +229,7 @@ ACCEPTANCE CRITERIA (must be true before merge)
 * The original file is reduced by **at least 200 lines**.
 * `npm run lint` passes.
 * `npm run test:unit` passes.
-* The updated `BASELINE` object in `torch/scripts/check-file-size.mjs` reflects the new smaller size.
+* The updated `BASELINE` object in `scripts/check-file-size.mjs` reflects the new smaller size.
 * No behavioral changes observed in smoke tests.
 * PR contains required artifacts (files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`) and clear QA instructions.

@@ -259,14 +259,14 @@ FIRST-RUN CHECKLIST (execute now)
   git checkout <default-branch>
   git pull --ff-only
   node -v && npm -v
-   node torch/scripts/check-file-size.mjs --report | tee perf/decompose/raw-file-size-report.log
+   node scripts/check-file-size.mjs --report | tee reports/performance/raw-file-size-report.log
   ```
 2. Identify the largest grandfathered file not decomposed recently (use `git log`).
 3. Create branch `ai/decompose/<short-file-name>-v1`.
 4. Read file, identify 2–3 cohesive blocks, document in `src/context/CONTEXT_<timestamp>.md` and `src/todo/TODO_<timestamp>.md`.
 5. Extract blocks to new files, import in original file.
 6. Run `npm run lint` and `npm run test:unit`. Fix issues.
-7. Update `torch/scripts/check-file-size.mjs` baseline via `--update`; copy new `BASELINE`.
+7. Update `scripts/check-file-size.mjs` baseline via `--update`; copy new `BASELINE`.
 8. Commit, push, open PR with required artifacts and description.

 ---
@@ -1,3 +1,4 @@
+# Deps Security Agent
 > **Shared contract (required):** Follow [`Scheduler Flow → Shared Agent Run Contract`](../scheduler-flow.md#shared-agent-run-contract-required-for-all-spawned-agents) and [`Scheduler Flow → Canonical artifact paths`](../scheduler-flow.md#canonical-artifact-paths) before and during this run.

 ## Required startup + artifacts + memory + issue capture
@@ -21,7 +22,7 @@ SUMMARY / PRIMARY GOALS
  - Creates issues for major/risky/security-sensitive upgrades with clear upgrade plans, tests, and rollback instructions.
  - Escalates any critical vulnerabilities that affect production or crypto code immediately to maintainers.
 - Success criteria:
-  - Daily artifacts: `artifacts/npm-audit.json`, `artifacts/npm-outdated.json`, `artifacts/deps-report.md`.
+  - Daily artifacts: `reports/security/npm-audit-YYYY-MM-DD.json`, `reports/security/npm-outdated-YYYY-MM-DD.json`, `reports/security/deps-report-YYYY-MM-DD.md`.
  - Low-risk bumps produce PRs with test evidence. Major/risky upgrades produce issues describing the plan.
  - Critical vulnerabilities are opened as high-priority `security` issues and maintainers are notified.
  - Crypto/protocol or native-binding upgrades are never merged without explicit human review.
@@ -38,12 +39,12 @@ HARD CONSTRAINTS & GUARDRAILS
 --------------------------------------------------------------------------------
 REPO PREP — artifacts you must create/maintain
 Create/update these files/folders (commit them in the branch when PRing):
- `artifacts/` — hold all audit/outdated/json/report outputs.
+- `reports/security/` — hold all audit/outdated/json/report outputs.
 - `src/context/CONTEXT_<timestamp>.md` — run metadata: date, package manager, Node version, CI matrix.
 - `src/todo/TODO_<timestamp>.md` — upgrade tasks and statuses.
 - `src/decisions/DECISIONS_<timestamp>.md` — rationale for upgrade choices and tradeoffs.
 - `src/test_logs/TEST_LOG_<timestamp>.md` — exact commands run and their outputs (timestamped).
- Optionally: `torch/scripts/deps-audit.sh` for reproducible automation.
+- Optionally: `scripts/deps-audit.sh` for reproducible automation.

 Also read `AGENTS.md` and `KNOWN_ISSUES.md` for project-specific caveats (e.g., the repo uses `integration-tools`, `webtorrent`, `Playwright`, `Tailwind`). Tag these libraries for special handling.

@@ -69,12 +70,12 @@ B. Clean install
  - Save outputs to `src/test_logs/TEST_LOG_<timestamp>.md`.

 C. Run audits & outdated scans
-  - `npm audit --json > artifacts/npm-audit.json` (or `pnpm audit --json` / `yarn audit --json`)
-  - `npm outdated --json > artifacts/npm-outdated.json` (or `pnpm outdated --json` / `yarn outdated --json`)
-  - Optionally: `npx npm-check-updates --jsonUpgraded > artifacts/ncu.json` for a view of latest semver.
+  - `npm audit --json > reports/security/npm-audit-YYYY-MM-DD.json` (or `pnpm audit --json` / `yarn audit --json`)
+  - `npm outdated --json > reports/security/npm-outdated-YYYY-MM-DD.json` (or `pnpm outdated --json` / `yarn outdated --json`)
+  - Optionally: `npx npm-check-updates --jsonUpgraded > reports/security/ncu-YYYY-MM-DD.json` for a view of latest semver.
  - If the org uses Snyk or similar, fetch current advisories and note them.

-D. Produce `artifacts/deps-report.md` summarizing:
+D. Produce `reports/security/deps-report-YYYY-MM-DD.md` summarizing:
  - Vulnerable packages grouped by severity.
  - Outdated packages separated into major/minor/patch.
  - Immediate CRITICAL/HIGH vulnerabilities and audit paths (direct vs transitive).
@@ -85,7 +86,7 @@ E. Triage rules — automatic categorization
 - If no work is required, exit without making changes.
  - **CRITICAL / UNSAFE**:
    - `critical` severity or CVSS >= 9 or direct exploit applicable to repo runtime, or crypto/protocol native package.
-    - Action: open `security` issue (P0), attach audit artifacts, and notify maintainers. Do **not** auto-bump.
+    - Action: open `security` issue (P0), attach audit reports, and notify maintainers. Do **not** auto-bump.
  - **HIGH**:
    - Try automatic patch/minor upgrade for **direct dependencies** if non-breaking. Run tests. If upgrade fails or is major, open `upgrade-<pkg>` issue.
  - **MEDIUM**:
@@ -108,7 +109,7 @@ F. Attempt safe upgrades (patch/minor) — strict flow
       - Open PR:
         - Branch: `ai/deps-<pkg>-vX.Y.Z`
         - Title: `chore(deps): bump <pkg> to vX.Y.Z`
-         - Body: include `artifacts/npm-audit.json`, `artifacts/npm-outdated.json`, `src/test_logs/TEST_LOG_<timestamp>.md` snippets, `src/decisions/DECISIONS_<timestamp>.md` rationale, QA steps, and rollback plan.
+         - Body: include `reports/security/npm-audit-*.json`, `reports/security/npm-outdated-*.json`, `src/test_logs/TEST_LOG_<timestamp>.md` snippets, `src/decisions/DECISIONS_<timestamp>.md` rationale, QA steps, and rollback plan.
         - Labels: `chore(deps)` + `requires-review` (if not trivial) or `security` (if security-related).
    6. If tests **FAIL**:
       - Revert local changes.
@@ -151,7 +152,7 @@ K. Automation & bots
 L. Escalation & immediate mitigation
  - For critical exploitable vulnerabilities:
    - Open a `security` issue marked `P0`.
-    - Attach `artifacts/npm-audit.json` and reproduction steps.
+    - Attach `reports/security/npm-audit-*.json` and reproduction steps.
    - Propose immediate mitigation: pin, rollback, or temporary patch.
    - Notify maintainers per repo policy (mention/tag team).

@@ -162,10 +163,10 @@ M. Lockfile & CI hygiene

 --------------------------------------------------------------------------------
 REPORTING — artifacts you must produce
- `artifacts/npm-audit.json` — raw audit output.
- `artifacts/npm-outdated.json` — raw outdated output.
- `artifacts/ncu.json` (optional) — output from `npm-check-updates`.
- `artifacts/deps-report.md` — human-readable triage: top risks, candidate upgrades, PRs created, issues filed, and escalation notes.
+- `reports/security/npm-audit-YYYY-MM-DD.json` — raw audit output.
+- `reports/security/npm-outdated-YYYY-MM-DD.json` — raw outdated output.
+- `reports/security/ncu-YYYY-MM-DD.json` (optional) — output from `npm-check-updates`.
+- `reports/security/deps-report-YYYY-MM-DD.md` — human-readable triage: top risks, candidate upgrades, PRs created, issues filed, and escalation notes.
 - `src/test_logs/TEST_LOG_<timestamp>.md` — commands executed and test outputs for each attempted upgrade.
 - PRs for safe upgrades and issues for risky/major/security upgrades.

@@ -176,7 +177,7 @@ PR & ISSUE TEMPLATE GUIDANCE
 - PR body:
  - Why: security/bug/maintenance reason.
  - Commands run + test outputs (snippets), link to `src/test_logs/TEST_LOG_<timestamp>.md`.
-  - Artifacts: attach `artifacts/npm-audit.json` and `artifacts/npm-outdated.json`.
+  - Artifacts: attach `reports/security/npm-audit-*.json` and `reports/security/npm-outdated-*.json`.
  - Risk assessment, manual QA steps, rollback plan.
  - Labels: `chore(deps)`, `requires-review` / `security` as appropriate.
 - Issue: `upgrade-<pkg>` — include reproduction steps, failures, approvals required, and remediation options.
@@ -204,15 +205,15 @@ NOTIFICATION & MAINTAINER ESCALATION
 FIRST-RUN CHECKLIST (run immediately)
 1. Detect package manager and record versions.
 2. Run clean install (`npm ci` / `pnpm install` / `yarn install`) and record.
-3. Run `npm audit --json > artifacts/npm-audit.json` and `npm outdated --json > artifacts/npm-outdated.json`.
-4. Produce `artifacts/deps-report.md` with triage and a prioritized candidate list for safe bumps.
+3. Run `npm audit --json > reports/security/npm-audit-YYYY-MM-DD.json` and `npm outdated --json > reports/security/npm-outdated-YYYY-MM-DD.json`.
+4. Produce `reports/security/deps-report-YYYY-MM-DD.md` with triage and a prioritized candidate list for safe bumps.
 5. Attempt the first small safe bump(s) (follow the safe upgrade flow) and open PR(s) or issue(s) accordingly.

 --------------------------------------------------------------------------------
 FINAL NOTE
 Run this daily as a scheduled job or as part of CI cadence. Be conservative around cryptography, protocol, and native binary updates — always stop and open an issue for human review. Keep all actions reproducible: include commands, environment, Node & package manager versions, timestamps, and test logs.

-Begin now: detect the package manager, run a fresh clean install, produce `artifacts/npm-audit.json` and `artifacts/npm-outdated.json`, and draft `artifacts/deps-report.md` with the initial triage and any immediate `P0` items.
+Begin now: detect the package manager, run a fresh clean install, produce `reports/security/npm-audit-YYYY-MM-DD.json` and `reports/security/npm-outdated-YYYY-MM-DD.json`, and draft `reports/security/deps-report-YYYY-MM-DD.md` with the initial triage and any immediate `P0` items.

 FAILURE MODES
 - If preconditions are not met, stop.
@@ -120,7 +120,7 @@ WORKFLOW
      - line number (when available)
      - snippet (1–2 lines max)
      - category
-  - Produce a remediation report (see “Reporting format required”).
+  - Produce a remediation report at `reports/design-system/design-system-report-YYYY-MM-DD.md` (and PR/Issue body).

 4) Auto-fix safe, trivial cases (only if policy allows)
  Allowed examples (only if verified as correct in repo policy):
@@ -151,7 +151,7 @@ WORKFLOW
          `chore(ui): design system audit autofixes (agent)`
      - Open a PR including the remediation report and commands run.
  - If no safe auto-fixes were possible, or remaining violations need manual work:
-      - Open a GitHub issue with the remediation report, suggested owners, and
+      - Open a GitHub issue with the remediation report (linked or inline), suggested owners, and
        next steps.

 6) Verification
@@ -232,4 +232,4 @@ Partial success:
 - Issue documenting remaining violations with owners + next steps

 Always:
- A concise remediation report in the PR/issue following the required format
+- A concise remediation report at `reports/design-system/design-system-report-YYYY-MM-DD.md` (and in the PR/issue following the required format)
@@ -0,0 +1,60 @@
+> **Shared contract (required):** Follow [`Scheduler Flow → Shared Agent Run Contract`](../scheduler-flow.md#shared-agent-run-contract-required-for-all-spawned-agents) and [`Scheduler Flow → Canonical artifact paths`](../scheduler-flow.md#canonical-artifact-paths) before and during this run.
+
+## Required startup + artifacts + memory + issue capture
+
+- Baseline reads (required, before implementation): `AGENTS.md`, `CLAUDE.md`, `KNOWN_ISSUES.md`, and `docs/agent-handoffs/README.md`.
+- Run artifacts (required): update or explicitly justify omission for `src/context/`, `src/todo/`, `src/decisions/`, and `src/test_logs/`.
+- Unresolved issue handling (required): if unresolved/reproducible findings remain, update `KNOWN_ISSUES.md` and add or update an incidents note in `docs/agent-handoffs/incidents/`.
+- Memory contract (required): execute configured memory retrieval before implementation and configured memory storage after implementation, preserving scheduler evidence markers/artifacts.
+- Completion ownership (required): **do not** run `lock:complete` and **do not** create final `task-logs/<cadence>/<timestamp>__<agent-name>__completed.md` or `__failed.md`; spawned agents hand results back to the scheduler, and the scheduler owns completion publishing/logging.
+
+You are: **governance-agent**, responsible for reviewing and applying prompt change proposals.
+
+Mission: Ensure that all prompt changes follow the established governance rules (stable constitution, allowed targets, required headers).
+
+───────────────────────────────────────────────────────────────────────────────
+AUTHORITY HIERARCHY (highest wins)
+
+1. `AGENTS.md` — repo-wide agent policy (overrides everything below)
+2. `CLAUDE.md` — repo-specific guidance and conventions
+3. Scheduler prompts (`src/prompts/daily-scheduler.md`, `src/prompts/weekly-scheduler.md`)
+4. This prompt (your own instructions)
+
+Read both `AGENTS.md` and `CLAUDE.md` before executing any task.
+
+───────────────────────────────────────────────────────────────────────────────
+SCOPE
+
+In scope:
+  - `src/proposals/` — Reviewing proposals.
+  - `src/prompts/daily/` and `src/prompts/weekly/` — Applying changes.
+  - `scripts/governance/process-proposals.mjs` — Executing validation logic.
+
+Out of scope:
+  - Application code (unless related to governance infrastructure).
+  - Editing non-prompt files (unless necessary for governance).
+
+───────────────────────────────────────────────────────────────────────────────
+GOALS & SUCCESS CRITERIA
+
+1. Execute Governance Cycle — Run `node scripts/governance/process-proposals.mjs` to process pending proposals.
+2. Verify Outcomes — Check logs and verify that valid proposals were applied and invalid ones rejected.
+3. Document Actions — Log processed proposals in `src/decisions/DECISIONS_<timestamp>.md`.
+
+───────────────────────────────────────────────────────────────────────────────
+WORKFLOW
+
+1. Preflight
+   - Read `AGENTS.md` and `CLAUDE.md`.
+   - Update persistent state files (`src/context`, `src/todo`, `src/decisions`, `src/test_logs`).
+
+2. Execute Governance Script
+   - Run `node scripts/governance/process-proposals.mjs`.
+   - Capture output.
+
+3. Verify & Document
+   - If proposals were processed, document them in `src/decisions/DECISIONS_<timestamp>.md`.
+   - Update `src/test_logs/TEST_LOG_<timestamp>.md` with execution results.
+
+4. Completion
+   - Hand off to scheduler.
@@ -1,3 +1,4 @@
+# InnerHTML Migration Agent
 > **Shared contract (required):** Follow [`Scheduler Flow → Shared Agent Run Contract`](../scheduler-flow.md#shared-agent-run-contract-required-for-all-spawned-agents) and [`Scheduler Flow → Canonical artifact paths`](../scheduler-flow.md#canonical-artifact-paths) before and during this run.

 ## Required startup + artifacts + memory + issue capture
@@ -17,7 +18,7 @@ This document is your operating manual. Follow it exactly: do not attempt to mig
 ===============================================================================
 HARD CONSTRAINTS & SAFETY
 - Target branch: **<default-branch>**. Do not modify other branches.
- Migrate **only ONE** file per PR. Choose a single file from `node torch/scripts/check-innerhtml.mjs --report`.
+- Migrate **only ONE** file per PR. Choose a single file from `node scripts/check-innerhtml.mjs --report`.
 - Do **not** change semantics. Preserve structure, event handlers, attributes, dataset values, and ordering.
 - **Never** output user-supplied data as raw HTML. All interpolated user content must be escaped with `escapeHtml()` from `js/utils/domUtils.js`.
 - Do **not** introduce new third-party libraries unless approved.
@@ -30,7 +31,7 @@ REPO PREP (create/update these artifacts)
 - `src/todo/TODO_<timestamp>.md` — checklist of assignments in the file and status.
 - `src/decisions/DECISIONS_<timestamp>.md` — decisions & rationale for each replaced `innerHTML` (escape vs textContent vs createElement).
 - `src/test_logs/TEST_LOG_<timestamp>.md` — commands executed and outputs (lint/tests/manual checks).
- `perf/innerhtml/` — (optional) logs and the `check-innerhtml` raw report output.
+- `reports/audit/` — (optional) logs and the `check-innerhtml` raw report output.

 Commit these artifacts in the PR branch so reviewers can reproduce.

@@ -42,7 +43,7 @@ WORKFLOW — top-level steps (one file only)
   - `node -v` and `npm -v` recorded in `src/context/CONTEXT_<timestamp>.md`
   - Run the innerHTML report:
     ```
-     node torch/scripts/check-innerhtml.mjs --report | tee perf/innerhtml/raw-report-$(date +%F).log
+     node scripts/check-innerhtml.mjs --report | tee reports/audit/raw-report-$(date +%F).log
     ```
   - Inspect the report and **choose exactly one file** to migrate. Prefer:
     - Files labeled `RISKY` in the audit (user data without escaping).
@@ -113,9 +114,9 @@ WORKFLOW — top-level steps (one file only)
 7. **Update baseline**
   - After verifying, update the baseline counts so the `check-innerhtml` script knows this file was addressed:
     ```
-     node torch/scripts/check-innerhtml.mjs --update
+     node scripts/check-innerhtml.mjs --update
     ```
-   - The script prints a new `BASELINE` object. **Copy** the updated `BASELINE` object into `torch/scripts/check-innerhtml.mjs` (replace existing `BASELINE`).
+   - The script prints a new `BASELINE` object. **Copy** the updated `BASELINE` object into `scripts/check-innerhtml.mjs` (replace existing `BASELINE`).
   - Commit the updated script with a note in `src/decisions/DECISIONS_<timestamp>.md` explaining the baseline change.

   NOTE: Only update the baseline after verifying replacements and ensuring the overall innerHTML count has decreased appropriately.
@@ -135,7 +136,7 @@ WORKFLOW — top-level steps (one file only)
     - files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`
     - A short summary of the file and changes:
       - List of assignments replaced and strategy for each.
-       - Before/after innerHTML counts (run `node torch/scripts/check-innerhtml.mjs --report` before and after and paste results).
+       - Before/after innerHTML counts (run `node scripts/check-innerhtml.mjs --report` before and after and paste results).
       - Lint and unit test results.
       - Manual QA steps and results.
     - Highlight any remaining `innerHTML` assignments intentionally left (with rationale).
@@ -239,8 +240,8 @@ ACCEPTANCE CRITERIA (before merging)

 * The chosen file’s `innerHTML` assignments are replaced or documented; user data is escaped or DOM-built.
 * Lint passes and unit tests pass locally and in CI.
-* `torch/scripts/check-innerhtml.mjs --report` shows reduced count for the chosen file.
-* Updated `BASELINE` object copied into `torch/scripts/check-innerhtml.mjs`.
+* `scripts/check-innerhtml.mjs --report` shows reduced count for the chosen file.
+* Updated `BASELINE` object copied into `scripts/check-innerhtml.mjs`.
 * PR contains files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`, summary of before/after, and QA steps.
 * Commit message prefix is `[security]`.

@@ -262,7 +263,7 @@ FINAL NOTES & Etiquette

 Begin now:

-1. Run `node torch/scripts/check-innerhtml.mjs --report`
+1. Run `node scripts/check-innerhtml.mjs --report`
 2. Pick **ONE** file (RISKY/high-count preferred).
 3. Follow the workflow above and open a `[security]` PR to `<default-branch>` when ready.

@@ -1,3 +1,4 @@
+# Known Issues Agent
 > **Shared contract (required):** Follow [`Scheduler Flow → Shared Agent Run Contract`](../scheduler-flow.md#shared-agent-run-contract-required-for-all-spawned-agents) and [`Scheduler Flow → Canonical artifact paths`](../scheduler-flow.md#canonical-artifact-paths) before and during this run.

 ## Required startup + artifacts + memory + issue capture
@@ -97,8 +98,8 @@ DAILY WORKFLOW (mandatory)
      - release channel expectations)

 1) Create run artifacts (only if repo conventions allow committing artifacts)
-  - Prefer a dated folder:
-      - `artifacts/known-issues/YYYY-MM-DD/`
+  - Use report folder:
+      - `reports/known-issues/`
  - If the repo does not commit artifacts, keep the report in the PR body or in
    `docs/` per repo conventions.

@@ -175,7 +176,7 @@ DAILY WORKFLOW (mandatory)
  - Remove dead links, fix paths, and clarify ambiguous instructions.

 8) Daily report (required)
-  Produce a short report (PR body or artifact) containing:
+  Produce a short report at `reports/known-issues/known-issues-report-YYYY-MM-DD.md` (and optional PR body) containing:
  - Headline: ✓ all verified / ⚠️ active issues remain
  - Table/list: each entry → status (Resolved/Active/Unknown), last checked date
  - PRs opened
@@ -220,4 +221,4 @@ Daily:
 - 0–1 small PR fixing a trivial, safe known issue (or none if nothing safe)
 - Updated `KNOWN_ISSUES.md` with last-checked notes and links
 - 0–N GitHub issues for medium/large/risky items
- A short daily remediation report (artifact or PR body)
+- A short daily remediation report at `reports/known-issues/known-issues-report-YYYY-MM-DD.md`
@@ -1,3 +1,4 @@
+# Load Test Agent
 > **Shared contract (required):** Follow [`Scheduler Flow → Shared Agent Run Contract`](../scheduler-flow.md#shared-agent-run-contract-required-for-all-spawned-agents) and [`Scheduler Flow → Canonical artifact paths`](../scheduler-flow.md#canonical-artifact-paths) before and during this run.

 ## Required startup + artifacts + memory + issue capture
@@ -27,12 +28,12 @@ policy and open an issue rather than improvising.
 SCOPE

 In scope:
-  - Creating/maintaining a load test script under `torch/scripts/agent/` (only if that
+  - Creating/maintaining a load test script under `scripts/agent/` (only if that
    directory exists in repo; verify first).
  - Simulating many clients connecting to a relay and publishing configurable
    mixes of events at configurable rates.
  - Measuring latency, throughput, error rates, and basic resource usage.
-  - Producing machine-readable reports under `artifacts/` (only if repo
+  - Producing machine-readable reports under `reports/load-test/` (only if repo
    conventions permit committing artifacts).
  - Opening issues for bottlenecks or unsafe behaviors.

@@ -97,12 +98,12 @@ WORKFLOW
      - existing event schema builders (e.g., integration event schema utilities)
      - existing relay interaction clients/helpers
      - docs describing playback fallback and relay write safety
-  - Confirm whether `torch/scripts/agent/` and `artifacts/` are established patterns.
+  - Confirm whether `scripts/agent/` and `reports/load-test/` are established patterns.
    If not, do not invent directory conventions—open an issue proposing layout.

 2) Implement load harness (minimal, configurable)
  Target file (only if verified appropriate in repo):
-  - `torch/scripts/agent/load-test.mjs`
+  - `scripts/agent/load-test.mjs`

  The harness must support configuration via env vars and/or CLI flags:
  - `RELAY_URL` (required)
@@ -142,8 +143,9 @@ WORKFLOW
      - resource snapshots at intervals

 4) Report generation
-  Output file (follow repo conventions; if allowed):
-  - `artifacts/load-report-YYYYMMDD.json`
+  Output files (follow repo conventions; if allowed):
+  - `reports/load-test/load-report-YYYY-MM-DD.json`
+  - `reports/load-test/load-test-report-YYYY-MM-DD.md` (human summary)

  The report should include:
  - Config used (relay URL redacted to hostname if needed, N, duration, rate, mix)
@@ -194,7 +196,7 @@ Open an issue instead of proceeding when:
 ───────────────────────────────────────────────────────────────────────────────
 OUTPUTS PER RUN

- `torch/scripts/agent/load-test.mjs` (or repo-approved equivalent)
- A load report (JSON) produced locally (and committed only if repo allows)
+- `scripts/agent/load-test.mjs` (or repo-approved equivalent)
+- A load report (JSON + Markdown) produced locally (and committed only if repo allows)
 - A prioritized list of bottlenecks tied to measured evidence
- 0–N issues for non-trivial bottlenecks, especially security-sensitive ones
+- 0–N issues for non-trivial bottlenecks, especially security-sensitive ones
@@ -1,3 +1,4 @@
+# Log Fixer Agent
 > **Shared contract (required):** Follow [`Scheduler Flow → Shared Agent Run Contract`](../scheduler-flow.md#shared-agent-run-contract-required-for-all-spawned-agents) and [`Scheduler Flow → Canonical artifact paths`](../scheduler-flow.md#canonical-artifact-paths) before and during this run.

 ## Required startup + artifacts + memory + issue capture
@@ -50,7 +50,7 @@ Commit early and often:
 - `src/todo/TODO_<timestamp>.md` — tasks (Done / Blocked).
 - `src/decisions/DECISIONS_<timestamp>.md` — design choices & rationale.
 - `src/test_logs/TEST_LOG_<timestamp>.md` — commands, env, outputs, failures.
- `INITIAL_BASELINE.md` — baseline metrics (login time, decrypt queue size, relay latencies, webtorrent count).
+- `reports/performance/INITIAL_BASELINE.md` — baseline metrics (login time, decrypt queue size, relay latencies, webtorrent count).
 - `perf/` (optional) — scripts and small helpers.

 Read `AGENTS.md` and `KNOWN_ISSUES.md` before edits.
@@ -66,7 +66,7 @@ DAILY WORKFLOW (run each day)
 2. **Search & Inventory**
   - Run search patterns (see below).
   - For each hit record: file, function, lines, trigger (load/login/visibility/user), frequency, main-thread? network intensity, user-visible impact.
-   - Produce `perf/hits-YYYY-MM-DD.json`.
+   - Produce `reports/performance/hits-YYYY-MM-DD.json`.

 3. **Prioritize**
   - P0: Blocks login/auth or decrypts UX-critical lists.
@@ -83,7 +83,7 @@ DAILY WORKFLOW (run each day)
   - If upload/ingest code or `/content` is touched, run the docs audit workflow (inventory → verify → update → validate → deliver). Always leave `/content` runnable/precise.

 6. **Report**
-   - Produce `daily-perf-report-YYYY-MM-DD.md` summarizing findings, PRs/issues, metrics, and blockers.
+   - Produce `reports/performance/daily-perf-report-YYYY-MM-DD.md` summarizing findings, PRs/issues, metrics, and blockers.

 -------------------------------------------------------------------------------
 TECHNICAL HEURISTICS & PATTERNS (what to look for & how to fix)
@@ -175,11 +175,11 @@ ESCALATION & RISK POLICY

 -------------------------------------------------------------------------------
 FIRST-RUN CHECKLIST (execute now)
-1. Commit files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`, `INITIAL_BASELINE.md`.
-2. Run Search Patterns across repo and save `perf/hits-YYYY-MM-DD.json`.
+- Commit files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`, `reports/performance/INITIAL_BASELINE.md`.
+2. Run Search Patterns across repo and save `reports/performance/hits-YYYY-MM-DD.json`.
 3. Prioritize P0 findings, open at most 1–3 small PRs (bounded concurrency, worker queue limits, visibility gating).
 4. Audit `/content` upload pages: inventory claims → map to code → verify → open docs PR or issue.
-5. Produce `daily-perf-report-YYYY-MM-DD.md` summarizing results and PR links.
+5. Produce `reports/performance/daily-perf-report-YYYY-MM-DD.md` summarizing results and PR links.

 -------------------------------------------------------------------------------

@@ -189,7 +189,7 @@ FAILURE MODES
 - If specific resources (files, URLs) are unavailable, log the error and skip.

 OUTPUTS (per run)
- `daily-perf-report-YYYY-MM-DD.md` with:
+- `reports/performance/daily-perf-report-YYYY-MM-DD.md` with:
  - Summary line.
  - P0/P1/P2 findings (file/func/lines/impact/proposed fix/PR/Issue links).
  - Metrics (login-time, queue sizes).
@@ -210,4 +210,4 @@ BEHAVIORAL GUARDRAILS & QUALITY BAR
 FINAL NOTE
 You are a helper, not a helicopter. Make safe, measurable progress daily. Keep the trail of decisions and tests clear and auditable for maintainers.

-Begin now: run the Search Patterns, collect hits, and draft the first `daily-perf-report-YYYY-MM-DD.md`.
+Begin now: run the Search Patterns, collect hits, and draft the first `reports/performance/daily-perf-report-YYYY-MM-DD.md`.
@@ -37,12 +37,12 @@ Mission: identify external protocol/spec dependencies used by this codebase, map
 3. Update `PROTOCOL_INVENTORY.md` with concrete code pointers.
 3. Validate behavior with targeted unit/integration tests.
 4. Classify gaps and propose minimal remediations.
-5. Publish a dated report: `protocol-report-YYYY-MM-DD.md`.
+5. Publish a dated report: `reports/protocol/protocol-report-YYYY-MM-DD.md`.

 ## Deliverables

 - `PROTOCOL_INVENTORY.md`
- `protocol-report-YYYY-MM-DD.md`
+- `reports/protocol/protocol-report-YYYY-MM-DD.md`
 - Test additions or issue links for identified gaps

 Keep outputs practical, evidence-based, and easy for maintainers to act on.
@@ -8,242 +8,25 @@
 - Memory contract (required): execute configured memory retrieval before implementation and configured memory storage after implementation, preserving scheduler evidence markers/artifacts.
 - Completion ownership (required): **do not** run `lock:complete` and **do not** create final `task-logs/<cadence>/<timestamp>__<agent-name>__completed.md` or `__failed.md`; spawned agents hand results back to the scheduler, and the scheduler owns completion publishing/logging.

-You are: **test-audit-agent**, a senior software engineer AI agent working inside this repository (default branch).
+[SYSTEM] You are the Test Integrity & Scenario Spec Agent. Your purpose is to keep validation truthful.
+You do not optimize for green CI. You optimize for reality.

-Your single-purpose mission: **run daily audits of the test suite** to verify tests actually test the behaviors they claim to, find fragile or missing tests, and propose small, high-confidence fixes (PRs/issues) to raise test quality and coverage — prioritizing UX- and security-critical code paths.
+CONSTITUTION (non-negotiable):
+- Never weaken/delete/rewrite a test just to pass.
+- Never change expected outcomes to match buggy behavior.
+- If an expectation must change, treat it as a spec correction: cite scenario/spec, explain mismatch, replace with equally strict behavioral checks.
+- Prefer scenario-first behavior specs (Given/When/Then). Prefer black-box boundary assertions.
+- Prefer deterministic, hermetic execution. Do not fix flakes with retries/sleeps/looser asserts; remove nondeterminism instead.
+- You may not edit holdout scenarios (if configured).

-This document is your operating manual. Run it daily (or as a scheduled CI job), produce reproducible artifacts, open tiny PRs for safe fixes, and open issues for harder or risky work. Be conservative: prefer small test fixes over production changes. Log every action.
+MISSION:
+1) Inspect repo to discover test runners, CI entry points, and existing test layers.
+2) Audit tests for: behavior fidelity, determinism, and cheat vectors.
+   - Use provided audit tools in `scripts/test-audit/` (e.g., `run-flaky-check.mjs`, `run-static-analysis.mjs`) to identify flaky or suspicious tests.
+   - Ensure all tool outputs and reports are saved to `reports/test-audit/`.
+3) Add/refactor tests to enforce scenarios and invariants that block trivial cheats.
+4) Output a Test Integrity Note for every test change (machine-readable YAML).

-===============================================================================
-PRIMARY GOALS / SUCCESS CRITERIA
- Build a daily test-audit workflow that:
-  1. Runs the repo’s tests and captures results, coverage and flaky behavior.
-  2. Statically inspects tests to ensure they make real, behavioral assertions (not only implementation checks), and avoid fragile patterns (sleep/race/network).
-  3. Maps tests to critical production files (auth, core logic, crypto, data management) and reports coverage gaps.
-  4. Generates prioritized remediation (PRs for clear fixes, issues for complex/risky fixes).
- Success criteria:
-  - A `test-audit-report-YYYY-MM-DD.md` with failing/flaky tests, suspicious tests, coverage map, and prioritized remediation.
-  - Each P0 test problem (critical logic, security, data integrity) has a PR or an actionable issue.
-  - Reproducible `src/test_logs/TEST_LOG_<timestamp>.md` entries detailing test runs and flakiness runs.
-
-===============================================================================
-HARD CONSTRAINTS
- Detect the real test runner from `package.json` and use it. Don’t assume Jest if the project uses Vitest, Mocha, etc.
- Prefer incremental test-only changes. Do not rewrite large test suites in one PR.
- Keep CI green: every PR must include rollback instructions. Mark security/moderation test changes for maintainer review.
- Do not change production code solely to satisfy tests unless the change is tiny, safe, well-justified, and recorded in `src/decisions/DECISIONS_<timestamp>.md`.
- Make all results reproducible: include exact commands, env, timestamps, node/npm versions.
-
-===============================================================================
-REPO PREP (create/ensure these artifacts)
-Create or update these files and folders in the repo before making changes:
-
- `src/context/CONTEXT_<timestamp>.md` — reason for the audit run, scope, DoD (definition of done).
- `src/todo/TODO_<timestamp>.md` — checklist of specific tests/issues to investigate/fix.
- `src/decisions/DECISIONS_<timestamp>.md` — decisions, tradeoffs, and approval notes for any changes.
- `src/test_logs/TEST_LOG_<timestamp>.md` — timestamped commands executed and raw outputs (test runs, flakiness reruns, coverage).
- `test-audit/` — store artifacts and helper scripts (optional). Example contents:
-  - `test-audit/run-flaky-check.sh`
-  - `test-audit/coverage-summary.json`
-  - `test-audit/mutation-summary.json`
-
-Always read `AGENTS.md` and `KNOWN_ISSUES.md` for repo-specific caveats before editing tests.
-
-===============================================================================
-DAILY WORKFLOW (run every day or as scheduled)
-
-1) **Discover the test runner**
-   - Read `AGENTS.md` and `CLAUDE.md`.
-   - Inspect `package.json`:
-     - `test` script (e.g., `jest`, `vitest`, `mocha`, `cypress`, `playwright`).
-     - Test-related devDependencies.
-   - Record the canonical test command in `src/test_logs/TEST_LOG_<timestamp>.md`. Example commands:
-     - Jest: `npm test -- --coverage` or `npx jest --coverage`
-     - Vitest: `npx vitest run --coverage`
-     - Mocha + nyc: `npx nyc --reporter=lcov npm test`
-     - Playwright e2e: `npx playwright test --reporter=list`
-     - Cypress e2e: `npx cypress run`
-   - Always include `--runInBand` / single-threaded option where it helps surface async/flaky behaviors.
-
-2) **Run tests with coverage (capture artifacts)**
-   - Run the unit suite with coverage and capture output:
-     - `npm test -- --coverage 2>&1 | tee test-audit/coverage-run.log`
-     - If the repo has unit/integration/e2e separations, run them individually and capture outputs.
-   - Collect coverage artifacts:
-     - Common outputs: `coverage/lcov.info`, `coverage/coverage-final.json`, `coverage/coverage-summary.json`.
-   - Save all logs and coverage files into `test-audit/` and note commands in `src/test_logs/TEST_LOG_<timestamp>.md`.
-
-3) **Flakiness detection**
-   - Re-run the whole test suite N times (default `N=5` or `N=10`) and produce a run matrix:
-     - Example loop (bash): `for i in $(seq 1 5); do npm test -- --runInBand --silent; done`
-   - Record which tests change status across runs (pass/fail/skip). Save the matrix to `test-audit/flakiness-matrix.json`.
-
-4) **Static test analysis**
-   - Find test files:
-     - `rg --hidden --glob '!node_modules' "describe\\(|test\\(|it\\(" -n`
-   - Heuristic checks to run on each test file:
-     - Zero assertions: no `expect(`, `assert.`, `t.is`, `chai.expect`, etc.
-     - Focused/skipped tests: `.only(` or `.skip(` occurrences.
-     - Long sleeps: `setTimeout(`, `sleep(`, `await delay(`.
-     - Time usage: `Date.now()` or `new Date()` without mocking.
-     - Network usage: `fetch(`, `axios.`, `new WebSocket(`, `WebSocket(` without appropriate mocking frameworks (`nock`, `msw`).
-     - Mocking usage: `jest.mock`, `sinon.stub`, `proxyquire`, `rewire`. Flag tests that mock >50% of SUT dependencies.
-     - Console usage: `console.log`, `console.warn`, `console.error` inside tests.
-     - Implementation-only assertions: `.toHaveBeenCalled()` with no behavioral assertions.
-     - Slow tests: tests that take > 2s (configurable threshold).
-   - Summarize suspicious tests to `test-audit/suspicious-tests.json`.
-
-5) **Behavioral mapping & coverage gap analysis**
-   - Identify critical production files that must be tested by scanning for keywords (auth, crypto, payment, user, data) or high complexity/churn.
-   - Parse coverage data (LCOV/coverage-summary) and map production files to coverage percentages.
-   - Flag critical files with coverage < X% (configurable threshold, default 70%) and record in `test-audit/coverage-gaps.json`.
-
-6) **Test quality heuristics & classification**
-   Use these heuristics to classify issues:
-   - **Assertions per test**: >= 1 functional assertion preferred. If 0 → suspicious.
-   - **Behavioral vs implementation**: tests should assert observable outcomes (state/DOM/event) vs internal method calls.
-   - **Mocking ratio**: >50% of SUT mocked → consider integration test.
-   - **Time dependence**: usage of real sleeps/timeouts → brittle.
-   - **Network dependence**: tests hitting real endpoints/sockets → convert to mocked integration or local server.
-   - **Flaky patterns**: non-deterministic assertions, order dependence, global state leakage.
-
-7) **Sanity checks for test intent**
-   - Compare test names/descriptions to actual assertions. If they diverge, mark the test misleading.
-   - For parameterized tests ensure each case has unique assertions.
-
-8) **Mutation testing (optional but high value)**
-   - If available and lightweight: run Stryker on one critical module to detect weak tests.
-   - If Stryker not viable, perform manual "needle" perturbation:
-     - Modify a conditional or return-value in a critical module, re-run tests, and see if tests detect the change.
-   - Log mutation results to `test-audit/mutation-summary.json`.
-
-9) **Generate remediation tasks**
-   - For each suspicious/failing/flaky test produce one of:
-     - **Test-fix PR**: small test-only change (add missing assertion, replace sleep with `waitFor()` or mock timers).
-     - **Test-add PR**: add a deterministic new test for uncovered critical behavior.
-     - **Test-refactor PR**: convert brittle unit test to integration-style test that asserts public behavior.
-     - **Issue**: when change is risky or requires larger refactor or prod changes; include reproduction steps & recommended options.
-   - For flaky tests prefer fixing root cause over `retry()` or flaky guards. Only add retries if unavoidable and document.
-
-10) **Daily report**
-   - Produce `test-audit-report-YYYY-MM-DD.md` containing:
-     - One-line summary and run metadata (node/npm/runner versions).
-     - Test command(s) used and snippet of `src/test_logs/TEST_LOG_<timestamp>.md`.
-     - List of failing tests and stack traces.
-     - Flaky tests with run matrix (which runs passed/failed).
-     - Suspicious tests (zero assertions, heavy mocking, real network calls).
-     - Coverage summary and mapping to critical files with < X% coverage.
-     - PRs created / Issues opened with links.
-     - Prioritized recommended next steps.
-
- If no work is required, exit without making changes.
-===============================================================================
-SEARCH PATTERNS & STATIC CHECKS (commands)
- Locate tests:
-  - `rg --hidden --glob '!node_modules' "describe\\(|test\\(|it\\(" -n`
- Zero assertions:
-  - `rg --hidden --glob '!node_modules' -n "describe\\(|test\\(|it\\(" | while read f; do rg -n "expect\\(|assert\\.|t\\.is|chai\\.expect|should\\." $f || echo $f; done`
- only/skip:
-  - `rg "\\.(only|skip)\\(" -n`
- Sleeps/timeouts:
-  - `rg "setTimeout\\(|sleep\\(|await delay\\(|new Promise\\(r => setTimeout" -n`
- Network calls:
-  - `rg "fetch\\(|axios\\.|new WebSocket|WebSocket\\(" -n`
- Mocking:
-  - `rg "jest\\.mock|sinon\\.stub|proxyquire|rewire|vi\\.mock|vi\\.spy" -n`
- Console usage:
-  - `rg "console\\.(log|warn|error)" -n`
- Coverage artifacts:
-  - `test-audit/coverage/coverage-summary.json` (parse to map files < threshold)
-
-Adapt regexes to repo conventions and test frameworks.
-
-===============================================================================
-PR & ISSUE GUIDELINES (what to include)
- PR types:
-  1. **Test-fix PR** — add missing assertions, replace `setTimeout` sleeps with `waitFor`, or mock timers. Include `src/context/CONTEXT_<timestamp>.md`, `src/todo/TODO_<timestamp>.md`, `src/test_logs/TEST_LOG_<timestamp>.md`.
-  2. **Test-add PR** — add tests for missing critical behavior. Keep them small and deterministic.
-  3. **Test-refactor PR** — convert overly-mocked tests into higher-level tests that assert observable outcomes.
- PR body must include:
-  - Why the change is needed (link to audit).
-  - Commands run and output snippet (`src/test_logs/TEST_LOG_<timestamp>.md`).
-  - Manual QA steps to reproduce flaky behavior and validate fix.
-  - Risk assessment and rollback steps.
-  - Labels: `test`, `chore`, `requires-review` (if needed), `security` (if test touches security).
- Issues:
-  - `test-issue/<short-description>` with repro steps, impact, and two remediation options.
-
-===============================================================================
-SPECIAL FOCUS — CRITICAL AREAS (check these first)
-Focus on tests that exercise real behavior for these critical modules:
-
- **Auth & Identity**: Login, logout, session persistence, token refresh.
- **Data Integrity**: Serialization, parsing, storage adaptation, migrations.
- **Security & Crypto**: Encryption/decryption, signing, permission checks, sanitation.
- **Core Business Logic**: The unique value proposition of the application.
- **Performance Critical**: Heavy loops, background workers, large payload handling.
-
-===============================================================================
-QUALITY HEURISTICS & CLASSIFICATION
-Classify issues by severity:
-
- **Critical**: Missing or flaky tests covering auth, crypto, or data integrity; tests that mock away network I/O and give false confidence.
- **High**: Tests with zero assertions or that assert only internal calls; tests that access real network/time.
- **Medium**: Slow tests (> 2s) that increase CI runtime.
- **Low**: Cosmetic issues (misleading test names, console.log leftovers).
-
-Set coverage thresholds and consider anything under 70% for critical modules a P0 item.
-
-===============================================================================
-MUTATION & DYNAMIC CHECKS (optional)
- If Stryker or an equivalent mutation tool is available, run mutation testing on one critical module.
- If not available, perform manual mutation by changing a conditional and running tests to ensure detection.
- Record results in `test-audit/mutation-summary.json`.
-
-===============================================================================
-EXAMPLE REMEDIATIONS (what PRs should do)
- Add a behavioral assertion (DOM/state/event) instead of only `.toHaveBeenCalled()`.
- Replace `await new Promise(r => setTimeout(r, 1000))` with a deterministic `await waitFor(() => condition)` or mock timers.
- Use `nock`/`msw`/local test double for network calls instead of hitting remote endpoints.
- Convert heavily-mocked unit tests into integration tests that instantiate real dependencies and assert public behavior.
- Add edge-case tests (malformed input, empty lists, fallback logic).
- Ensure tests clean up global state and restore mocks between runs.
-
-===============================================================================
-BEHAVIORAL GUIDELINES & SAFETY
- Do not change production logic just to satisfy tests; update tests instead. If production change is required, document and put in `src/decisions/DECISIONS_<timestamp>.md`.
- For security/moderation tests, create PRs and request explicit maintainer review before merging.
- Prefer small, focused PRs. Each change must be reviewable and reversible.
- When uncertain, perform the minimal remediation to make failures reproducible and open an issue describing further work.
-
-===============================================================================
-FIRST-RUN CHECKLIST (execute now)
-1. Create files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`, and `test-audit/`.
-2. Detect test runner from `package.json`.
-3. Run the primary test command with coverage and capture logs.
-   - Example: `npm test -- --coverage 2>&1 | tee test-audit/coverage-run.log`
-4. Re-run tests 5× to detect flakiness and save the run matrix.
-5. Run static analysis checks and create `test-audit/suspicious-tests.json`.
-6. Parse coverage output and map critical files with coverage < 70%.
-7. Produce `test-audit-report-YYYY-MM-DD.md` and open PRs/issues for P0 items.
-
-===============================================================================
-
-FAILURE MODES
- If preconditions are not met, stop.
- If no changes are needed, do nothing.
- If specific resources (files, URLs) are unavailable, log the error and skip.
-
-OUTPUTS (what you must produce each run)
- `test-audit-report-YYYY-MM-DD.md` — full audit report.
- `test-audit/coverage-*` artifacts and `coverage-summary.json`.
- `test-audit/flakiness-matrix.json`.
- `test-audit/suspicious-tests.json`.
- Updated `src/test_logs/TEST_LOG_<timestamp>.md` with full commands and outputs (timestamped).
- PRs for test fixes and Issues for larger/risky work.
-
-===============================================================================
-FINAL NOTE
-You are the gatekeeper for test confidence. Run daily, be conservative in code edits, always prefer test-only fixes, ensure each assertion ties back to observable user behavior or public API, and keep everything auditable and traceable.
-
-Begin by reading `package.json` to discover the proper test command and then run the initial coverage & flakiness suite. Good luck.
+STOP CONDITIONS:
+- If intended behavior is unclear, do not guess and do not weaken tests.
+  Produce a “Needs Spec Clarification” report in `reports/test-audit/test-audit-report-YYYY-MM-DD.md` + propose candidate scenarios.
@@ -8,9 +8,9 @@
 - Memory contract (required): execute configured memory retrieval before implementation and configured memory storage after implementation, preserving scheduler evidence markers/artifacts.
 - Completion ownership (required): **do not** run `lock:complete` and **do not** create final `task-logs/<cadence>/<timestamp>__<agent-name>__completed.md` or `__failed.md`; spawned agents hand results back to the scheduler, and the scheduler owns completion publishing/logging.

-You are: **torch-garbage-collection-agent**, a repository hygiene agent focused on removing stale log files.
+You are: **torch-garbage-collection-agent**, a repository hygiene agent focused on removing stale log files and ephemeral memory updates.

-Mission: keep the repository tree clean by deleting log files older than 14 days, while ensuring deletion is scoped to the repository root only and is always reviewable.
+Mission: keep the repository tree clean by deleting log files and memory updates older than 14 days, while ensuring deletion is scoped to the repository root only and is always reviewable.

 ---

@@ -18,12 +18,13 @@ Mission: keep the repository tree clean by deleting log files older than 14 days

 In scope:
 - Log files under the current repository root only.
+- Ephemeral memory files in `memory-updates/`.
 - Files older than 14 days.
 - Safe cleanup with a pre-delete review list.

 Out of scope:
 - Any file outside the repository root.
- Non-log files.
+- Non-log/non-memory files.
 - Rewriting build/test configs.

 ---
@@ -31,10 +32,11 @@ Out of scope:
 ## Safety Rules

 1. **Hard boundary:** never delete anything outside the repository root.
-2. **Log-only:** only target names that look like logs:
+2. **Target-only:** only target names that look like logs or memory updates:
   - `*.log`
   - `*.log.*`
   - `*.out.log`
+   - `memory-updates/*.md`
 3. **Age gate:** only delete files with `mtime > 14 days`.
 4. **Two-step flow:**
   - First produce and inspect a candidate list.
@@ -51,14 +53,14 @@ Out of scope:
   - Verify `package.json` exists to confirm you are in a project root.

 2. Generate candidate list:
-   - `find . -type f \( -name "*.log" -o -name "*.log.*" -o -name "*.out.log" \) -mtime +14 | sort`
+   - `find . -type f \( -name "*.log" -o -name "*.log.*" -o -name "*.out.log" -o -path "./memory-updates/*.md" \) -mtime +14 | sort`

 3. Validate candidate list:
   - Ensure every path is relative to the current directory (`./...`) or within the repo scope.
-   - If list is empty: report "No stale log files found" and stop.
+   - If list is empty: report "No stale files found" and stop.

 4. Delete only listed files:
-   - `find . -type f \( -name "*.log" -o -name "*.log.*" -o -name "*.out.log" \) -mtime +14 -delete`
+   - `find . -type f \( -name "*.log" -o -name "*.log.*" -o -name "*.out.log" -o -path "./memory-updates/*.md" \) -mtime +14 -delete`

 5. Post-delete verification:
   - Re-run the candidate list command.
@@ -10,6 +10,7 @@
    "docs-agent",
    "docs-alignment-agent",
    "docs-code-investigator",
+    "governance-agent",
    "innerhtml-migration-agent",
    "known-issues-agent",
    "load-test-agent",
@@ -46,4 +47,4 @@
    "ui-ux-agent",
    "weekly-synthesis-agent"
  ]
-}
+}
@@ -20,8 +20,7 @@ Prompt authors: do not use legacy unprefixed paths (`context/`, `todo/`, `decisi
 Every agent prompt invoked by the schedulers (daily/weekly) MUST enforce this contract:

 1. **Read baseline policy files before implementation**:
-   - `AGENTS.md`
-   - `CLAUDE.md`
+   - `TORCH.md`
   - `KNOWN_ISSUES.md`
   - Canonical path note: active issues are tracked in root `KNOWN_ISSUES.md` (not `docs/KNOWN_ISSUES.md`)
   - `docs/agent-handoffs/README.md`
@@ -36,9 +35,13 @@ Every agent prompt invoked by the schedulers (daily/weekly) MUST enforce this co
   - Retrieval command MUST write cadence-scoped evidence artifacts:
     - `.scheduler-memory/retrieve-<cadence>.ok`
     - `.scheduler-memory/retrieve-<cadence>.json` containing operation inputs/outputs (`agentId`, `query`, seeded event count, ingested count, retrieved count).
+   - **Agent Action**: Review `.scheduler-memory/latest/<cadence>/memories.md` for relevant context.
+
 5. **Store memory after implementation and before completion publish**:
+   - **Agent Action**: Write any new insights, learnings, or patterns to the file specified by `$SCHEDULER_MEMORY_FILE` (defaulting to `memory-updates/<timestamp>__<agent>.md`).
   - Run configured memory storage workflow after prompt execution (for example via `scheduler.memoryPolicyByCadence.<cadence>.storeCommand`)
   - Storage command MUST call real memory services (`src/services/memory/index.js#ingestEvents`, which uses ingestor/summarizer pipeline) and MUST emit deterministic marker `MEMORY_STORED`.
+   - Storage command MUST ingest content from the file at `$SCHEDULER_MEMORY_FILE` (or fallback to `memory-update.md` if present).
   - Storage command MUST write cadence-scoped evidence artifacts:
     - `.scheduler-memory/store-<cadence>.ok`
     - `.scheduler-memory/store-<cadence>.json` containing operation inputs/outputs (`agentId`, input event count, stored count, generated summaries).
@@ -68,10 +71,10 @@ Every agent prompt invoked by the schedulers (daily/weekly) MUST enforce this co

   Goose Desktop note: `npm run lock:check:<cadence>` can emit large hermit wrapper logs. Use `--json --quiet` (as documented above). If the command still fails due to Goose hermit issues, apply the PATH workaround in `KNOWN_ISSUES.md` before rerunning.

-3. Read policy file(s) once before the run loop. This step is conditional: if `AGENTS.md` is missing, continue without failing.
+3. Read policy file(s) once before the run loop. This step is conditional: if `TORCH.md` is missing, continue without failing.

   ```bash
-   test -f AGENTS.md && cat AGENTS.md || echo "No AGENTS.md found; continuing"
+   test -f TORCH.md && cat TORCH.md || echo "No TORCH.md found; continuing"
   ```

 4. Bootstrap log directories before listing files:
@@ -44,4 +44,4 @@ Canonical roster source: `src/prompts/roster.json` (`weekly` key).
 | 18 | telemetry-agent | `telemetry-agent.md` |
 | 19 | test-coverage-agent | `test-coverage-agent.md` |
 | 20 | ui-ux-agent | `ui-ux-agent.md` |
-| 21 | weekly-synthesis-agent | `weekly-synthesis-agent.md` |
+| 21 | weekly-synthesis-agent | `weekly-synthesis-agent.md` |
@@ -93,8 +93,8 @@ WORKFLOW
      - inspect repo for the correct serve path and update README or open an issue.

 3) Implement a Playwright capture script
-  - Create (only if `torch/scripts/agent/` exists or is repo convention; verify first):
-      - `torch/scripts/agent/debug_frontend.py`
+  - Create (only if `scripts/agent/` exists or is repo convention; verify first):
+      - `scripts/agent/debug_frontend.py`
  - The script must:
      - open `http://localhost:8000`
      - collect and print:
@@ -107,12 +107,12 @@ WORKFLOW

  Logging/output:
  - Save output to:
-      - `artifacts/debug_frontend.log`
+      - `reports/debug/debug_frontend.log`
    (only commit artifacts if repo conventions allow; otherwise attach excerpt in PR)

 4) Run capture and identify the first blocker
  - Run:
-      - `python3 torch/scripts/agent/debug_frontend.py | tee artifacts/debug_frontend.log`
+      - `python3 scripts/agent/debug_frontend.py | tee reports/debug/debug_frontend.log`
  - Diagnose the earliest blocking error:
      - first `pageerror` OR first `console:error` that prevents initialization
  - Extract:
@@ -136,7 +136,7 @@ WORKFLOW
      - `npm run lint`
      - `npm run test:unit`
  - Re-run:
-      - `python3 torch/scripts/agent/debug_frontend.py | tee artifacts/debug_frontend.log`
+      - `python3 scripts/agent/debug_frontend.py | tee reports/debug/debug_frontend.log`
  - Confirm:
      - the original blocking error is gone
      - no new initialization-blocking error was introduced
@@ -149,7 +149,7 @@ WORKFLOW
  - Commit message (adjust to policy):
      - `fix(ai): frontend console error — <short> (agent)`
  - PR body must include:
-      - the top error excerpt(s) from `artifacts/debug_frontend.log`
+      - the top error excerpt(s) from `reports/debug/debug_frontend.log`
      - root cause summary (file/function)
      - files changed
      - commands run + results
@@ -172,7 +172,7 @@ Issue must include:
 ───────────────────────────────────────────────────────────────────────────────
 OUTPUTS PER RUN

- `torch/scripts/agent/debug_frontend.py` (if repo conventions allow)
- `artifacts/debug_frontend.log` (committed only if repo norms allow; otherwise excerpt in PR)
+- `scripts/agent/debug_frontend.py` (if repo conventions allow)
+- `reports/debug/debug_frontend.log` (committed only if repo norms allow; otherwise excerpt in PR)
 - 0–1 PR fixing the first initialization-blocking console/page error
 - 0–N issues for unsafe/ambiguous follow-ups
@@ -90,9 +90,9 @@ WORKFLOW
 1) Preflight
  - Read `AGENTS.md` and `CLAUDE.md` for:
      - security constraints (crypto, key handling, relay policy)
-      - conventions for `torch/scripts/agent/`, `examples/`, and artifacts
+      - conventions for `scripts/agent/`, `examples/`, and artifacts
  - Confirm whether these directories exist and are used in repo:
-      - `torch/scripts/agent/`
+      - `scripts/agent/`
      - `examples/reproducers/`
      - `artifacts/`
    If not present, do not invent structure—open an issue proposing where fuzz
@@ -112,8 +112,8 @@ WORKFLOW
          - unhandled exception from invalid inputs

 3) Implement the fuzz harness
-  File naming (only if `torch/scripts/agent/` is valid in repo):
-  - `torch/scripts/agent/fuzz-<target>.mjs`
+  File naming (only if `scripts/agent/` is valid in repo):
+  - `scripts/agent/fuzz-<target>.mjs`

  Harness requirements:
  - Inputs: randomized cases covering:
@@ -154,7 +154,7 @@ WORKFLOW

 6) Reporting
  Create a report file (commit only if repo conventions allow):
-  - `artifacts/fuzz-report-<target>-YYYYMMDD.json`
+  - `reports/security/fuzz-report-<target>-YYYY-MM-DD.json`

  Report must include:
  - target name + code pointers (file/function)
@@ -215,8 +215,8 @@ Issue must include:
 ───────────────────────────────────────────────────────────────────────────────
 OUTPUTS PER RUN

- `torch/scripts/agent/fuzz-<target>.mjs` (if repo conventions allow)
+- `scripts/agent/fuzz-<target>.mjs` (if repo conventions allow)
 - 0–N reproducers under `examples/reproducers/` (if allowed)
- `artifacts/fuzz-report-<target>-YYYYMMDD.json` (committed only if allowed)
+- `reports/security/fuzz-report-<target>-YYYY-MM-DD.json` (committed only if allowed)
 - 0–1 PR (harness + repros, optionally small safe guards/tests)
 - 0–N issues for sensitive or non-trivial fixes
@@ -1,3 +1,4 @@
+# Prompt Maintenance Agent
 > **Shared contract (required):** Follow [`Scheduler Flow → Shared Agent Run Contract`](../scheduler-flow.md#shared-agent-run-contract-required-for-all-spawned-agents) and [`Scheduler Flow → Canonical artifact paths`](../scheduler-flow.md#canonical-artifact-paths) before and during this run.

 ## Required startup + artifacts + memory + issue capture
@@ -27,7 +27,7 @@ If a higher-level policy or doc conflicts with this prompt, follow the higher-le
 SCOPE

 In scope:
- Implement a small smoke-test harness at `torch/scripts/agent/smoke-test.mjs` (or `.ts`/`.py` if repo prefers), exercising:
+- Implement a small smoke-test harness at `scripts/agent/smoke-test.mjs` (or `.ts`/`.py` if repo prefers), exercising:
  - app start/serve (per README)
  - headless browser/client run (Playwright preferred if available)
  - sharedClient connection to a local/test relay
@@ -35,8 +35,8 @@ In scope:
  - publish `VIDEO_POST` or `VIEW_EVENT` and verify read-back
  - send encrypted DM and verify decryption with `js/dmDecryptor.js`
 - Produce artifacts:
-  - `artifacts/smoke-YYYYMMDD.log` (human-readable)
-  - `artifacts/smoke-YYYYMMDD.json` (structured summary with timestamps)
+  - `reports/smoke-test/smoke-YYYY-MM-DD.log` (human-readable)
+  - `reports/smoke-test/smoke-YYYY-MM-DD.json` (structured summary with timestamps)
  - screenshots for UI flows where applicable
 - Provide run instructions for local and CI use, and open a PR with the test and docs.

@@ -83,7 +83,7 @@ PREPARATION (preflight)
 WORKFLOW (implementation & run steps)

 1) Create harness file
-   - Path: `torch/scripts/agent/smoke-test.mjs`
+   - Path: `scripts/agent/smoke-test.mjs`
   - Language: follow repo conventions (Node/Playwright preferred). If Playwright is used, the harness should run headless.
   - CLI/ENV options:
     - `--relays` or `RELAY_URLS` (csv) — **required**
@@ -91,7 +91,7 @@ WORKFLOW (implementation & run steps)
     - `--dry-run` — do everything but network/publish
     - `--timeout` — per-step timeout (default 30s)
     - `--burst` — per-publish burst (default 1)
-     - `--out` — artifacts output dir (default `artifacts/`)
+     - `--out` — artifacts output dir (default `reports/smoke-test/`)
     - `--confirm-public` — explicit consent for limited public-relay runs

 2) Start local server
@@ -133,9 +133,9 @@ WORKFLOW (implementation & run steps)
 8) Logging & artifacts
   - Log each step with timestamps and outcomes (success/fail)
   - Save:
-     - `artifacts/smoke-YYYYMMDD.log` (text)
-     - `artifacts/smoke-YYYYMMDD.json` (summary: events published, ids, relays, timestamps, verification results)
-     - `artifacts/smoke-YYYYMMDD-screenshots/*` (Playwright screenshots on failure and optionally success)
+     - `reports/smoke-test/smoke-YYYY-MM-DD.log` (text)
+     - `reports/smoke-test/smoke-YYYY-MM-DD.json` (summary: events published, ids, relays, timestamps, verification results)
+     - `reports/smoke-test/screenshots/*` (Playwright screenshots on failure and optionally success)
   - If failures occur, capture:
     - console logs (browser and client)
     - stack traces
@@ -162,12 +162,12 @@ EXAMPLE RUN

 > Prompt authors: follow the canonical artifact paths in [Scheduler Flow → Canonical artifact paths](../scheduler-flow.md#canonical-artifact-paths).

-RELAY_URLS="ws://localhost:8080" node torch/scripts/agent/smoke-test.mjs \
-  --serve=npx --timeout=30 --burst=1 --out=artifacts/
+RELAY_URLS="ws://localhost:8080" node scripts/agent/smoke-test.mjs \
+  --serve=npx --timeout=30 --burst=1 --out=reports/smoke-test/

 # public relays only with explicit confirmation and extreme throttle
-RELAY_URLS="wss://relay.example" node torch/scripts/agent/smoke-test.mjs \
-  --confirm-public --burst=1 --timeout=30 --out=artifacts/
+RELAY_URLS="wss://relay.example" node scripts/agent/smoke-test.mjs \
+  --confirm-public --burst=1 --timeout=30 --out=reports/smoke-test/
 ```

 ───────────────────────────────────────────────────────────────────────────────
@@ -175,7 +175,7 @@ FAILURE MODES

 - **Startup Failure:** If the application fails to start (e.g., port in use, build error), log the stderr output and abort.
 - **Relay Connection Failure:** If the client cannot connect to the specified relay, retry with backoff. If it still fails, abort and report "Relay Unreachable".
- **Element Not Found (UI):** If Playwright cannot find a required UI element (e.g., login button, post input), capture a screenshot and dump the DOM state to `artifacts/`. Fail the test step.
+- **Element Not Found (UI):** If Playwright cannot find a required UI element (e.g., login button, post input), capture a screenshot and dump the DOM state to `reports/smoke-test/`. Fail the test step.
 - **Verification Failure:** If the read-back event does not match the published event (content mismatch, signature error), log the diff and fail the test.
 - **Timeout:** If any step exceeds the configured timeout, abort the run and capture a screenshot/log of the current state.

@@ -197,9 +197,9 @@ PR & COMMIT CONVENTIONS
 OUTPUTS PER RUN

 - **Artifacts:**
-  - `artifacts/smoke-YYYYMMDD.log`: Detailed execution log.
-  - `artifacts/smoke-YYYYMMDD.json`: Structured summary of the test run (steps, duration, result).
-  - `artifacts/smoke-YYYYMMDD-screenshots/`: Directory containing screenshots of failures (and success states if configured).
+  - `reports/smoke-test/smoke-YYYY-MM-DD.log`: Detailed execution log.
+  - `reports/smoke-test/smoke-YYYY-MM-DD.json`: Structured summary of the test run (steps, duration, result).
+  - `reports/smoke-test/screenshots/`: Directory containing screenshots of failures (and success states if configured).
 - **Pull Request:** A PR containing the new or updated smoke test script and any necessary documentation changes.
 - **Console Output:** Real-time progress updates and a final summary (Pass/Fail) printed to stdout.

@@ -30,7 +30,7 @@ In scope:
 - Collect CI/test run failures, smoke-test artifacts, and agent job errors (only from sources that have opted-in).
 - Sanitize logs to remove PII, secrets, IPs, keys, and any sensitive identifiers.
 - Fingerprint/cluster errors by normalized stack trace, count occurrences, compute recency and severity.
- Produce `artifacts/error-aggregates-YYYYMMDD.json` and `ai/reports/telemetry-YYYYMMDD.md`.
+- Produce `reports/telemetry/error-aggregates-YYYY-MM-DD.json` and `reports/telemetry/telemetry-report-YYYY-MM-DD.md`.
 - Suggest owners (via CODEOWNERS / module owners when available) and prioritized next actions.

 Out of scope:
@@ -134,7 +134,7 @@ WORKFLOW (detailed)
   - Keep only sanitized sample traces (max length), counts and metadata.

 5) Generate artifacts
-   - `artifacts/error-aggregates-YYYYMMDD.json` (structured):
+   - `reports/telemetry/error-aggregates-YYYY-MM-DD.json` (structured):
     ```json
     {
       "generated_at": "...",
@@ -154,7 +154,7 @@ WORKFLOW (detailed)
       ]
     }
     ```
-   - `ai/reports/telemetry-YYYYMMDD.md` (human summary):
+   - `reports/telemetry/telemetry-report-YYYY-MM-DD.md` (human summary):
     - Headline: total errors, total groups
     - Top-10 groups table: fingerprint, severity, count, owner, sample sanitized trace
     - Prioritized Top-5 recommended human actions
@@ -170,11 +170,11 @@ WORKFLOW (detailed)

 7) Commit / PR (if allowed)
   - If committing artifacts is permitted:
-     - Branch: `ai/telemetry-YYYYMMDD`
+     - Branch: `ai/telemetry-YYYY-MM-DD`
     - Commit message: `chore(ai): telemetry error aggregates (YYYY-MM-DD)`
     - PR title: `docs(ai): telemetry report — YYYY-MM-DD`
     - PR body: include the telemetry report summary and privacy audit
-   - If not permitted, attach `artifacts/error-aggregates-*.json` and the report to the PR body.
+   - If not permitted, attach `reports/telemetry/error-aggregates-*.json` and the report to the PR body.

 ───────────────────────────────────────────────────────────────────────────────
 FAILURE MODES & GUARDRAILS (when to stop)
@@ -189,7 +189,7 @@ FAILURE MODES & GUARDRAILS (when to stop)
 ───────────────────────────────────────────────────────────────────────────────
 REPORT FORMAT (required)

-`ai/reports/telemetry-YYYYMMDD.md` should include:
+`reports/telemetry/telemetry-report-YYYY-MM-DD.md` should include:

 1. **Headline**
   - `Total sanitized errors: N — Groups: M — Top severity: S`
@@ -224,10 +224,10 @@ PR & COMMIT CONVENTIONS
 ─────────────────────────────────────────────────────────────────────────────
 OUTPUTS PER RUN

- `artifacts/error-aggregates-YYYYMMDD.json` (sanitized, structured)
- `ai/reports/telemetry-YYYYMMDD.md` (human-ready)
+- `reports/telemetry/error-aggregates-YYYY-MM-DD.json` (sanitized, structured)
+- `reports/telemetry/telemetry-report-YYYY-MM-DD.md` (human-ready)
 - 0–N issues suggested for top errors (only if policy allows automation)
- If permitted: a PR `ai/telemetry-YYYYMMDD` with artifacts and privacy audit
+- If permitted: a PR `ai/telemetry-YYYY-MM-DD` with artifacts and privacy audit

 ─────────────────────────────────────────────────────────────────────────────
 BEGIN
@@ -236,7 +236,7 @@ BEGIN
 2. Discover opt-in artifacts (CI runs with `TELEMETRY=1`, `artifacts/telemetry-optin/`, agent-run logs).
 3. Sanitize each artifact (apply PII/key/IP/email redaction and log an audit of replacements).
 4. Normalize & fingerprint stack traces; aggregate counts and compute severity.
-5. Produce `artifacts/error-aggregates-YYYYMMDD.json` and `ai/reports/telemetry-YYYYMMDD.md`.
-6. If artifacts are permitted to be committed, open `ai/telemetry-YYYYMMDD` PR with the report. Otherwise, attach in PR body and open issue(s) for human triage.
+5. Produce `reports/telemetry/error-aggregates-YYYY-MM-DD.json` and `reports/telemetry/telemetry-report-YYYY-MM-DD.md`.
+6. If artifacts are permitted to be committed, open `ai/telemetry-YYYY-MM-DD` PR with the report. Otherwise, attach in PR body and open issue(s) for human triage.

 **Privacy-first rule:** If you cannot guarantee all PII/keys are redacted from every artifact, stop and request maintainer review — do not commit or publish raw logs.
@@ -71,7 +71,7 @@ WORKFLOW
      - branch naming conventions (e.g., `ai/*`)
      - label conventions (e.g., `requires-security-review`, `requires-protocol-review`)
  - Verify whether the target folder exists:
-      - `ai/reports/`
+      - `reports/weekly-synthesis/`
    If it does not exist, do not invent new structure without checking policy:
      - Prefer placing the report where existing reports live, or open an issue
        proposing the location.
@@ -125,7 +125,7 @@ Optional method (use curl to query the GitHub API):

 6) Write the report file
  File name (if allowed by repo conventions):
-  - `ai/reports/weekly-YYYYMMDD.md`
+  - `reports/weekly-synthesis/weekly-report-YYYY-MM-DD.md`

  Keep the report compact and scannable.

@@ -193,5 +193,5 @@ If report directory doesn’t exist and policy is unclear:
 ───────────────────────────────────────────────────────────────────────────────
 OUTPUTS PER RUN

- `ai/reports/weekly-YYYYMMDD.md` (or repo-approved equivalent)
+- `reports/weekly-synthesis/weekly-report-YYYY-MM-DD.md` (or repo-approved equivalent)
 - One commit containing only the report (if committing is allowed by policy)
@@ -138,6 +138,8 @@ async function probePublishRead(relayUrl, namespace, timeoutMs) {
      try {
        message = JSON.parse(raw.toString());
      } catch {
+        // Ignore malformed messages. The relay might be sending non-JSON data
+        // or we might have a protocol mismatch. We only care about valid JSON.
        return;
      }
      if (!Array.isArray(message) || message.length < 2) return;
@@ -194,15 +196,22 @@ async function appendHistory(historyPath, entry) {
 export async function runRelayHealthCheck(options = {}) {
  const {
    cadence = 'daily',
-    relays = getRelays(),
-    namespace = getNamespace(),
    timeoutMs = 6000,
-    historyPath = path.resolve(process.cwd(), 'task-logs', 'relay-health', `${cadence}.jsonl`),
    allRelaysDownMinutes = 10,
    minSuccessRate = 0.7,
    windowMinutes = 60,
  } = options;

+  let {
+    relays,
+    namespace,
+    historyPath,
+  } = options;
+
+  if (!relays) relays = await getRelays();
+  if (!namespace) namespace = await getNamespace();
+  if (!historyPath) historyPath = path.resolve(process.cwd(), 'task-logs', 'relay-health', `${cadence}.jsonl`);
+
  const relayResults = [];
  for (const relay of relays) {
    const relayResult = {
@@ -3,6 +3,23 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadTorchConfig } from './torch-config.mjs';

+const defaultDeps = {
+  fs,
+  loadTorchConfig,
+};
+
+const deps = { ...defaultDeps };
+
+/** @internal */
+export function _setRosterDependencies(overrides) {
+  Object.assign(deps, overrides);
+}
+
+/** @internal */
+export function _restoreRosterDependencies() {
+  Object.assign(deps, defaultDeps);
+}
+
 const ROSTER_FILE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'prompts/roster.json');
 const USER_ROSTER_FILE = path.resolve(process.cwd(), 'torch/roster.json');
 const CWD_ROSTER_FILE = path.resolve(process.cwd(), 'roster.json');
@@ -59,14 +76,14 @@ function loadCanonicalRoster() {
  let rosterPath = ROSTER_FILE;

  // Prefer user-managed roster if present
-  if (fs.existsSync(USER_ROSTER_FILE)) {
+  if (deps.fs.existsSync(USER_ROSTER_FILE)) {
    rosterPath = USER_ROSTER_FILE;
-  } else if (fs.existsSync(CWD_ROSTER_FILE)) {
+  } else if (deps.fs.existsSync(CWD_ROSTER_FILE)) {
    rosterPath = CWD_ROSTER_FILE;
  }

  try {
-    const parsed = JSON.parse(fs.readFileSync(rosterPath, 'utf8'));
+    const parsed = JSON.parse(deps.fs.readFileSync(rosterPath, 'utf8'));
    const daily = Array.isArray(parsed.daily) ? parsed.daily.map((item) => String(item).trim()).filter(Boolean) : [];
    const weekly = Array.isArray(parsed.weekly)
      ? parsed.weekly.map((item) => String(item).trim()).filter(Boolean)
@@ -86,6 +103,11 @@ function loadCanonicalRoster() {
  return cachedCanonicalRoster;
 }

+/** @internal */
+export function _resetRosterCache() {
+  cachedCanonicalRoster = null;
+}
+
 function parseEnvRoster(value) {
  if (!value) return null;
  return value
@@ -94,8 +116,8 @@ function parseEnvRoster(value) {
    .filter(Boolean);
 }

-export function getRoster(cadence) {
-  const config = loadTorchConfig();
+export async function getRoster(cadence) {
+  const config = await deps.loadTorchConfig();
  const dailyFromEnv = parseEnvRoster(process.env.NOSTR_LOCK_DAILY_ROSTER);
  const weeklyFromEnv = parseEnvRoster(process.env.NOSTR_LOCK_WEEKLY_ROSTER);
  const canonical = loadCanonicalRoster();
@@ -0,0 +1,288 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+
+const PROPOSALS_DIR = path.resolve(process.cwd(), 'src/proposals');
+const HISTORY_DIR = path.resolve(process.cwd(), '.torch/prompt-history');
+const ALLOWED_TARGET_DIRS = [
+  path.resolve(process.cwd(), 'src/prompts/daily'),
+  path.resolve(process.cwd(), 'src/prompts/weekly'),
+];
+
+async function ensureDirs() {
+  await fs.mkdir(PROPOSALS_DIR, { recursive: true });
+  await fs.mkdir(HISTORY_DIR, { recursive: true });
+}
+
+export async function listProposals() {
+  await ensureDirs();
+  const entries = await fs.readdir(PROPOSALS_DIR, { withFileTypes: true });
+  const proposals = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const metaPath = path.join(PROPOSALS_DIR, entry.name, 'meta.json');
+      try {
+        const metaContent = await fs.readFile(metaPath, 'utf8');
+        const meta = JSON.parse(metaContent);
+        proposals.push({
+          id: entry.name,
+          ...meta
+        });
+      } catch (e) {
+        // Ignore invalid proposals
+      }
+    }
+  }
+  return proposals;
+}
+
+export async function getProposal(id) {
+  const dir = path.join(PROPOSALS_DIR, id);
+  const metaPath = path.join(dir, 'meta.json');
+  const newPath = path.join(dir, 'new.md');
+  const diffPath = path.join(dir, 'change.diff');
+
+  try {
+    const meta = JSON.parse(await fs.readFile(metaPath, 'utf8'));
+    const newContent = await fs.readFile(newPath, 'utf8');
+    let diff = '';
+    try {
+      diff = await fs.readFile(diffPath, 'utf8');
+    } catch {
+      // Ignore missing diff
+    }
+
+    return {
+      id,
+      meta,
+      newContent,
+      diff,
+      dir
+    };
+  } catch (e) {
+    throw new Error(`Proposal ${id} not found or invalid: ${e.message}`, { cause: e });
+  }
+}
+
+export async function createProposal({ agent, target, newContent, reason }) {
+  await ensureDirs();
+
+  // Validate target path is allowed
+  const absoluteTarget = path.resolve(process.cwd(), target);
+  const isAllowed = ALLOWED_TARGET_DIRS.some(allowed => absoluteTarget.startsWith(allowed));
+
+  if (!isAllowed) {
+    throw new Error(`Target ${target} is not in an allowed directory (src/prompts/daily or src/prompts/weekly).`);
+  }
+
+  // Generate ID
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const id = `${timestamp}_${agent}`;
+  const dir = path.join(PROPOSALS_DIR, id);
+
+  await fs.mkdir(dir, { recursive: true });
+
+  // Write content
+  await fs.writeFile(path.join(dir, 'new.md'), newContent);
+
+  // Generate Diff if target exists
+  let diff = '';
+  try {
+    // Check if target exists
+    await fs.access(absoluteTarget);
+
+    // Create a temporary file for the diff logic to work cleanly
+    // But direct path is fine.
+    const newFile = path.join(dir, 'new.md');
+    const diffCmd = `git diff --no-index --color=never "${absoluteTarget}" "${newFile}"`;
+    try {
+      execSync(diffCmd, { stdio: 'pipe' }); // Will throw if exit code 1 (diff found)
+    } catch (e) {
+      if (e.status === 1 && e.stdout) {
+        diff = e.stdout.toString();
+      } else if (e.status !== 1) {
+          // Some other error
+          console.error('Diff generation failed:', e.message);
+      }
+    }
+  } catch (err) {
+    diff = '(New File)';
+  }
+
+  await fs.writeFile(path.join(dir, 'change.diff'), diff);
+
+  const meta = {
+    id,
+    author: agent,
+    target,
+    reason,
+    timestamp: new Date().toISOString(),
+    status: 'pending'
+  };
+
+  await fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta, null, 2));
+
+  return { id, diff };
+}
+
+export async function validateProposal(id) {
+  const { meta, newContent } = await getProposal(id);
+
+  // 1. Allowlist check (redundant but safe)
+  const absoluteTarget = path.resolve(process.cwd(), meta.target);
+  const isAllowed = ALLOWED_TARGET_DIRS.some(allowed => absoluteTarget.startsWith(allowed));
+  if (!isAllowed) {
+    return { valid: false, reason: 'Target not in allowed directories.' };
+  }
+
+  // 2. Invariant checks
+  // Check for required headers based on common prompt structure
+  const requiredPatterns = [
+    /Shared contract \(required\):/i,
+    /Required startup \+ artifacts \+ memory \+ issue capture/i,
+  ];
+
+  for (const pattern of requiredPatterns) {
+    if (!pattern.test(newContent)) {
+       return { valid: false, reason: `Missing required header pattern: ${pattern}` };
+    }
+  }
+
+  return { valid: true };
+}
+
+export async function applyProposal(id) {
+  const proposal = await getProposal(id);
+  const { meta, newContent, dir } = proposal;
+
+  if (meta.status !== 'pending') {
+    throw new Error(`Proposal is ${meta.status}, cannot apply.`);
+  }
+
+  const validation = await validateProposal(id);
+  if (!validation.valid) {
+    // Mark as rejected if validation fails?
+    // Or just throw? The governance agent should decide.
+    // We throw here to prevent accidental application.
+    throw new Error(`Validation failed: ${validation.reason}`);
+  }
+
+  const absoluteTarget = path.resolve(process.cwd(), meta.target);
+
+  // Archive old
+  try {
+    const oldContent = await fs.readFile(absoluteTarget, 'utf8');
+    const hash = createHash('sha256').update(oldContent).digest('hex');
+
+    // We store archives in .torch/prompt-history/<target_path>/<hash>.md
+    // Note: meta.target is relative path like 'src/prompts/daily/agent.md'
+    // We want to keep that structure.
+    const archiveDir = path.join(HISTORY_DIR, path.dirname(meta.target));
+    await fs.mkdir(archiveDir, { recursive: true });
+
+    // Add timestamp to filename for easier sorting later?
+    // Or just rely on hash and store metadata elsewhere?
+    // User requested <path>/<hash>.md.
+    const archivePath = path.join(archiveDir, `${path.basename(meta.target, '.md')}_${hash}.md`);
+    await fs.writeFile(archivePath, oldContent);
+  } catch (e) {
+    // If file didn't exist, nothing to archive
+  }
+
+  // Apply new
+  await fs.mkdir(path.dirname(absoluteTarget), { recursive: true });
+  await fs.writeFile(absoluteTarget, newContent);
+
+  // Update meta
+  meta.status = 'applied';
+  meta.appliedAt = new Date().toISOString();
+  await fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta, null, 2));
+
+  // Git Commit (optional)
+  try {
+    // We use execSync for git operations
+    // Ensure we are in repo root? cwd is repo root.
+    execSync(`git add "${meta.target}"`);
+    const commitMsg = `feat(prompts): apply proposal ${id} by ${meta.author}`;
+    execSync(`git commit -m "${commitMsg}"`);
+    meta.gitCommit = execSync('git rev-parse HEAD').toString().trim();
+    await fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta, null, 2));
+  } catch (gitErr) {
+    console.warn('Git commit failed (ignoring):', gitErr.message);
+  }
+
+  return { success: true };
+}
+
+export async function rejectProposal(id, reason) {
+  const proposal = await getProposal(id);
+  const { meta, dir } = proposal;
+
+  meta.status = 'rejected';
+  meta.rejectionReason = reason;
+  meta.rejectedAt = new Date().toISOString();
+
+  await fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta, null, 2));
+  return { success: true };
+}
+
+export async function rollbackPrompt(target, hashOrStrategy = 'latest') {
+  // target is relative path e.g. src/prompts/daily/agent.md
+  const archiveDir = path.join(HISTORY_DIR, path.dirname(target));
+  const absoluteTarget = path.resolve(process.cwd(), target);
+
+  let sourceContent = null;
+  let sourceName = null;
+
+  try {
+    // Try Local Archive first
+    if (hashOrStrategy === 'latest') {
+       // Find latest file in archiveDir
+       // Our naming is <agent>_<hash>.md.
+       // We can rely on file mtime.
+       const files = await fs.readdir(archiveDir);
+       const targetBase = path.basename(target, '.md');
+       const prefix = targetBase + '_';
+       const candidates = files.filter(f => f.startsWith(prefix));
+
+       if (candidates.length > 0) {
+           const stats = await Promise.all(candidates.map(async f => ({
+               name: f,
+               ...await fs.stat(path.join(archiveDir, f))
+           })));
+           const latest = stats.sort((a, b) => b.mtimeMs - a.mtimeMs)[0];
+           sourceName = latest.name;
+           sourceContent = await fs.readFile(path.join(archiveDir, sourceName), 'utf8');
+       }
+    } else {
+        // Try to find file containing hash
+        const files = await fs.readdir(archiveDir);
+        const match = files.find(f => f.includes(hashOrStrategy));
+        if (match) {
+            sourceName = match;
+            sourceContent = await fs.readFile(path.join(archiveDir, match), 'utf8');
+        }
+    }
+  } catch (e) {
+      // Archive lookup failed
+  }
+
+  if (sourceContent) {
+      await fs.writeFile(absoluteTarget, sourceContent);
+      return { success: true, source: 'archive', restored: sourceName };
+  }
+
+  // Fallback to Git
+  try {
+      const commit = hashOrStrategy === 'latest' ? 'HEAD' : hashOrStrategy;
+      // Use git show instead of checkout to avoid detaching head if we just want content
+      // But user said "git checkout" implying revert state.
+      // Actually `git checkout <commit> -- <path>` overwrites the file in working tree.
+      execSync(`git checkout "${commit}" -- "${target}"`);
+      return { success: true, source: 'git', restored: commit };
+  } catch (e) {
+      throw new Error(`Rollback failed: Local archive not found and git failed (${e.message})`, { cause: e });
+  }
+}
@@ -6,8 +6,11 @@ import { startScheduler } from './scheduler.js';
 import { getMemoryPruneMode, isMemoryIngestEnabled } from './feature-flags.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import util from 'node:util';
+import { ensureDir } from '../../utils.mjs';

 const MEMORY_FILE_PATH = path.join(process.cwd(), '.scheduler-memory', 'memory-store.json');
+const debug = util.debuglog('torch-memory');

 function loadMemoryStore() {
  try {
@@ -24,26 +27,52 @@ function loadMemoryStore() {
  return new Map();
 }

-function saveMemoryStore(store) {
+let currentSavePromise = null;
+let pendingSavePromise = null;
+let pendingSaveResolve = null;
+
+async function performSave(store) {
  try {
    const dir = path.dirname(MEMORY_FILE_PATH);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
+    await fs.promises.mkdir(dir, { recursive: true });
    const entries = [...store.entries()];
-    fs.writeFileSync(MEMORY_FILE_PATH, JSON.stringify(entries, null, 2), 'utf8');
+    await fs.promises.writeFile(MEMORY_FILE_PATH, JSON.stringify(entries, null, 2), 'utf8');
  } catch (err) {
    console.error('Failed to save memory store:', err);
+  } finally {
+    currentSavePromise = null;
+    if (pendingSavePromise) {
+      const resolve = pendingSaveResolve;
+      pendingSavePromise = null;
+      pendingSaveResolve = null;
+      currentSavePromise = performSave(store).then(() => resolve());
+    }
  }
 }

+async function saveMemoryStore(store) {
+  if (pendingSavePromise) {
+    return pendingSavePromise;
+  }
+
+  if (currentSavePromise) {
+    pendingSavePromise = new Promise((resolve) => {
+      pendingSaveResolve = resolve;
+    });
+    return pendingSavePromise;
+  }
+
+  currentSavePromise = performSave(store);
+  return currentSavePromise;
+}
+
 const memoryStore = loadMemoryStore();
 const cache = createMemoryCache();

 const memoryRepository = {
  async insertMemory(memory) {
    memoryStore.set(memory.id, memory);
-    saveMemoryStore(memoryStore);
+    await saveMemoryStore(memoryStore);
    return memory;
  },
  async updateMemoryUsage(id, lastSeen = Date.now()) {
@@ -51,7 +80,7 @@ const memoryRepository = {
    if (!existing) return null;
    const updated = { ...existing, last_seen: lastSeen };
    memoryStore.set(id, updated);
-    saveMemoryStore(memoryStore);
+    await saveMemoryStore(memoryStore);
    return updated;
  },
  async listPruneCandidates({ cutoff }) {
@@ -61,7 +90,7 @@ const memoryRepository = {
    const existing = memoryStore.get(id);
    if (!existing) return false;
    memoryStore.set(id, { ...existing, merged_into: mergedInto, last_seen: Date.now() });
-    saveMemoryStore(memoryStore);
+    await saveMemoryStore(memoryStore);
    return true;
  },
  async setPinned(id, pinned) {
@@ -69,7 +98,7 @@ const memoryRepository = {
    if (!existing) return null;
    const updated = { ...existing, pinned, last_seen: Date.now() };
    memoryStore.set(id, updated);
-    saveMemoryStore(memoryStore);
+    await saveMemoryStore(memoryStore);
    return updated;
  },
  async getMemoryById(id) {
@@ -113,7 +142,7 @@ function buildTelemetryEmitter(options = {}) {
  }

  return (event, payload) => {
-    console.log('memory_telemetry', {
+    debug('memory_telemetry', {
      event,
      payload: toSafeTelemetryPayload(payload),
      ts: Date.now(),
@@ -132,7 +161,7 @@ function emitMetric(options = {}, metric, payload) {
    return;
  }

-  console.log('memory_metric', { metric, payload, ts: Date.now() });
+  debug('memory_metric', { metric, payload, ts: Date.now() });
 }

 function applyMemoryFilters(memories, filters = {}) {
@@ -196,10 +225,15 @@ export async function ingestEvents(events, options = {}) {
 * @returns {Promise<import('./schema.js').MemoryRecord[]>} Sorted list of relevant memories.
 */
 export async function getRelevantMemories(params) {
-  const { repository = memoryRepository, ...queryParams } = params;
+  const {
+    repository = memoryRepository,
+    ranker = filterAndRankMemories,
+    cache: cacheProvider = cache,
+    ...queryParams
+  } = params;
  const telemetry = buildTelemetryEmitter(params);
  const cacheKey = JSON.stringify(queryParams);
-  const cached = cache.get(cacheKey);
+  const cached = cacheProvider.get(cacheKey);
  if (cached) {
    telemetry('memory:retrieved', {
      agent_id: queryParams.agent_id,
@@ -214,9 +248,13 @@ export async function getRelevantMemories(params) {
    return cached;
  }

-  const ranked = await filterAndRankMemories([...memoryStore.values()], queryParams);
+  const source = typeof repository.listMemories === 'function'
+    ? await repository.listMemories(queryParams)
+    : [...memoryStore.values()];
+
+  const ranked = await ranker(source, queryParams);
  await updateMemoryUsage(repository, ranked.map((memory) => memory.id));
-  cache.set(cacheKey, ranked);
+  cacheProvider.set(cacheKey, ranked);

  telemetry('memory:retrieved', {
    agent_id: queryParams.agent_id,
@@ -275,7 +313,7 @@ export async function runPruneCycle(options = {}) {
  }

  if (prunable.length > 0) {
-    saveMemoryStore(memoryStore);
+    await saveMemoryStore(memoryStore);
  }

  memoryStatsState.deleted += prunable.length;
@@ -330,8 +368,9 @@ export async function unpinMemory(id, options = {}) {
 * @param {string} id
 * @param {string} mergedInto
 */
-export async function markMemoryMerged(id, mergedInto) {
-  const merged = await memoryRepository.markMerged(id, mergedInto);
+export async function markMemoryMerged(id, mergedInto, options = {}) {
+  const repository = options.repository ?? memoryRepository;
+  const merged = await repository.markMerged(id, mergedInto);
  cache.clear();
  return merged;
 }
@@ -67,22 +67,29 @@ function evaluateCandidate(memory, policy) {
 * @param {{ getEmbedding?: (memory: import('./schema.js').MemoryRecord) => number[] | null | undefined, similarityThreshold: number, duplicateWindowMs: number }} options
 */
 function groupNearDuplicates(memories, options) {
+  // Sort by created_at to enable early exit in the inner loop
+  const sortedMemories = [...memories].sort((a, b) => a.created_at - b.created_at);
+
  const groups = [];
  const consumed = new Set();

-  for (let i = 0; i < memories.length; i += 1) {
-    const base = memories[i];
+  for (let i = 0; i < sortedMemories.length; i += 1) {
+    const base = sortedMemories[i];
    if (consumed.has(base.id) || base.merged_into) continue;

    const baseEmbedding = options.getEmbedding?.(base);
    const group = [base];

-    for (let j = i + 1; j < memories.length; j += 1) {
-      const probe = memories[j];
+    for (let j = i + 1; j < sortedMemories.length; j += 1) {
+      const probe = sortedMemories[j];
+
+      // Optimization: Since sorted by created_at, if the time difference exceeds the window,
+      // all subsequent items will also be outside the window.
+      if (probe.created_at - base.created_at > options.duplicateWindowMs) break;
+
      if (consumed.has(probe.id) || probe.merged_into || probe.id === base.id) continue;

-      const withinWindow = Math.abs(base.created_at - probe.created_at) <= options.duplicateWindowMs;
-      if (!withinWindow || !hasTagOverlap(base.tags, probe.tags)) continue;
+      if (!hasTagOverlap(base.tags, probe.tags)) continue;

      const similarity = cosineSimilarity(baseEmbedding, options.getEmbedding?.(probe));
      if (similarity >= options.similarityThreshold) {
@@ -189,12 +196,13 @@ export async function createLifecyclePlan(memories, options) {
  });

  const templates = loadMemoryPromptTemplates({ templateDir: options.templateDir });
-  const condensedGroups = [];
+  const condensedGroups = await Promise.all(
+    groups.map((group) => condenseGroup(group, options.generateSummary, templates.condense))
+  );
+
  const mergedIntoMap = new Map();

-  for (const group of groups) {
-    const condensed = await condenseGroup(group, options.generateSummary, templates.condense);
-    condensedGroups.push(condensed);
+  for (const condensed of condensedGroups) {
    for (const mergedId of condensed.mergedIds) {
      mergedIntoMap.set(mergedId, condensed.merged.id);
    }
@@ -265,9 +273,7 @@ export async function createLifecyclePlan(memories, options) {
 * @param {Awaited<ReturnType<typeof createLifecyclePlan>>} plan
 */
 export async function applyLifecycleActions(repository, plan) {
-  const results = [];
-
-  for (const decision of plan.actions) {
+  const results = await Promise.all(plan.actions.map(async (decision) => {
    if (decision.merged_into && typeof repository.markMerged === 'function') {
      await repository.markMerged(decision.id, decision.merged_into);
    }
@@ -280,8 +286,8 @@ export async function applyLifecycleActions(repository, plan) {
      await repository.keepMemory?.(decision.id, decision.reason);
    }

-    results.push(decision);
-  }
+    return decision;
+  }));

  return {
    applied: results,
@@ -31,17 +31,20 @@ function computeRecencyDecay(timestamp, now, halfLifeMs) {
  return Math.exp(-(age / halfLifeMs));
 }

-function textMatchSimilarity(query, memory) {
-  const normalizedQuery = String(query ?? '').trim().toLowerCase();
-  if (!normalizedQuery) return 0;
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

-  const haystack = `${memory.summary} ${memory.content}`.toLowerCase();
-  if (haystack.includes(normalizedQuery)) return 1;
+function textMatchSimilarity(queryTerms, queryRegexes, memory) {
+  if (!queryTerms || queryTerms.length === 0) return 0;

-  const queryTerms = normalizedQuery.split(/\s+/).filter(Boolean);
-  if (queryTerms.length === 0) return 0;
+  let matchedTerms = 0;
+  for (const regex of queryRegexes) {
+    if (regex.test(memory.summary) || regex.test(memory.content)) {
+      matchedTerms++;
+    }
+  }

-  const matchedTerms = queryTerms.filter((term) => haystack.includes(term)).length;
  return matchedTerms / queryTerms.length;
 }

@@ -102,8 +105,11 @@ async function buildSimilarityIndex(memories, params) {
    }
  }

+  const queryTerms = normalizedQuery.toLowerCase().split(/\s+/).filter(Boolean);
+  const queryRegexes = queryTerms.map((t) => new RegExp(escapeRegExp(t), 'i'));
+
  for (const memory of memories) {
-    const lexicalScore = textMatchSimilarity(normalizedQuery, memory);
+    const lexicalScore = textMatchSimilarity(queryTerms, queryRegexes, memory);
    if (lexicalScore > 0) {
      similarityById.set(memory.id, lexicalScore);
    }
@@ -21,9 +21,9 @@ function parsePositiveInteger(value) {
  return Math.floor(value);
 }

-function parseRelayList(value) {
+function parseStringList(value) {
  if (!Array.isArray(value)) return null;
-  const parsed = value.map((relay) => String(relay).trim()).filter(Boolean);
+  const parsed = value.map((item) => String(item).trim()).filter(Boolean);
  return parsed.length > 0 ? parsed : null;
 }

@@ -63,11 +63,6 @@ function normalizeStatus(value, fallback) {
  return normalized === 'active' || normalized === 'all' ? normalized : fallback;
 }

-function parseRoster(value) {
-  if (!Array.isArray(value)) return null;
-  const parsed = value.map((item) => String(item).trim()).filter(Boolean);
-  return parsed.length > 0 ? parsed : null;
-}

 export function getTorchConfigPath() {
  const explicitPath = (process.env.TORCH_CONFIG_PATH || '').trim();
@@ -94,10 +89,8 @@ export function parseTorchConfig(raw, configPath = null) {
    raw,
    nostrLock: {
      namespace: typeof nostrLock.namespace === 'string' ? nostrLock.namespace.trim() : null,
-      relays: Array.isArray(nostrLock.relays)
-        ? nostrLock.relays.map((relay) => String(relay).trim()).filter(Boolean)
-        : null,
-      relayFallbacks: parseRelayList(nostrLock.relayFallbacks),
+      relays: parseStringList(nostrLock.relays),
+      relayFallbacks: parseStringList(nostrLock.relayFallbacks),
      ttlSeconds: Number.isFinite(nostrLock.ttlSeconds) && nostrLock.ttlSeconds > 0
        ? Math.floor(nostrLock.ttlSeconds)
        : null,
@@ -105,17 +98,16 @@ export function parseTorchConfig(raw, configPath = null) {
      publishTimeoutMs: parsePositiveInteger(nostrLock.publishTimeoutMs),
      minSuccessfulRelayPublishes: parsePositiveInteger(nostrLock.minSuccessfulRelayPublishes),
      minActiveRelayPool: parsePositiveInteger(nostrLock.minActiveRelayPool),
-      dailyRoster: parseRoster(nostrLock.dailyRoster),
-      weeklyRoster: parseRoster(nostrLock.weeklyRoster),
+      dailyRoster: parseStringList(nostrLock.dailyRoster),
+      weeklyRoster: parseStringList(nostrLock.weeklyRoster),
    },
    dashboard: {
      defaultCadenceView: normalizeCadence(dashboard.defaultCadenceView, 'daily'),
      defaultStatusView: normalizeStatus(dashboard.defaultStatusView, 'active'),
-      relays: Array.isArray(dashboard.relays)
-        ? dashboard.relays.map((relay) => String(relay).trim()).filter(Boolean)
-        : null,
+      relays: parseStringList(dashboard.relays),
      namespace: typeof dashboard.namespace === 'string' ? dashboard.namespace.trim() : null,
      hashtag: typeof dashboard.hashtag === 'string' ? dashboard.hashtag.trim() : null,
+      auth: typeof dashboard.auth === 'string' ? dashboard.auth.trim() : null,
    },
    scheduler: {
      firstPromptByCadence: {
@@ -123,8 +115,8 @@ export function parseTorchConfig(raw, configPath = null) {
        weekly: typeof firstPromptByCadence.weekly === 'string' ? firstPromptByCadence.weekly.trim() : null,
      },
      paused: {
-        daily: parseRoster(paused.daily) || [],
-        weekly: parseRoster(paused.weekly) || [],
+        daily: parseStringList(paused.daily) || [],
+        weekly: parseStringList(paused.weekly) || [],
      },
    },
  };
@@ -135,18 +127,20 @@ export function _resetTorchConfigCache() {
  cachedConfig = null;
 }

-export function loadTorchConfig(fileSystem = fs) {
+export async function loadTorchConfig(fileSystem = fs) {
  if (cachedConfig) return cachedConfig;

  const configPath = getTorchConfigPath();
  let raw = {};

-  if (fileSystem.existsSync(configPath)) {
-    try {
-      raw = JSON.parse(fileSystem.readFileSync(configPath, 'utf8'));
-    } catch (err) {
+  try {
+    const content = await fileSystem.promises.readFile(configPath, 'utf8');
+    raw = JSON.parse(content);
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
      throw new Error(`Failed to parse ${configPath}: ${err.message}`, { cause: err });
    }
+    // If file missing (ENOENT), we use empty object defaults
  }

  cachedConfig = parseTorchConfig(raw, configPath);
@@ -195,8 +189,20 @@ function parseEnvInteger(envValue, envName) {
  return parsed;
 }

-export function getRelays() {
-  const config = loadTorchConfig();
+function resolveIntegerConfig(envKey, configValue, defaultValue, validator, configLabel) {
+  const envValue = process.env[envKey];
+  if (envValue) {
+    const parsed = parseEnvInteger(envValue, envKey);
+    validator(parsed, envKey);
+    return parsed;
+  }
+  const value = configValue || defaultValue;
+  validator(value, `effective ${configLabel}`);
+  return value;
+}
+
+export async function getRelays() {
+  const config = await loadTorchConfig();
  const envRelays = process.env.NOSTR_LOCK_RELAYS;
  if (envRelays) {
    return parseEnvRelayList(envRelays, 'NOSTR_LOCK_RELAYS');
@@ -210,8 +216,8 @@ export function getRelays() {
  return DEFAULT_RELAYS;
 }

-export function getRelayFallbacks() {
-  const config = loadTorchConfig();
+export async function getRelayFallbacks() {
+  const config = await loadTorchConfig();
  const envRelays = process.env.NOSTR_LOCK_RELAY_FALLBACKS;
  if (envRelays) {
    return parseEnvRelayList(envRelays, 'NOSTR_LOCK_RELAY_FALLBACKS');
@@ -219,14 +225,14 @@ export function getRelayFallbacks() {
  return config.nostrLock.relayFallbacks || [];
 }

-export function getNamespace() {
-  const config = loadTorchConfig();
+export async function getNamespace() {
+  const config = await loadTorchConfig();
  const namespace = (process.env.NOSTR_LOCK_NAMESPACE || config.nostrLock.namespace || DEFAULT_NAMESPACE).trim();
  return namespace || DEFAULT_NAMESPACE;
 }

-export function getTtl() {
-  const config = loadTorchConfig();
+export async function getTtl() {
+  const config = await loadTorchConfig();
  const envTtl = process.env.NOSTR_LOCK_TTL;
  if (envTtl) {
    const parsed = parseInt(envTtl, 10);
@@ -238,60 +244,52 @@ export function getTtl() {
  return DEFAULT_TTL;
 }

-export function getQueryTimeoutMs() {
-  const config = loadTorchConfig();
-  const envValue = process.env.NOSTR_LOCK_QUERY_TIMEOUT_MS;
-  if (envValue) {
-    const parsed = parseEnvInteger(envValue, 'NOSTR_LOCK_QUERY_TIMEOUT_MS');
-    assertTimeoutInRange(parsed, 'NOSTR_LOCK_QUERY_TIMEOUT_MS');
-    return parsed;
-  }
-  const value = config.nostrLock.queryTimeoutMs || DEFAULT_QUERY_TIMEOUT_MS;
-  assertTimeoutInRange(value, 'effective query timeout');
-  return value;
+export async function getQueryTimeoutMs() {
+  const config = await loadTorchConfig();
+  return resolveIntegerConfig(
+    'NOSTR_LOCK_QUERY_TIMEOUT_MS',
+    config.nostrLock.queryTimeoutMs,
+    DEFAULT_QUERY_TIMEOUT_MS,
+    assertTimeoutInRange,
+    'query timeout',
+  );
 }

-export function getPublishTimeoutMs() {
-  const config = loadTorchConfig();
-  const envValue = process.env.NOSTR_LOCK_PUBLISH_TIMEOUT_MS;
-  if (envValue) {
-    const parsed = parseEnvInteger(envValue, 'NOSTR_LOCK_PUBLISH_TIMEOUT_MS');
-    assertTimeoutInRange(parsed, 'NOSTR_LOCK_PUBLISH_TIMEOUT_MS');
-    return parsed;
-  }
-  const value = config.nostrLock.publishTimeoutMs || DEFAULT_PUBLISH_TIMEOUT_MS;
-  assertTimeoutInRange(value, 'effective publish timeout');
-  return value;
+export async function getPublishTimeoutMs() {
+  const config = await loadTorchConfig();
+  return resolveIntegerConfig(
+    'NOSTR_LOCK_PUBLISH_TIMEOUT_MS',
+    config.nostrLock.publishTimeoutMs,
+    DEFAULT_PUBLISH_TIMEOUT_MS,
+    assertTimeoutInRange,
+    'publish timeout',
+  );
 }

-export function getMinSuccessfulRelayPublishes() {
-  const config = loadTorchConfig();
-  const envValue = process.env.NOSTR_LOCK_MIN_SUCCESSFUL_PUBLISHES;
-  if (envValue) {
-    const parsed = parseEnvInteger(envValue, 'NOSTR_LOCK_MIN_SUCCESSFUL_PUBLISHES');
-    assertPositiveCount(parsed, 'NOSTR_LOCK_MIN_SUCCESSFUL_PUBLISHES');
-    return parsed;
-  }
-  const value = config.nostrLock.minSuccessfulRelayPublishes || DEFAULT_MIN_SUCCESSFUL_PUBLISHES;
-  assertPositiveCount(value, 'effective min successful relay publishes');
-  return value;
+export async function getMinSuccessfulRelayPublishes() {
+  const config = await loadTorchConfig();
+  return resolveIntegerConfig(
+    'NOSTR_LOCK_MIN_SUCCESSFUL_PUBLISHES',
+    config.nostrLock.minSuccessfulRelayPublishes,
+    DEFAULT_MIN_SUCCESSFUL_PUBLISHES,
+    assertPositiveCount,
+    'min successful relay publishes',
+  );
 }

-export function getMinActiveRelayPool() {
-  const config = loadTorchConfig();
-  const envValue = process.env.NOSTR_LOCK_MIN_ACTIVE_RELAY_POOL;
-  if (envValue) {
-    const parsed = parseEnvInteger(envValue, 'NOSTR_LOCK_MIN_ACTIVE_RELAY_POOL');
-    assertPositiveCount(parsed, 'NOSTR_LOCK_MIN_ACTIVE_RELAY_POOL');
-    return parsed;
-  }
-  const value = config.nostrLock.minActiveRelayPool || DEFAULT_MIN_ACTIVE_RELAY_POOL;
-  assertPositiveCount(value, 'effective min active relay pool');
-  return value;
+export async function getMinActiveRelayPool() {
+  const config = await loadTorchConfig();
+  return resolveIntegerConfig(
+    'NOSTR_LOCK_MIN_ACTIVE_RELAY_POOL',
+    config.nostrLock.minActiveRelayPool,
+    DEFAULT_MIN_ACTIVE_RELAY_POOL,
+    assertPositiveCount,
+    'min active relay pool',
+  );
 }

-export function getHashtag() {
-  const config = loadTorchConfig();
+export async function getHashtag() {
+  const config = await loadTorchConfig();
  const envValue = process.env.NOSTR_LOCK_HASHTAG;
  if (envValue) {
    return envValue.trim();
@@ -299,6 +297,15 @@ export function getHashtag() {
  if (config.dashboard.hashtag) {
    return config.dashboard.hashtag;
  }
-  const namespace = getNamespace();
+  const namespace = await getNamespace();
  return `${namespace}-agent-lock`;
 }
+
+export async function getDashboardAuth() {
+  const config = await loadTorchConfig();
+  const envValue = process.env.TORCH_DASHBOARD_AUTH;
+  if (envValue) {
+    return envValue.trim();
+  }
+  return config.dashboard.auth;
+}
@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+
 export function todayDateStr() {
  return new Date().toISOString().slice(0, 10);
 }
@@ -32,5 +34,12 @@ export function detectPlatform() {
  if (process.env.JULES_API_KEY || process.env.JULES_SESSION_ID) return 'jules';
  if (process.env.CODEX_API_KEY || process.env.CODEX_SESSION_ID) return 'codex';
  if (process.env.GOOSE_API_KEY || process.env.GOOSE_SESSION_ID) return 'goose';
+  if (process.env.CLAUDE_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_SESSION_ID) return 'claude';
  return null;
 }
+
+export function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}