start-vibing-stacks 2.22.0 → 2.24.0

package/stacks/_shared/hooks/peers.ts

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+// @sv-version: 1.0.0
+/**
+ * `peers` — CLI for the multi-instance coordination layer.
+ *
+ * Usage:
+ *   peers list                                List active + idle peer sessions.
+ *   peers notify <id-prefix-or-substring> "msg"
+ *                                             Queue a message for that peer.
+ *   peers locks [--minutes 10]                Show files touched in the window.
+ *   peers cleanup                             Remove stale sessions (>1h idle).
+ *
+ * Exit codes:
+ *   0  success (and at least one peer for `list`)
+ *   1  argument / state error
+ *   2  no peers found (for `list`)
+ *
+ * Run:
+ *   npx tsx .claude/hooks/peers.ts <command>
+ */
+
+import { existsSync, readdirSync, readFileSync, renameSync, rmSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import {
+  ACTIVE_MS,
+  IDLE_MS,
+  STALE_MS,
+  ageMs,
+  appendInbox,
+  classifyAge,
+  ensureStateDirs,
+  formatPeer,
+  getProjectDir,
+  getStateDir,
+  listSessionFiles,
+  nowIso,
+  readJsonSafe,
+  shortId,
+  tailFileTouches,
+  type SessionRecord,
+} from './_state.js';
+
+function parseFlag(args: string[], flag: string, fallback?: string): string | undefined {
+  const i = args.indexOf(flag);
+  if (i === -1) return fallback;
+  return args[i + 1];
+}
+
+function loadSessions(stateDir: string): SessionRecord[] {
+  const out: SessionRecord[] = [];
+  for (const file of listSessionFiles(stateDir)) {
+    const rec = readJsonSafe<SessionRecord>(file);
+    if (rec) out.push(rec);
+  }
+  return out;
+}
+
+function findCurrentSessionId(stateDir: string): string | null {
+  const fromEnv = process.env['CLAUDE_SESSION_ID'];
+  if (fromEnv) return fromEnv;
+  const sessions = loadSessions(stateDir).filter(s => ageMs(s.lastSeenAt) < ACTIVE_MS);
+  if (sessions.length === 1) return sessions[0]!.sessionId;
+  return null;
+}
+
+function cmdList(stateDir: string): number {
+  const all = loadSessions(stateDir);
+  const fresh = all.filter(s => ageMs(s.lastSeenAt) < IDLE_MS);
+  if (fresh.length === 0) {
+    console.log('No peer sessions in this project.');
+    return 2;
+  }
+  fresh.sort((a, b) => ageMs(a.lastSeenAt) - ageMs(b.lastSeenAt));
+  console.log(`Sessions registered for ${getProjectDir()}:`);
+  for (const s of fresh) console.log(`  ${formatPeer(s)}`);
+  return 0;
+}
+
+function cmdNotify(stateDir: string, args: string[]): number {
+  if (args.length < 2) {
+    console.error('Usage: peers notify <id-prefix-or-title-substring> "<message>"');
+    return 1;
+  }
+  const target = args[0]!;
+  const message = args.slice(1).join(' ');
+  if (!message.trim()) {
+    console.error('Empty message — nothing to send.');
+    return 1;
+  }
+
+  const all = loadSessions(stateDir).filter(s => ageMs(s.lastSeenAt) < STALE_MS);
+  const matches = all.filter(s => {
+    if (s.sessionId.startsWith(target)) return true;
+    if (s.title && s.title.toLowerCase().includes(target.toLowerCase())) return true;
+    return false;
+  });
+
+  if (matches.length === 0) {
+    console.error(`No peer session matches "${target}". Run \`peers list\`.`);
+    return 1;
+  }
+
+  if (matches.length > 1) {
+    console.error(`Ambiguous target "${target}" — ${matches.length} matches:`);
+    for (const m of matches) console.error(`  - ${formatPeer(m)}`);
+    console.error('Use a longer id prefix to disambiguate.');
+    return 1;
+  }
+
+  const target_ = matches[0]!;
+  const fromSessionId = findCurrentSessionId(stateDir) || 'cli';
+  const fromTitle = loadSessions(stateDir).find(s => s.sessionId === fromSessionId)?.title;
+
+  appendInbox(stateDir, target_.sessionId, {
+    ts: nowIso(),
+    fromSessionId,
+    fromTitle,
+    message,
+  });
+  console.log(`Queued message for ${shortId(target_.sessionId)} "${target_.title}".`);
+  return 0;
+}
+
+function cmdLocks(stateDir: string, args: string[]): number {
+  const minutes = Number(parseFlag(args, '--minutes', '10') || '10');
+  if (!Number.isFinite(minutes) || minutes <= 0) {
+    console.error('--minutes must be a positive number.');
+    return 1;
+  }
+  const windowMs = minutes * 60 * 1000;
+  const touches = tailFileTouches(stateDir, 1000).filter(t => ageMs(t.ts) <= windowMs);
+  if (touches.length === 0) {
+    console.log(`No file touches in the last ${minutes}min.`);
+    return 0;
+  }
+
+  const sessions = loadSessions(stateDir);
+  const sessById = new Map(sessions.map(s => [s.sessionId, s]));
+
+  type Row = { file: string; sessionId: string; ts: string; tool: string };
+  const byFile = new Map<string, Row>();
+  for (const t of touches) {
+    const prev = byFile.get(t.file);
+    if (!prev || Date.parse(t.ts) > Date.parse(prev.ts)) {
+      byFile.set(t.file, { file: t.file, sessionId: t.sessionId, ts: t.ts, tool: t.tool });
+    }
+  }
+
+  const rows = [...byFile.values()].sort(
+    (a, b) => Date.parse(b.ts) - Date.parse(a.ts)
+  );
+
+  console.log(`File touches in the last ${minutes}min (most-recent first):`);
+  for (const r of rows) {
+    const sess = sessById.get(r.sessionId);
+    const klass = sess ? classifyAge(ageMs(sess.lastSeenAt)) : 'gone';
+    const who = sess ? `${shortId(sess.sessionId)} "${sess.title}"` : `${shortId(r.sessionId)}(gone)`;
+    const ageSec = Math.round(ageMs(r.ts) / 1000);
+    console.log(`  ${r.file}  <-  ${who} [${klass}] via ${r.tool}, ${ageSec}s ago`);
+  }
+  return 0;
+}
+
+function cmdCleanup(stateDir: string): number {
+  ensureStateDirs(stateDir);
+  let archived = 0;
+  let removed = 0;
+  for (const file of listSessionFiles(stateDir)) {
+    const rec = readJsonSafe<SessionRecord>(file);
+    if (!rec) continue;
+    const age = ageMs(rec.lastSeenAt);
+    if (age > STALE_MS) {
+      try {
+        rmSync(file);
+        removed++;
+      } catch {}
+    } else if (age > IDLE_MS) {
+      try {
+        const dest = join(stateDir, 'sessions', '_archive', basename(file));
+        renameSync(file, dest);
+        archived++;
+      } catch {}
+    }
+  }
+
+  // Drop empty inbox files older than 7 days.
+  const inboxDir = join(stateDir, 'inbox');
+  if (existsSync(inboxDir)) {
+    try {
+      for (const f of readdirSync(inboxDir)) {
+        const p = join(inboxDir, f);
+        try {
+          const s = statSync(p);
+          if (s.size === 0 && Date.now() - s.mtimeMs > 7 * 24 * 60 * 60 * 1000) {
+            rmSync(p);
+          } else if (s.size > 0) {
+            const lines = readFileSync(p, 'utf8').split('\n').filter(Boolean);
+            if (lines.length === 0) rmSync(p);
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  console.log(`Cleanup done. Archived: ${archived}. Removed: ${removed}.`);
+  return 0;
+}
+
+function usage(): void {
+  console.log(`peers — multi-instance coordination CLI
+
+Commands:
+  peers list
+  peers notify <id-prefix-or-title-substring> "<message>"
+  peers locks [--minutes 10]
+  peers cleanup
+`);
+}
+
+function main(): void {
+  const [, , cmd, ...rest] = process.argv;
+  const stateDir = getStateDir();
+
+  switch (cmd) {
+    case 'list':
+      process.exit(cmdList(stateDir));
+      break;
+    case 'notify':
+      process.exit(cmdNotify(stateDir, rest));
+      break;
+    case 'locks':
+      process.exit(cmdLocks(stateDir, rest));
+      break;
+    case 'cleanup':
+      process.exit(cmdCleanup(stateDir));
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      usage();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      usage();
+      process.exit(1);
+  }
+}
+
+main();

package/stacks/_shared/hooks/post-tool-use.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// @sv-version: 1.0.0
+/**
+ * PostToolUse Hook — Multi-Instance Coordination
+ *
+ * Wired with matcher `Edit|Write|MultiEdit|NotebookEdit`. Runs AFTER a write
+ * succeeds. Responsibilities:
+ *  1. Append a `FileTouch` record to `.claude/state/file-touches.jsonl`.
+ *  2. Update the session's heartbeat + `filesTouched` (capped at 50, deduped).
+ *
+ * On any internal error the hook exits silently — coordination must NEVER
+ * disturb Claude after a successful tool call.
+ */
+
+import {
+  FILES_TOUCHED_CAP,
+  ensureStateDirs,
+  extractTargetFiles,
+  getProjectDir,
+  getStateDir,
+  heartbeat,
+  nowIso,
+  readSession,
+  readStdinJson,
+  recordFileTouch,
+} from './_state.js';
+
+async function main(): Promise<void> {
+  const input = await readStdinJson(1500);
+  const sessionId: string | undefined = input.session_id || input.sessionId;
+  const toolName: string = input.tool_name || input.toolName || '';
+  const toolInput: any = input.tool_input || input.toolInput || {};
+  const toolResponse: any = input.tool_response || input.toolResponse;
+
+  if (!sessionId || !/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(toolName)) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  // Some tool responses surface a `success: false` — do not record those.
+  if (toolResponse && typeof toolResponse === 'object' && toolResponse.success === false) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  const projectDir = getProjectDir();
+  const stateDir = getStateDir(projectDir);
+  ensureStateDirs(stateDir);
+
+  const targets = extractTargetFiles(toolName, toolInput, projectDir);
+  const ts = nowIso();
+  for (const file of targets) {
+    recordFileTouch(stateDir, { ts, sessionId, tool: toolName, file });
+  }
+
+  const session = readSession(stateDir, sessionId);
+  const previous = session?.filesTouched || [];
+  const merged = dedupeKeepLast([...previous, ...targets], FILES_TOUCHED_CAP);
+  heartbeat(stateDir, sessionId, `PostToolUse:${toolName}`, { filesTouched: merged });
+
+  console.log(JSON.stringify({ continue: true }));
+}
+
+function dedupeKeepLast(items: string[], cap: number): string[] {
+  const seen = new Set<string>();
+  const reversed: string[] = [];
+  for (let i = items.length - 1; i >= 0; i--) {
+    const x = items[i]!;
+    if (seen.has(x)) continue;
+    seen.add(x);
+    reversed.push(x);
+    if (reversed.length >= cap) break;
+  }
+  return reversed.reverse();
+}
+
+main().catch(() => {
+  console.log(JSON.stringify({ continue: true }));
+  process.exit(0);
+});

package/stacks/_shared/hooks/pre-tool-use.ts

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+// @sv-version: 1.0.0
+/**
+ * PreToolUse Hook — Multi-Instance Coordination
+ *
+ * Wired with matcher `Edit|Write|MultiEdit|NotebookEdit`. Reads the file-touches
+ * log + active peer sessions and decides:
+ *
+ *  - BLOCK if a peer is currently ACTIVE (heartbeat < 60s) AND touched the same
+ *    file within the last 5 minutes. The reason explains how to recover.
+ *  - WARN (approve + systemMessage) if a peer touched the file recently but is
+ *    only IDLE (60s — 5min).
+ *  - APPROVE silently otherwise.
+ *
+ * Hook input:
+ *   { session_id, tool_name, tool_input, hook_event_name, ... }
+ *
+ * Output schema (JSON):
+ *   { decision?: 'block', reason?: string, continue: true, systemMessage?: string }
+ *
+ * On any internal error, the hook approves silently — coordination must NEVER
+ * break Claude.
+ */
+
+import {
+  ACTIVE_MS,
+  COLLISION_WINDOW_MS,
+  ageMs,
+  classifyAge,
+  ensureStateDirs,
+  extractTargetFiles,
+  getProjectDir,
+  getStateDir,
+  heartbeat,
+  listPeerSessions,
+  readStdinJson,
+  shortId,
+  tailFileTouches,
+  type FileTouch,
+  type SessionRecord,
+} from './_state.js';
+
+interface Verdict {
+  block: boolean;
+  reason?: string;
+  warning?: string;
+}
+
+function evaluate(
+  targetFiles: string[],
+  peers: SessionRecord[],
+  touches: FileTouch[],
+  selfSessionId: string
+): Verdict {
+  if (targetFiles.length === 0) return { block: false };
+
+  const peerById = new Map<string, SessionRecord>();
+  for (const p of peers) peerById.set(p.sessionId, p);
+
+  // Most-recent peer touch per (file).
+  const recent = new Map<string, FileTouch>();
+  for (const t of touches) {
+    if (t.sessionId === selfSessionId) continue;
+    if (!targetFiles.includes(t.file)) continue;
+    if (ageMs(t.ts) > COLLISION_WINDOW_MS) continue;
+    const prev = recent.get(t.file);
+    if (!prev || Date.parse(t.ts) > Date.parse(prev.ts)) recent.set(t.file, t);
+  }
+
+  if (recent.size === 0) return { block: false };
+
+  const blockers: string[] = [];
+  const warns: string[] = [];
+
+  for (const [file, touch] of recent) {
+    const peer = peerById.get(touch.sessionId);
+    const peerActive = peer && ageMs(peer.lastSeenAt) < ACTIVE_MS;
+    const touchAgeSec = Math.round(ageMs(touch.ts) / 1000);
+    const peerLabel = peer
+      ? `${shortId(peer.sessionId)} "${peer.title}"${peer.gitBranch ? ` @${peer.gitBranch}` : ''}`
+      : `${shortId(touch.sessionId)} (session record gone)`;
+
+    if (peerActive) {
+      blockers.push(
+        `  - ${file}\n    last touched ${touchAgeSec}s ago by peer ${peerLabel} (HEARTBEAT ACTIVE)`
+      );
+    } else {
+      const klass = peer ? classifyAge(ageMs(peer.lastSeenAt)) : 'stale';
+      warns.push(
+        `  - ${file}: peer ${peerLabel} (${klass}) touched it ${touchAgeSec}s ago`
+      );
+    }
+  }
+
+  if (blockers.length > 0) {
+    const reason =
+      `BLOCKED by multi-instance coordination — another active Claude session is editing the same file.\n` +
+      `Active collision(s):\n${blockers.join('\n')}\n\n` +
+      `Recommended actions:\n` +
+      `  1. Run \`npx tsx .claude/hooks/peers.ts list\` to see who is active.\n` +
+      `  2. Notify them: \`npx tsx .claude/hooks/peers.ts notify <id-prefix> "I need to edit <file>, can you commit/stash?"\`\n` +
+      `  3. Wait for them to commit, then retry — or have them call \`peers.ts cleanup\` if you confirm they are no longer editing.\n` +
+      `  4. If you must override: re-run the same Edit after 60s of peer inactivity (their heartbeat will go IDLE and the hook will downgrade to a warning).`;
+    return { block: true, reason };
+  }
+
+  if (warns.length > 0) {
+    const warning =
+      `MULTI-INSTANCE WARNING — files you are about to edit were recently touched by an idle peer:\n${warns.join('\n')}\n` +
+      `Edit is allowed (peer is not actively typing). Consider rebasing on their work after they commit.`;
+    return { block: false, warning };
+  }
+
+  return { block: false };
+}
+
+async function main(): Promise<void> {
+  const input = await readStdinJson(1500);
+  const sessionId: string | undefined = input.session_id || input.sessionId;
+  const toolName: string = input.tool_name || input.toolName || '';
+  const toolInput: any = input.tool_input || input.toolInput || {};
+
+  // Defensive: only act on edit-class tools.
+  if (!/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(toolName)) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  const projectDir = getProjectDir();
+  const stateDir = getStateDir(projectDir);
+  ensureStateDirs(stateDir);
+
+  if (sessionId) {
+    heartbeat(stateDir, sessionId, `PreToolUse:${toolName}`);
+  }
+
+  const targetFiles = extractTargetFiles(toolName, toolInput, projectDir);
+  if (targetFiles.length === 0) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  const peers = listPeerSessions(stateDir, sessionId || null);
+  const touches = tailFileTouches(stateDir);
+
+  const verdict = evaluate(targetFiles, peers, touches, sessionId || '');
+
+  if (verdict.block) {
+    console.log(
+      JSON.stringify({
+        continue: true,
+        decision: 'block',
+        reason: verdict.reason,
+      })
+    );
+    return;
+  }
+
+  if (verdict.warning) {
+    console.log(
+      JSON.stringify({
+        continue: true,
+        systemMessage: verdict.warning,
+      })
+    );
+    return;
+  }
+
+  console.log(JSON.stringify({ continue: true }));
+}
+
+main().catch(() => {
+  // Coordination must never block Claude on its own bug.
+  console.log(JSON.stringify({ continue: true }));
+  process.exit(0);
+});

package/stacks/_shared/hooks/run-hook.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.0.0
 /**
  * Universal Hook Runner — Start Vibing Stacks
  *

package/stacks/_shared/hooks/session-start.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+// @sv-version: 1.0.0
+/**
+ * SessionStart Hook — Multi-Instance Coordination
+ *
+ * Runs once per Claude session start. Responsibilities:
+ *  1. Register this session in `.claude/state/sessions/<id>.json`.
+ *  2. Extract a human title from the transcript (matches what `claude --resume` shows).
+ *  3. Scan for peer sessions in the same project; warn if any are active.
+ *  4. Drain the inbox so messages from peers are surfaced in the first prompt.
+ *
+ * Hook input (JSON via stdin):
+ *   { session_id, transcript_path, cwd, hook_event_name, source }
+ *
+ * Output (JSON to stdout):
+ *   { continue: true, systemMessage?: string }
+ */
+
+import {
+  ageMs,
+  appendInbox,
+  drainInbox,
+  ensureStateDirs,
+  extractTitle,
+  formatPeer,
+  getGitBranch,
+  getProjectDir,
+  getStateDir,
+  heartbeat,
+  listPeerSessions,
+  nowIso,
+  readSession,
+  readStdinJson,
+  shortId,
+  type InboxMessage,
+} from './_state.js';
+
+async function main(): Promise<void> {
+  const input = await readStdinJson(1500);
+  const sessionId: string | undefined = input.session_id || input.sessionId;
+  const transcriptPath: string | undefined = input.transcript_path || input.transcriptPath;
+  const projectDir = getProjectDir();
+  const stateDir = getStateDir(projectDir);
+
+  if (!sessionId) {
+    console.log(JSON.stringify({ continue: true }));
+    return;
+  }
+
+  ensureStateDirs(stateDir);
+
+  // Resolve title: prefer the existing record (so we don't lose a real title
+  // captured by user-prompt-submit when the SessionStart event also fires for
+  // a `/resume` flow that already had a title).
+  const existing = readSession(stateDir, sessionId);
+  const title = existing?.title && existing.title !== '(untitled)'
+    ? existing.title
+    : extractTitle(transcriptPath);
+
+  const branch = getGitBranch(projectDir);
+
+  heartbeat(stateDir, sessionId, 'SessionStart', {
+    transcriptPath,
+    title,
+    cwd: projectDir,
+    gitBranch: branch,
+  });
+
+  // Discover peers (active or idle within 30min).
+  const peers = listPeerSessions(stateDir, sessionId);
+
+  // Drain inbox messages addressed to this session.
+  const inbox = drainInbox(stateDir, sessionId);
+
+  const messageParts: string[] = [];
+  messageParts.push(
+    `MULTI-INSTANCE COORDINATION ACTIVE — this Claude session is registered as ${shortId(sessionId)} ("${title}"). State at .claude/state/.`
+  );
+
+  if (peers.length > 0) {
+    messageParts.push('');
+    messageParts.push(`PEERS DETECTED in this project (${peers.length}):`);
+    for (const p of peers) messageParts.push(`  - ${formatPeer(p)}`);
+    const anyActive = peers.some(p => ageMs(p.lastSeenAt) < 60 * 1000);
+    if (anyActive) {
+      messageParts.push('');
+      messageParts.push(
+        'WARNING: at least one peer is ACTIVE right now. Edit/Write of a file ' +
+          'a peer just touched will be BLOCKED by the PreToolUse hook to prevent ' +
+          'overwriting their uncommitted work. Coordinate via `/peers notify <id> "msg"` ' +
+          'before touching shared files.'
+      );
+    } else {
+      messageParts.push('');
+      messageParts.push(
+        'Peers are idle (>60s). Edits will be allowed but you will see a notice if ' +
+          'you touch files they recently modified.'
+      );
+    }
+  }
+
+  if (inbox.length > 0) {
+    messageParts.push('');
+    messageParts.push(`INBOX (${inbox.length} message${inbox.length === 1 ? '' : 's'} from peers):`);
+    for (const m of inbox) messageParts.push(formatInbox(m));
+  }
+
+  const systemMessage = messageParts.join('\n');
+
+  console.log(JSON.stringify({ continue: true, systemMessage }));
+}
+
+function formatInbox(m: InboxMessage): string {
+  const from = m.fromTitle ? `${shortId(m.fromSessionId)} "${m.fromTitle}"` : shortId(m.fromSessionId);
+  return `  [${m.ts}] from ${from}: ${m.message}`;
+}
+
+main().catch(() => {
+  console.log(JSON.stringify({ continue: true }));
+  process.exit(0);
+});
+
+// Silence unused-import warning when type-only imports are tree-shaken
+void nowIso;
+void appendInbox;

package/stacks/_shared/hooks/stop-validator.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.1.0
 /**
  * Stop Validator Hook — Start Vibing Stacks (Universal)
  *
@@ -15,6 +16,16 @@
 import { execSync } from 'child_process';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
+import {
+  ACTIVE_MS,
+  ageMs,
+  archiveSession,
+  clearInbox,
+  ensureStateDirs,
+  formatPeer,
+  getStateDir,
+  listPeerSessions,
+} from './_state.js';
 
 const PROJECT_DIR = process.env['CLAUDE_PROJECT_DIR'] || process.cwd();
 const CLAUDE_MD = join(PROJECT_DIR, 'CLAUDE.md');
@@ -237,6 +248,33 @@ async function main(): Promise<void> {
   }
 
   const result = validate();
+
+  // Multi-instance coordination side effects.
+  const sessionId: string | undefined = hookInput.session_id || hookInput.sessionId;
+  const eventName: string = hookInput.hook_event_name || hookInput.hookEventName || '';
+  const isSessionEnd = /SessionEnd/i.test(eventName);
+
+  try {
+    const stateDir = getStateDir(PROJECT_DIR);
+    ensureStateDirs(stateDir);
+
+    if (result.decision === 'approve' && sessionId) {
+      const peers = listPeerSessions(stateDir, sessionId);
+      const activePeers = peers.filter(p => ageMs(p.lastSeenAt) < ACTIVE_MS);
+      if (activePeers.length > 0) {
+        const lines = activePeers.map(p => `  - ${formatPeer(p)}`).join('\n');
+        result.reason +=
+          `\n\nNOTE: ${activePeers.length} peer instance(s) still active in this project:\n${lines}\n` +
+          `If you committed and pushed, your work is now visible to them.`;
+      }
+    }
+
+    if (isSessionEnd && sessionId) {
+      archiveSession(stateDir, sessionId);
+      clearInbox(stateDir, sessionId);
+    }
+  } catch {}
+
   console.log(JSON.stringify(result));
   process.exit(0);
 }