@ssm-08/relay 0.4.0

package/bin/relay.mjs

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { isMain } from '../lib/util.mjs';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+export function relayInit(targetDir) {
+  const relayDir = path.join(targetDir, '.relay');
+
+  if (fs.existsSync(relayDir)) {
+    console.log('Relay already initialized.');
+    return false;
+  }
+
+  // Create .relay/memory.md — optionally seeded from existing CLAUDE.md
+  fs.mkdirSync(relayDir, { recursive: true });
+
+  let seedSection = '';
+  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+  let claudeStat;
+  try { claudeStat = fs.statSync(claudeMdPath); } catch {}
+  if (claudeStat && claudeStat.isFile()) {
+    const raw = fs.readFileSync(claudeMdPath, 'utf8');
+    const MAX = 8000;
+    const body = raw.length > MAX ? raw.slice(0, MAX) + '\n<!-- truncated -->' : raw;
+    const trimmed = body.trim();
+    if (trimmed) {
+      seedSection = `\n\n## Seeded from CLAUDE.md\n\n<!-- One-time import on relay init. Not kept in sync. -->\n\n${trimmed}`;
+      console.log('  → Seeded memory.md from existing CLAUDE.md');
+    }
+  }
+
+  fs.writeFileSync(
+    path.join(relayDir, 'memory.md'),
+    `# Relay Memory\n<!-- Populated by distiller. Edit manually to seed context. -->${seedSection}\n`,
+    'utf8'
+  );
+
+  // Create .relay/broadcast/ with .gitkeep so git tracks the empty dir
+  fs.mkdirSync(path.join(relayDir, 'broadcast'), { recursive: true });
+  fs.writeFileSync(path.join(relayDir, 'broadcast', '.gitkeep'), '', 'utf8');
+
+  // Create .relay/broadcast/skills/ with .gitkeep so git tracks it before any skill is broadcast
+  fs.mkdirSync(path.join(relayDir, 'broadcast', 'skills'), { recursive: true });
+  fs.writeFileSync(path.join(relayDir, 'broadcast', 'skills', '.gitkeep'), '', 'utf8');
+
+  // Update .gitignore — idempotent
+  const gitignorePath = path.join(targetDir, '.gitignore');
+  let existing = '';
+  try { existing = fs.readFileSync(gitignorePath, 'utf8'); } catch {}
+
+  const toAdd = [];
+  if (!existing.includes('.relay/state/')) toAdd.push('.relay/state/');
+  if (!existing.includes('.relay/log')) toAdd.push('.relay/log');
+
+  if (toAdd.length > 0) {
+    const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+    fs.appendFileSync(gitignorePath, prefix + toAdd.join('\n') + '\n', 'utf8');
+  }
+
+  console.log('Relay initialized.\n');
+  console.log('  git add .relay/ .gitignore');
+  console.log('  git commit -m "chore: add relay shared memory"');
+  console.log('  git push\n');
+  console.log('Teammates install once per machine:');
+  console.log('  npm install -g @ssm-08/relay && relay install');
+  return true;
+}
+
+export function relayStatus(targetDir) {
+  const relayDir = path.join(targetDir, '.relay');
+
+  if (!fs.existsSync(relayDir)) {
+    console.log('Relay not initialized in this repo. Run: relay init');
+    return;
+  }
+
+  // M6: fixed-width labels for readable demo output (11 chars + space)
+  const label = (s) => s.padEnd(11);
+
+  // Memory stats
+  const memPath = path.join(relayDir, 'memory.md');
+  if (fs.existsSync(memPath)) {
+    const content = fs.readFileSync(memPath, 'utf8');
+    const lines = content.split(/\r?\n/).length;
+    const bytes = fs.statSync(memPath).size;
+    console.log(`${label('Memory:')} .relay/memory.md  (${(bytes / 1024).toFixed(1)} KB, ${lines} lines)`);
+  } else {
+    console.log(`${label('Memory:')} .relay/memory.md  (not found)`);
+  }
+
+  // Watermark / distiller state
+  const watermarkPath = path.join(relayDir, 'state', 'watermark.json');
+  const logPath = path.join(relayDir, 'log');
+  if (fs.existsSync(watermarkPath)) {
+    let state = {};
+    try { state = JSON.parse(fs.readFileSync(watermarkPath, 'utf8')); } catch {}
+
+    if (state.last_distilled_at) {
+      const ago = Math.round((Date.now() - state.last_distilled_at) / 60_000);
+      console.log(`${label('Distilled:')} ${new Date(state.last_distilled_at).toISOString()} (${ago} min ago)`);
+    } else {
+      console.log(`${label('Distilled:')} never`);
+    }
+
+    if (state.last_uuid) {
+      console.log(`${label('Last UUID:')} ${state.last_uuid}`);
+    }
+
+    const turns = state.turns_since_distill ?? 0;
+    const threshold = parseInt(process.env.RELAY_TURNS_THRESHOLD ?? '5', 10);
+    const progressLine = state.distiller_running
+      ? `${turns} turns (distilling now...)`
+      : `${turns} / ${threshold} turns until next distill`;
+    console.log(`${label('Progress:')} ${progressLine}`);
+
+    if (state.last_transcript) {
+      console.log(`${label('Transcript:')} ${state.last_transcript}`);
+    }
+  } else {
+    console.log(`${label('Progress:')} (no state yet — run a session to start tracking)`);
+  }
+  const inj = getLastInjection(logPath);
+  if (inj) {
+    const ago = Math.round((Date.now() - inj.ts) / 60_000);
+    console.log(`${label('Injected:')} ${new Date(inj.ts).toISOString()} (${ago} min ago via ${inj.event})`);
+  } else {
+    console.log(`${label('Injected:')} never`);
+  }
+
+  // Git remote
+  try {
+    const r = spawnSync('git', ['remote', 'get-url', 'origin'], {
+      cwd: targetDir,
+      encoding: 'utf8',
+      windowsHide: true,
+    });
+    const remote = (r.stdout || '').trim();
+    if (r.status === 0 && remote) {
+      console.log(`${label('Remote:')} origin → ${remote}`);
+    } else {
+      console.log(`${label('Remote:')} (none configured)`);
+    }
+  } catch {
+    console.log(`${label('Remote:')} (none configured)`);
+  }
+
+  // Only show lock when held — not held is the normal state, not worth showing
+  const lockPath = path.join(relayDir, 'state', '.lock');
+  if (fs.existsSync(lockPath)) {
+    try {
+      const age = Math.round((Date.now() - fs.statSync(lockPath).mtimeMs) / 1000);
+      console.log(`${label('Lock:')} held (${age}s old)`);
+    } catch {
+      console.log(`${label('Lock:')} held`);
+    }
+  }
+}
+
+export async function relayDistill(targetDir, argv) {
+  const relayDir = path.join(targetDir, '.relay');
+
+  if (!fs.existsSync(relayDir)) {
+    console.error('Relay not initialized. Run: relay init');
+    process.exit(1);
+  }
+
+  // Parse flags
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--force') { flags.force = true; continue; }
+    if (a === '--dry-run') { flags.dryRun = true; continue; }
+    if (a === '--push') { flags.push = true; continue; }
+    if (a === '--transcript' && argv[i + 1]) { flags.transcript = argv[++i]; continue; }
+  }
+
+  // Resolve transcript path
+  let transcriptPath = flags.transcript;
+  if (!transcriptPath) {
+    const watermarkPath = path.join(relayDir, 'state', 'watermark.json');
+    try {
+      const state = JSON.parse(fs.readFileSync(watermarkPath, 'utf8'));
+      transcriptPath = state.last_transcript;
+    } catch {}
+  }
+
+  if (!transcriptPath) {
+    console.error('No transcript found. Start a Claude Code session in this repo first, or pass --transcript <path>.');
+    process.exit(1);
+  }
+
+  const memoryPath = path.join(relayDir, 'memory.md');
+  const distillerPath = path.join(__dirname, '..', 'distiller.mjs');
+
+  const args = [
+    distillerPath,
+    '--transcript', transcriptPath,
+    '--memory', memoryPath,
+    '--out', memoryPath,
+    '--cwd', targetDir,
+  ];
+  if (flags.force) args.push('--force');
+  if (flags.dryRun) args.push('--dry-run');
+
+  const result = spawnSync('node', args, { stdio: 'inherit' });
+
+  if (flags.push && result.status === 0 && !flags.dryRun) {
+    const { GitSync } = await import('../lib/sync.mjs');
+    const sync = new GitSync();
+    let release = () => {};
+    try { release = sync.lock(targetDir); } catch (e) {
+      if (e.message !== 'LOCKED') console.error(`relay distill: lock error: ${e.message}`);
+      else console.error('relay distill: sync locked by another process — retry in a moment');
+      // M1: exit 2 so callers can detect that push was skipped (not conflated with success)
+      process.exit(2);
+    }
+    try {
+      sync.push(targetDir, 'manual');
+    } catch (e) {
+      console.error(`relay distill: push failed: ${e.message}`);
+    } finally {
+      release();
+    }
+  }
+
+  process.exit(result.status ?? 0);
+}
+
+export function relayBroadcastSkill(targetDir, filePath) {
+  const relayDir = path.join(targetDir, '.relay');
+
+  if (!fs.existsSync(relayDir)) {
+    console.error('Relay not initialized. Run: relay init');
+    return null;
+  }
+
+  if (!filePath) {
+    console.error('Usage: relay broadcast-skill <file>');
+    return null;
+  }
+
+  if (!fs.existsSync(filePath)) {
+    console.error(`File not found: ${filePath}`);
+    return null;
+  }
+
+  const skillName = path.basename(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+  const TEXT_EXTS = new Set(['.md', '.toml', '.txt', '.json', '.yaml', '.yml']);
+  if (!TEXT_EXTS.has(ext)) {
+    console.warn(`Warning: "${skillName}" has extension "${ext}" — expected a text skill file (.md, .toml). Proceeding anyway.`);
+  }
+
+  const destDir = path.join(relayDir, 'broadcast', 'skills');
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const destPath = path.join(destDir, skillName);
+  fs.copyFileSync(filePath, destPath);
+  console.log(`Broadcast: .relay/broadcast/skills/${skillName}`);
+  return destPath;
+}
+
+const HELP_TEXT =
+  `Usage: relay <command>\n\nCommands:\n` +
+  `  init              Initialize relay in current repository\n` +
+  `  status            Show memory, watermark, and sync state\n` +
+  `  log               Show distiller log [--lines <n>] (default 50)\n` +
+  `  distill           Run distiller manually [--transcript <path>] [--force] [--dry-run] [--push]\n` +
+  `  broadcast-skill   Broadcast a skill file to all teammates [<file>]\n` +
+  `  install           Install relay hooks on this machine [--from-local <path>] [--home <path>]\n` +
+  `  update            Update relay to latest version\n` +
+  `  uninstall         Remove relay hooks from this machine [--yes]\n` +
+  `  doctor            Verify relay install is working correctly\n\n` +
+  `Options:\n` +
+  `  --version         Print relay version\n` +
+  `  --help            Show this help`;
+
+export function relayVersion() {
+  const pkgPath = path.join(__dirname, '..', 'package.json');
+  try {
+    const { version } = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    console.log(`relay ${version}`);
+  } catch {
+    console.log('relay (unknown version)');
+  }
+}
+
+export function relayLog(targetDir, argv) {
+  const logPath = path.join(targetDir, '.relay', 'log');
+
+  let lines = 50;
+  for (let i = 0; i < argv.length; i++) {
+    if ((argv[i] === '--lines' || argv[i] === '-n') && argv[i + 1]) {
+      const n = parseInt(argv[++i], 10);
+      if (!isNaN(n) && n > 0) lines = n;
+      else if (!isNaN(n)) console.error(`relay log: --lines must be a positive integer (got ${n}), using default ${lines}`);
+    }
+  }
+
+  if (!fs.existsSync(logPath)) {
+    console.log('No log yet — distiller has not run in this repo.');
+    return;
+  }
+
+  const content = fs.readFileSync(logPath, 'utf8');
+  const allLines = content.split(/\r?\n/);
+  // Drop trailing empty line from final newline
+  if (allLines.length > 0 && allLines[allLines.length - 1] === '') allLines.pop();
+
+  if (allLines.length === 0) {
+    console.log('Log is empty.');
+    return;
+  }
+
+  const tail = allLines.slice(-lines);
+  if (allLines.length > lines) {
+    console.log(`... (${allLines.length - lines} earlier lines omitted — use --lines to show more)\n`);
+  }
+  const inj = getLastInjection(logPath);
+  if (inj) {
+    const ago = Math.round((Date.now() - inj.ts) / 60_000);
+    console.log(`Last injected: ${new Date(inj.ts).toISOString()} (${ago} min ago via ${inj.event})\n`);
+  }
+  console.log(tail.join('\n'));
+}
+
+function getLastInjection(logPath) {
+  if (!fs.existsSync(logPath)) return null;
+  const lines = fs.readFileSync(logPath, 'utf8').split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line) continue;
+    const m = line.match(/^\[([^\]]+)\]\s+injection:\s+([a-z0-9-]+)\s*$/i);
+    if (!m) continue;
+    const ts = Date.parse(m[1]);
+    if (!isNaN(ts)) return { ts, event: m[2] };
+  }
+  return null;
+}
+
+if (isMain(import.meta.url)) {
+  const [, , command, ...rest] = process.argv;
+
+  if (command === '--version' || command === '-v') {
+    relayVersion();
+  } else if (command === '--help' || command === '-h') {
+    console.log(HELP_TEXT);
+  } else if (command === 'init') {
+    relayInit(process.cwd());
+  } else if (command === 'status') {
+    relayStatus(process.cwd());
+  } else if (command === 'log') {
+    relayLog(process.cwd(), rest);
+  } else if (command === 'distill') {
+    await relayDistill(process.cwd(), rest);
+  } else if (command === 'broadcast-skill') {
+    const filePath = rest[0];
+    const dest = relayBroadcastSkill(process.cwd(), filePath);
+    if (!dest) process.exit(1);
+    const { GitSync } = await import('../lib/sync.mjs');
+    const sync = new GitSync();
+    let release = () => {};
+    try {
+      release = sync.lock(process.cwd());
+    } catch (e) {
+      if (e.message === 'LOCKED') {
+        console.error('relay: sync locked by another process');
+        process.exit(2);
+      }
+      throw e;
+    }
+    try {
+      sync.push(process.cwd(), 'broadcast');
+      console.log('Pushed to remote.');
+    } catch (e) {
+      console.error(`relay: push failed: ${e.message}`);
+      process.exit(1);
+    } finally {
+      release();
+    }
+  } else if (command === 'install' || command === 'update' || command === 'uninstall' || command === 'doctor') {
+    const { main: installerMain } = await import('../scripts/installer.mjs');
+    await installerMain([command, ...rest]);
+  } else if (command === undefined) {
+    console.log(HELP_TEXT);
+  } else {
+    console.error(`relay: unknown command '${command}'\n\n${HELP_TEXT}`);
+    process.exit(1);
+  }
+}

