xtrm-tools 2.4.2 → 2.4.4

package/hooks/beads-claim-sync.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 // beads-claim-sync — PostToolUse hook
-// Auto-sets kv claim on bd update --claim; auto-clears on bd close.
-// Also bootstraps worktree-first session state for xtrm finish workflow.
+// bd update --claim → set kv claim
+// bd close         → auto-commit staged changes, set closed-this-session kv for memory gate
 
 import { spawnSync } from 'node:child_process';
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { writeSessionState } from './session-state.mjs';
+import { resolveSessionId } from './beads-gate-utils.mjs';
 
 function readInput() {
   try {
@@ -46,103 +46,56 @@ function runGit(args, cwd, timeout = 8000) {
   });
 }
 
-function getRepoRoot(cwd) {
-  const result = runGit(['rev-parse', '--show-toplevel'], cwd);
-  if (result.status !== 0) return null;
-  return result.stdout.trim();
+function runBd(args, cwd, timeout = 5000) {
+  return spawnSync('bd', args, {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    timeout,
+  });
 }
 
-function inLinkedWorktree(cwd) {
-  const gitDir = runGit(['rev-parse', '--git-dir'], cwd);
-  const gitCommonDir = runGit(['rev-parse', '--git-common-dir'], cwd);
-  if (gitDir.status !== 0 || gitCommonDir.status !== 0) return false;
-  return gitDir.stdout.trim() !== gitCommonDir.stdout.trim();
+function hasGitChanges(cwd) {
+  const result = runGit(['status', '--porcelain'], cwd);
+  if (result.status !== 0) return false;
+  return result.stdout.trim().length > 0;
 }
 
-function ensureWorktreeForClaim(cwd, issueId) {
-  const repoRoot = getRepoRoot(cwd);
-  if (!repoRoot) return { created: false, reason: 'not-git' };
+function getCloseReason(cwd, issueId, command) {
+  // 1. Parse --reason "..." from the command itself (fastest, no extra call)
+  const reasonMatch = command.match(/--reason[=\s]+["']([^"']+)["']/);
+  if (reasonMatch) return reasonMatch[1].trim();
 
-  if (inLinkedWorktree(cwd)) {
-    return { created: false, reason: 'already-worktree', repoRoot };
+  // 2. Fall back to bd show <id> --json
+  const show = runBd(['show', issueId, '--json'], cwd);
+  if (show.status === 0 && show.stdout) {
+    try {
+      const parsed = JSON.parse(show.stdout);
+      const reason = parsed?.[0]?.close_reason;
+      if (typeof reason === 'string' && reason.trim().length > 0) return reason.trim();
+    } catch { /* fall through */ }
   }
 
-  const overstoryDir = join(repoRoot, '.overstory');
-  const worktreesBase = existsSync(overstoryDir)
-    ? join(overstoryDir, 'worktrees')
-    : join(repoRoot, '.worktrees');
-
-  mkdirSync(worktreesBase, { recursive: true });
-
-  const branch = `feature/${issueId}`;
-  const worktreePath = join(worktreesBase, issueId);
+  return `Close ${issueId}`;
+}
 
-  if (existsSync(worktreePath)) {
-    // Already created previously — rewrite state file for continuity.
-    try {
-      const stateFile = writeSessionState({
-        issueId,
-        branch,
-        worktreePath,
-        prNumber: null,
-        prUrl: null,
-        phase: 'claimed',
-        conflictFiles: [],
-      }, { cwd: repoRoot });
-      return { created: false, reason: 'exists', repoRoot, branch, worktreePath, stateFile };
-    } catch {
-      return { created: false, reason: 'exists', repoRoot, branch, worktreePath };
-    }
+function autoCommit(cwd, issueId, command) {
+  if (!hasGitChanges(cwd)) {
+    return { ok: true, message: 'No changes detected — auto-commit skipped.' };
   }
 
-  const branchExists = runGit(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], repoRoot).status === 0;
-  const addArgs = branchExists
-    ? ['worktree', 'add', worktreePath, branch]
-    : ['worktree', 'add', worktreePath, '-b', branch];
-
-  const addResult = runGit(addArgs, repoRoot, 20000);
-  if (addResult.status !== 0) {
-    return {
-      created: false,
-      reason: 'create-failed',
-      repoRoot,
-      branch,
-      worktreePath,
-      error: (addResult.stderr || addResult.stdout || '').trim(),
-    };
+  const reason = getCloseReason(cwd, issueId, command);
+  const commitMessage = `${reason} (${issueId})`;
+  const result = runGit(['commit', '-am', commitMessage], cwd, 15000);
+  if (result.status !== 0) {
+    const err = (result.stderr || result.stdout || '').trim();
+    return { ok: false, message: `Auto-commit failed: ${err || 'unknown error'}` };
   }
 
-  try {
-    const stateFile = writeSessionState({
-      issueId,
-      branch,
-      worktreePath,
-      prNumber: null,
-      prUrl: null,
-      phase: 'claimed',
-      conflictFiles: [],
-    }, { cwd: repoRoot });
-
-    return {
-      created: true,
-      reason: 'created',
-      repoRoot,
-      branch,
-      worktreePath,
-      stateFile,
-    };
-  } catch (err) {
-    return {
-      created: true,
-      reason: 'created-state-write-failed',
-      repoRoot,
-      branch,
-      worktreePath,
-      error: String(err?.message || err),
-    };
-  }
+  return { ok: true, message: `Auto-committed: \`${commitMessage}\`` };
 }
 
+
 function main() {
   const input = readInput();
   if (!input || input.hook_event_name !== 'PostToolUse') process.exit(0);
@@ -152,12 +105,7 @@ function main() {
   if (!isBeadsProject(cwd)) process.exit(0);
 
   const command = input.tool_input?.command || '';
-  const sessionId = input.session_id ?? input.sessionId;
-
-  if (!sessionId) {
-    process.stderr.write('Beads claim sync: no session_id in hook input\n');
-    process.exit(0);
-  }
+  const sessionId = resolveSessionId(input);
 
   // Auto-claim: bd update <id> --claim (fire regardless of exit code — bd returns 1 for "already in_progress")
   if (/\bbd\s+update\b/.test(command) && /--claim\b/.test(command)) {
@@ -176,41 +124,39 @@ function main() {
         process.exit(0);
       }
 
-      const wt = ensureWorktreeForClaim(cwd, issueId);
-      const details = [];
-      if (wt.created) {
-        details.push(`🧭 **Session Flow**: Worktree created: \`${wt.worktreePath}\`  Branch: \`${wt.branch}\``);
-      } else if (wt.reason === 'exists') {
-        details.push(`🧭 **Session Flow**: Worktree already exists: \`${wt.worktreePath}\`  Branch: \`${wt.branch}\``);
-      } else if (wt.reason === 'already-worktree') {
-        details.push('🧭 **Session Flow**: Already in a linked worktree — skipping nested worktree creation.');
-      } else if (wt.reason === 'create-failed') {
-        const err = wt.error ? `\nWarning: ${wt.error}` : '';
-        details.push(`⚠️ **Session Flow**: Worktree creation failed for \`${issueId}\`. Continuing without blocking claim.${err}`);
-      }
-
       process.stdout.write(JSON.stringify({
-        additionalContext: `\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`.${details.length ? `\n${details.join('\n')}` : ''}`,
+        additionalContext: `\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`.`,
       }));
       process.stdout.write('\n');
       process.exit(0);
     }
   }
 
-  // Auto-clear: bd close <id> — remove the kv claim so commit gate unblocks
+  // On bd close: auto-commit staged changes, then mark closed-this-session for memory gate
   if (/\bbd\s+close\b/.test(command) && commandSucceeded(input)) {
-    const result = spawnSync('bd', ['kv', 'clear', `claimed:${sessionId}`], {
-      cwd,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 5000,
-    });
+    const match = command.match(/\bbd\s+close\s+(\S+)/);
+    const closedIssueId = match?.[1];
 
-    if (result.status === 0) {
-      process.stdout.write(JSON.stringify({
-        additionalContext: `\n🔓 **Beads**: Session claim cleared. Ready to commit.`,
-      }));
-      process.stdout.write('\n');
+    // Auto-commit before marking the gate (no-op if clean)
+    const commit = closedIssueId ? autoCommit(cwd, closedIssueId, command) : null;
+
+    // Mark this issue as closed this session (memory gate reads this)
+    if (closedIssueId) {
+      spawnSync('bd', ['kv', 'set', `closed-this-session:${sessionId}`, closedIssueId], {
+        cwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 5000,
+      });
     }
+
+    const commitLine = commit
+      ? `\n${commit.ok ? '✅' : '⚠️'} **Session Flow**: ${commit.message}`
+      : '';
+
+    process.stdout.write(JSON.stringify({
+      additionalContext: `\n🔓 **Beads**: Issue closed.${commitLine}\nEvaluate insights, then acknowledge:\n  \`bd remember "<insight>"\` (or note "nothing")\n  \`touch .beads/.memory-gate-done\``,
+    }));
+    process.stdout.write('\n');
     process.exit(0);
   }
 

package/hooks/beads-commit-gate.mjs

@@ -13,20 +13,35 @@ import {
   resolveClaimAndWorkState,
   decideCommitGate,
 } from './beads-gate-core.mjs';
-import { withSafeBdContext } from './beads-gate-utils.mjs';
-import { commitBlockMessage } from './beads-gate-messages.mjs';
+import { withSafeBdContext, isMemoryGatePending, isMemoryAckCommand } from './beads-gate-utils.mjs';
+import { commitBlockMessage, memoryGatePendingMessage } from './beads-gate-messages.mjs';
 
 const input = readHookInput();
 if (!input) process.exit(0);
 
-// Only intercept git commit commands
 if ((input.tool_name ?? '') !== 'Bash') process.exit(0);
-if (!/\bgit\s+commit\b/.test(input.tool_input?.command ?? '')) process.exit(0);
+
+const command = input.tool_input?.command ?? '';
+// Strip quoted strings to avoid matching patterns inside --reason "..." or similar args
+const commandUnquoted = command.replace(/'[^']*'|"[^"]*"/g, '');
 
 withSafeBdContext(() => {
   const ctx = resolveSessionContext(input);
   if (!ctx || !ctx.isBeadsProject) process.exit(0);
 
+  // Memory gate: block all Bash except acknowledgment commands while gate pending
+  if (ctx.sessionId && isMemoryGatePending(ctx.sessionId, ctx.cwd)) {
+    if (!isMemoryAckCommand(commandUnquoted)) {
+      process.stdout.write(JSON.stringify({ decision: 'block', reason: memoryGatePendingMessage() }));
+      process.stdout.write('\n');
+      process.exit(0);
+    }
+    process.exit(0); // memory-ack command — allow
+  }
+
+  // Only intercept git commit for the claim-gate check
+  if (!/\bgit\s+commit\b/.test(commandUnquoted)) process.exit(0);
+
   const state = resolveClaimAndWorkState(ctx);
   const decision = decideCommitGate(ctx, state);
 

package/hooks/beads-compact-restore.mjs

@@ -7,7 +7,6 @@
 import { execSync } from 'node:child_process';
 import { readFileSync, existsSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
-import { writeSessionState } from './session-state.mjs';
 
 let input;
 try {
@@ -22,14 +21,12 @@ const lastActivePath = path.join(cwd, '.beads', '.last_active');
 if (!existsSync(lastActivePath)) process.exit(0);
 
 let ids = [];
-let sessionState = null;
 
 try {
   const raw = readFileSync(lastActivePath, 'utf8').trim();
   if (raw.startsWith('{')) {
     const parsed = JSON.parse(raw);
     ids = Array.isArray(parsed.ids) ? parsed.ids.filter(Boolean) : [];
-    sessionState = parsed.sessionState ?? null;
   } else {
     // Backward compatibility: legacy newline format
     ids = raw.split('\n').filter(Boolean);
@@ -56,27 +53,8 @@ for (const id of ids) {
   }
 }
 
-let restoredSession = false;
-if (sessionState && typeof sessionState === 'object') {
-  try {
-    writeSessionState(sessionState, { cwd });
-    restoredSession = true;
-  } catch {
-    // fail open
-  }
-}
-
-if (restored > 0 || restoredSession) {
-  const lines = [];
-  if (restored > 0) {
-    lines.push(`Restored ${restored} in_progress issue${restored === 1 ? '' : 's'} from last session before compaction.`);
-  }
-
-  if (restoredSession && (sessionState.phase === 'waiting-merge' || sessionState.phase === 'pending-cleanup')) {
-    const pr = sessionState.prNumber != null ? `#${sessionState.prNumber}` : '(pending PR)';
-    const prUrl = sessionState.prUrl ? ` ${sessionState.prUrl}` : '';
-    lines.push(`RESUME: Run xtrm finish — PR ${pr}${prUrl} waiting for merge. Worktree: ${sessionState.worktreePath}`);
-  }
+if (restored > 0) {
+  const lines = [`Restored ${restored} in_progress issue${restored === 1 ? '' : 's'} from last session before compaction.`];
 
   process.stdout.write(
     JSON.stringify({

package/hooks/beads-compact-save.mjs

@@ -7,7 +7,6 @@
 import { execSync } from 'node:child_process';
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
-import { readSessionState } from './session-state.mjs';
 
 let input;
 try {
@@ -40,38 +39,13 @@ for (const line of output.split('\n')) {
   if (match) ids.push(match[1]);
 }
 
-const sessionState = readSessionState(cwd);
 const bundle = {
   ids,
-  sessionState: sessionState ? {
-    issueId: sessionState.issueId,
-    branch: sessionState.branch,
-    worktreePath: sessionState.worktreePath,
-    prNumber: sessionState.prNumber,
-    prUrl: sessionState.prUrl,
-    phase: sessionState.phase,
-    conflictFiles: Array.isArray(sessionState.conflictFiles) ? sessionState.conflictFiles : [],
-    startedAt: sessionState.startedAt,
-    lastChecked: sessionState.lastChecked,
-  } : null,
   savedAt: new Date().toISOString(),
 };
 
-if (bundle.ids.length === 0 && !bundle.sessionState) process.exit(0);
+if (bundle.ids.length === 0) process.exit(0);
 
 writeFileSync(path.join(beadsDir, '.last_active'), JSON.stringify(bundle, null, 2) + '\n', 'utf8');
 
-if (bundle.sessionState?.phase === 'waiting-merge') {
-  const pr = bundle.sessionState.prNumber != null ? `#${bundle.sessionState.prNumber}` : '(pending PR)';
-  process.stdout.write(
-    JSON.stringify({
-      hookSpecificOutput: {
-        hookEventName: 'PreCompact',
-        additionalSystemPrompt:
-          `PENDING: xtrm finish waiting for PR ${pr} to merge. Re-run xtrm finish to resume.`,
-      },
-    }) + '\n',
-  );
-}
-
 process.exit(0);

package/hooks/beads-edit-gate.mjs

@@ -13,8 +13,8 @@ import {
   resolveClaimAndWorkState,
   decideEditGate,
 } from './beads-gate-core.mjs';
-import { withSafeBdContext } from './beads-gate-utils.mjs';
-import { editBlockMessage, editBlockFallbackMessage } from './beads-gate-messages.mjs';
+import { withSafeBdContext, isMemoryGatePending } from './beads-gate-utils.mjs';
+import { editBlockMessage, editBlockFallbackMessage, memoryGatePendingMessage } from './beads-gate-messages.mjs';
 
 const input = readHookInput();
 if (!input) process.exit(0);
@@ -23,6 +23,13 @@ withSafeBdContext(() => {
   const ctx = resolveSessionContext(input);
   if (!ctx || !ctx.isBeadsProject) process.exit(0);
 
+  // Memory gate takes priority: block edits while pending acknowledgment
+  if (ctx.sessionId && isMemoryGatePending(ctx.sessionId, ctx.cwd)) {
+    process.stdout.write(JSON.stringify({ decision: 'block', reason: memoryGatePendingMessage() }));
+    process.stdout.write('\n');
+    process.exit(0);
+  }
+
   const state = resolveClaimAndWorkState(ctx);
   const decision = decideEditGate(ctx, state);
 

package/hooks/beads-gate-core.mjs

@@ -10,10 +10,12 @@
 import { readFileSync } from 'node:fs';
 import {
   resolveCwd,
+  resolveSessionId,
   isBeadsProject,
   getSessionClaim,
   getTotalWork,
   getInProgress,
+  isIssueInProgress,
 } from './beads-gate-utils.mjs';
 
 // ── Input parsing ────────────────────────────────────────────────────────────
@@ -41,7 +43,7 @@ export function resolveSessionContext(input) {
   if (!cwd) return null;
   return {
     cwd,
-    sessionId: input.session_id ?? null,
+    sessionId: resolveSessionId(input),
     isBeadsProject: isBeadsProject(cwd),
   };
 }
@@ -68,6 +70,7 @@ export function resolveClaimAndWorkState(ctx) {
     return {
       claimed: !!claimId,
       claimId: claimId || null,
+      claimInProgress: claimId ? isIssueInProgress(claimId, ctx.cwd) : false,
       totalWork,
       inProgress,
     };
@@ -77,6 +80,7 @@ export function resolveClaimAndWorkState(ctx) {
   return {
     claimed: false,
     claimId: null,
+    claimInProgress: false,
     totalWork,
     inProgress,
   };
@@ -154,16 +158,16 @@ export function decideCommitGate(ctx, state) {
     return { allow: true };
   }
 
-  // Has claim but no in_progress issues → allow (stale/already-closed claim)
-  if (!state.inProgress || state.inProgress.count === 0) {
+  // Claimed issue is no longer in_progress → allow (closed or transferred to another agent)
+  if (!state.claimInProgress) {
     return { allow: true };
   }
 
-  // Has claim + in_progress issues → block (need to close first)
+  // Session's own claimed issue is still in_progress → block (need to close first)
   return {
     allow: false,
     reason: 'unclosed_claim',
-    summary: state.inProgress.summary,
+    summary: `  Claimed: ${state.claimId} (still in_progress)`,
     claimed: state.claimId,
   };
 }
@@ -196,16 +200,16 @@ export function decideStopGate(ctx, state) {
     return { allow: true };
   }
 
-  // Has claim but no in_progress issues → allow (stale claim)
-  if (!state.inProgress || state.inProgress.count === 0) {
+  // Claimed issue is no longer in_progress → allow (stale claim)
+  if (!state.claimInProgress) {
     return { allow: true };
   }
 
-  // Has claim + in_progress issues → block
+  // Session's own claimed issue is still in_progress → block
   return {
     allow: false,
     reason: 'unclosed_claim',
-    summary: state.inProgress.summary,
+    summary: `  Claimed: ${state.claimId} (still in_progress)`,
     claimed: state.claimId,
   };
 }

package/hooks/beads-gate-messages.mjs

@@ -68,34 +68,16 @@ export function stopBlockMessage(summary, claimed) {
   );
 }
 
-export function stopBlockWaitingMergeMessage(state) {
-  const pr = state.prNumber != null ? `#${state.prNumber}` : '(PR pending)';
-  const prUrl = state.prUrl ? `\nPR: ${state.prUrl}` : '';
-  return (
-    `🚫 PR ${pr} not yet merged. Run: xtrm finish\n` +
-    `${prUrl}\n` +
-    `Worktree: ${state.worktreePath}\n`
-  );
-}
-
-export function stopBlockConflictingMessage(state) {
-  const conflicts = Array.isArray(state.conflictFiles) && state.conflictFiles.length > 0
-    ? state.conflictFiles.join(', ')
-    : 'unknown files';
-  return (
-    `🚫 Merge conflicts in: ${conflicts}. Resolve, push, then: xtrm finish\n` +
-    `Worktree: ${state.worktreePath}\n`
-  );
-}
+// ── Memory gate messages ─────────────────────────────────────────
 
-export function stopWarnActiveWorktreeMessage(state) {
+export function memoryGatePendingMessage() {
   return (
-    `⚠ Session has an active worktree at ${state.worktreePath}. Consider running: xtrm finish\n`
+    '🧠 Memory gate pending — evaluate insights before continuing.\n' +
+    '  YES → bd remember "<insight>"   NO → note "nothing to persist"\n' +
+    '  Then acknowledge: touch .beads/.memory-gate-done\n'
   );
 }
 
-// ── Memory gate messages ─────────────────────────────────────────
-
 export function memoryPromptMessage() {
   return (
     '🧠 Memory gate: for each closed issue, worth persisting?\n' +

package/hooks/beads-gate-utils.mjs

@@ -13,6 +13,14 @@ export function resolveCwd(input) {
   return input.cwd ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
 }
 
+/**
+ * Resolve a stable session key for beads hooks.
+ * Priority: explicit hook session id -> cwd fallback.
+ */
+export function resolveSessionId(input) {
+  return input?.session_id ?? input?.sessionId ?? resolveCwd(input);
+}
+
 /** Return true if the directory contains a .beads project. */
 export function isBeadsProject(cwd) {
   return existsSync(join(cwd, '.beads'));
@@ -71,6 +79,23 @@ export function getInProgress(cwd) {
   }
 }
 
+/**
+ * Return true if a specific issue ID is currently in in_progress status.
+ * Used by commit/stop gates to scope the check to the session's own claimed issue.
+ * Returns false (fail open) if bd is unavailable.
+ */
+export function isIssueInProgress(issueId, cwd) {
+  if (!issueId) return false;
+  try {
+    const output = execSync('bd list --status=in_progress', {
+      encoding: 'utf8', cwd, stdio: ['pipe', 'pipe', 'pipe'], timeout: 8000,
+    });
+    return output.includes(issueId);
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Count total trackable work (open + in_progress issues) using a single bd list call.
  * Returns the count, or null if bd is unavailable.
@@ -90,6 +115,42 @@ export function getTotalWork(cwd) {
   }
 }
 
+/**
+ * Get the closed-this-session issue ID for a session from bd kv.
+ * Returns: issue ID string if set, '' if not set, null if bd kv unavailable.
+ */
+export function getClosedThisSession(sessionId, cwd) {
+  try {
+    return execSync(`bd kv get "closed-this-session:${sessionId}"`, {
+      encoding: 'utf8',
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+  } catch (err) {
+    if (err.status === 1) return ''; // key not found
+    return null;                     // bd kv unavailable
+  }
+}
+
+/**
+ * Return true if the memory gate is pending acknowledgment for this session.
+ * Pending = closed-this-session kv is set AND .beads/.memory-gate-done marker is absent.
+ */
+export function isMemoryGatePending(sessionId, cwd) {
+  if (existsSync(join(cwd, '.beads', '.memory-gate-done'))) return false;
+  const closed = getClosedThisSession(sessionId, cwd);
+  return !!closed; // null (unavailable) is falsy → fail open
+}
+
+/**
+ * Return true if a Bash command is a memory-gate acknowledgment command.
+ * These commands are allowed even while the memory gate is pending.
+ */
+export function isMemoryAckCommand(command) {
+  return /\bbd\s+remember\b/.test(command) || /\btouch\s+\.beads\/\.memory-gate-done\b/.test(command);
+}
+
 /**
  * Clear the session claim key from bd kv. Non-fatal — best-effort cleanup.
  */
@@ -115,7 +176,10 @@ export function clearSessionClaim(sessionId, cwd) {
 export function withSafeBdContext(fn) {
   try {
     fn();
-  } catch {
+  } catch (err) {
+    if (err instanceof TypeError || err instanceof ReferenceError || err instanceof SyntaxError) {
+      throw err;
+    }
     process.exit(0);
   }
 }