package/commands/relay-handoff.toml

@@ -0,0 +1,28 @@
+description = "Write a handoff note to .relay/memory.md and push to teammates"
+prompt = """
+Help the user write a Relay handoff note so teammates pick up where they left off.
+
+Steps:
+1. Ask the user: "What should teammates know when they pick this up? (Press Enter to write a timestamp-only note.)"
+2. Read the current contents of .relay/memory.md.
+3. Get the current UTC time by running: node -e "console.log(new Date().toISOString())" — use the output as the timestamp.
+4. Build the handoff entry:
+   - If the user provided text: "- [<timestamp>] <user text>"
+   - If the user pressed Enter / provided nothing: "- [<timestamp>] (session handoff — no note)"
+5. If a "## Handoff notes" section already exists in memory.md, prepend the new entry as the first bullet under that heading (newest-first order).
+   If no such section exists, prepend the following to the top of the file:
+   "## Handoff notes\n<entry>\n\n"
+6. Write atomically: write the full updated content to .relay/memory.md.tmp, then rename it to .relay/memory.md.
+7. Run: node bin/relay.mjs distill --push
+   If that errors with "No transcript found", fall back to these steps (handle conflicts):
+   a. git add .relay/memory.md
+   b. git commit -m "[relay] handoff note"
+   c. git push
+   d. If git push fails with "non-fast-forward" or "rejected":
+      git fetch && git reset --mixed FETCH_HEAD
+      git add .relay/memory.md
+      git commit -m "[relay] handoff note"
+      git push
+   e. If push still fails, tell the user: "Push failed — remote has diverged. Run 'relay status' to diagnose, then re-run /relay-handoff."
+8. Confirm to the user: "Handoff note written and pushed. Teammates will see it at their next SessionStart."
+"""

package/distiller.mjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { spawn } from 'node:child_process';
+import {
+  readTranscriptLines,
+  sliceSinceUuid,
+  renderForDistiller,
+  lastUuid,
+} from './lib/transcript.mjs';
+import { readMemory, writeMemoryAtomic } from './lib/memory.mjs';
+import { hasTier0Signal } from './lib/filter.mjs';
+import { GitSync } from './lib/sync.mjs';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const CLAUDE_TIMEOUT_MS = 120_000;
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith('--')) continue;
+    const key = a.slice(2);
+    const val = argv[i + 1];
+    if (!val || val.startsWith('--')) {
+      out[key] = true;
+    } else {
+      out[key] = val;
+      i++;
+    }
+  }
+  return out;
+}
+
+function usage() {
+  console.error(
+    `Usage: distiller.mjs --transcript <path> --memory <path> --out <path>` +
+    ` [--since <uuid>] [--cwd <dir>] [--limit <n>] [--model <id>] [--dry-run]`
+  );
+  process.exit(2);
+}
+
+function buildPrompt({ systemPrompt, sessionId, existingMemory, transcriptSlice }) {
+  return (
+    systemPrompt +
+    `\n\n<session-id>${sessionId || 'unknown'}</session-id>\n\n` +
+    `<existing-memory>\n${existingMemory || '(empty — first distillation)'}\n</existing-memory>\n\n` +
+    `<transcript-slice>\n${transcriptSlice}\n</transcript-slice>\n`
+  );
+}
+
+function runClaude(prompt, model) {
+  return new Promise((resolve, reject) => {
+    const claudeArgs = [
+      '-p',
+      '--bare',
+      '--no-session-persistence',
+      '--tools', '',   // empty string = no tools; --bare doesn't disable tools
+      '--output-format', 'text',
+      '--max-budget-usd', '1.00',
+    ];
+    if (model) claudeArgs.push('--model', model);
+
+    // Windows: use cmd /c to invoke claude without shell:true (avoids injection surface)
+    const [exe, args] = process.platform === 'win32'
+      ? ['cmd', ['/c', 'claude', ...claudeArgs]]
+      : ['claude', claudeArgs];
+
+    let proc;
+    try {
+      proc = spawn(exe, args, {
+        windowsHide: true,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (e) {
+      return reject(new Error(`failed to spawn claude: ${e.message}. Is claude CLI on PATH?`));
+    }
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+      reject(new Error(`claude subprocess timed out after ${CLAUDE_TIMEOUT_MS}ms`));
+    }, CLAUDE_TIMEOUT_MS);
+
+    proc.stdout.on('data', (c) => (stdout += c.toString()));
+    proc.stderr.on('data', (c) => (stderr += c.toString()));
+    proc.on('error', (e) => {
+      clearTimeout(timer);
+      reject(new Error(`claude spawn error: ${e.message}. Is claude CLI on PATH?`));
+    });
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      if (timedOut) return;
+      if (code !== 0) {
+        reject(new Error(`claude exited with code ${code}\n${stderr}`));
+      } else {
+        resolve(stdout);
+      }
+    });
+
+    proc.stdin.end(prompt, 'utf8');
+  });
+}
+
+// Intentionally not imported from stop.mjs — distiller runs detached and must be self-contained.
+function writeWatermark(cwd, uuid, { clearRunning = false, transcript = '' } = {}) {
+  if (!cwd) return;
+  const statePath = path.join(cwd, '.relay', 'state', 'watermark.json');
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  let state = {};
+  try { state = JSON.parse(fs.readFileSync(statePath, 'utf8')); } catch {}
+  if (uuid) {
+    state.last_uuid = uuid;
+    state.last_distilled_at = Date.now();
+  }
+  if (transcript) state.last_transcript = transcript;
+  if (clearRunning) {
+    delete state.distiller_running;
+    delete state.distiller_pid; // clear stale PID alongside the flag
+  }
+  const tmp = `${statePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+  // Retry loop matches writeWatermarkAtomic in stop.mjs — EPERM/EBUSY transient on Windows
+  let lastErr;
+  for (let i = 0; i < 3; i++) {
+    try { fs.renameSync(tmp, statePath); return; } catch (e) {
+      lastErr = e;
+      if (e.code !== 'EPERM' && e.code !== 'EBUSY') break;
+    }
+  }
+  try { fs.unlinkSync(tmp); } catch {}
+  throw lastErr;
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (!args.transcript || !args.memory || !args.out) usage();
+
+  const transcriptPath = args.transcript;
+  const memoryPath = args.memory;
+  const outPath = args.out;
+  const since = args.since && args.since !== 'true' ? args.since : '';
+  const cwd = args.cwd && args.cwd !== 'true' ? args.cwd : '';
+  const model = args.model && args.model !== 'true' ? args.model : 'claude-haiku-4-5-20251001';
+  const dryRun = !!args['dry-run'];
+  const force = !!args['force'];
+
+  // --limit applies to raw lines before --since slice; useful for A/B testing only.
+  // Chunk 3 wiring uses --since and omits --limit.
+  const limit = args.limit && args.limit !== 'true' ? parseInt(args.limit, 10) : 0;
+
+  if (!fs.existsSync(transcriptPath)) {
+    console.error(`transcript not found: ${transcriptPath}`);
+    process.exit(1);
+  }
+
+  const promptPath = path.join(__dirname, 'prompts', 'distill.md');
+  const systemPrompt = fs.readFileSync(promptPath, 'utf8');
+
+  const lines = await readTranscriptLines(transcriptPath);
+  const limited = limit > 0 ? lines.slice(0, limit) : lines;
+  const sliced = sliceSinceUuid(limited, since);
+  const transcriptSlice = renderForDistiller(sliced);
+
+  if (!transcriptSlice.trim()) {
+    console.error('empty transcript slice; nothing to distill');
+    // Write watermark to end of limited lines so next run advances correctly
+    const endUuid = lastUuid(limited) || lastUuid(lines);
+    if (endUuid) writeWatermark(cwd, endUuid, { clearRunning: true });
+    process.exit(0);
+  }
+
+  const existingMemory = readMemory(memoryPath);
+
+  // Use session id from transcript; fall back to filename-derived id to avoid
+  // empty provenance tags ([session , turn n]) in distilled memory entries.
+  const rawSessionId = (lines.find((l) => l && l.sessionId) || {}).sessionId || '';
+  const sessionId = rawSessionId.slice(0, 8) ||
+    path.basename(transcriptPath, '.jsonl').slice(0, 8);
+
+  const fullPrompt = buildPrompt({
+    systemPrompt,
+    sessionId,
+    existingMemory,
+    transcriptSlice,
+  });
+
+  if (dryRun) {
+    process.stdout.write(fullPrompt);
+    return;
+  }
+
+  // Tier 0: skip API call if slice has no actionable signal (bypass with --force)
+  if (!force && !hasTier0Signal(transcriptSlice, sliced)) {
+    console.error('distiller: low-signal session; skipping distillation');
+    const endUuid = lastUuid(sliced) || lastUuid(limited) || lastUuid(lines);
+    writeWatermark(cwd, endUuid, { clearRunning: true });
+    process.exit(0);
+  }
+
+  console.error(
+    `distiller: transcript=${transcriptPath} lines=${lines.length}` +
+    ` slice_chars=${transcriptSlice.length} memory_chars=${existingMemory.length} model=${model}`
+  );
+
+  try {
+    const newMemory = await runClaude(fullPrompt, model);
+    const cleaned = newMemory.trim() + '\n';
+    writeMemoryAtomic(outPath, cleaned);
+
+    const newLastUuid = lastUuid(sliced) || lastUuid(limited) || lastUuid(lines);
+    writeWatermark(cwd, newLastUuid, { clearRunning: true, transcript: transcriptPath });
+
+    console.error(
+      `distiller: wrote ${outPath} (${cleaned.length} chars). last_uuid=${newLastUuid}`
+    );
+
+    // Sync push (best-effort — failure is logged but never throws)
+    if (cwd) {
+      const sync = new GitSync();
+      let release = () => {};
+      let locked = false;
+      try {
+        release = sync.lock(cwd);
+      } catch (e) {
+        locked = true; // any lock failure → skip push (conservative)
+        const reason = e.message === 'LOCKED' ? 'locked by another process' : `lock error: ${e.message}`;
+        console.error(`distiller: ${reason}, skipping push`);
+      }
+      if (!locked) {
+        try {
+          sync.push(cwd, sessionId);
+        } catch (e) {
+          console.error(`distiller: sync.push error: ${e.message}`);
+        } finally {
+          release();
+        }
+      }
+    }
+  } catch (e) {
+    try { writeWatermark(cwd, null, { clearRunning: true }); } catch {}
+    throw e;
+  }
+}
+
+main().catch((e) => {
+  console.error(`distiller error: ${e && e.stack ? e.stack : e}`);
+  process.exit(1);
+});