safeword 0.35.1 → 0.35.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safeword",
-  "version": "0.35.1",
+  "version": "0.35.2",
   "description": "CLI for setting up and managing safeword development environments",
   "repository": {
     "type": "git",

package/templates/hooks/lib/re-entry.ts

@@ -9,8 +9,8 @@
  */
 
 import { execSync } from 'node:child_process';
-import { readdirSync, readFileSync } from 'node:fs';
-import { basename, dirname, join, relative } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 
 export interface Entry {
   timestamp: string;
@@ -107,6 +107,34 @@ export function normalizeRelative(filePath: string, cwd: string): string {
   return filePath;
 }
 
+/**
+ * Resolve the project root reliably, regardless of where the session's cwd drifted.
+ *
+ * Claude Code passes `input.cwd` = the session's current working directory, which
+ * is not necessarily the project root. Hooks that wrote `join(cwd, '.safeword-project')`
+ * blindly would silently mkdirSync a bogus nested `.safeword-project/` inside whatever
+ * subdir the session happened to be in (e.g. `<root>/.safeword-project/tickets/.safeword-project/`).
+ *
+ * Implementation: walk up from `cwd` looking for a `.git` marker. Pure (no subprocess),
+ * preserves the cwd path form (matters on macOS where `git rev-parse --show-toplevel`
+ * canonicalizes `/var/folders/...` symlinks to `/private/var/folders/...` and breaks
+ * downstream `startsWith` comparisons against absolute paths captured by other code).
+ *
+ * Returns null when no `.git/` ancestor exists — caller bails silently rather than
+ * write to a stray path. Note: we intentionally do NOT match on `.safeword-project/`
+ * during the walk because the bogus nested directories created by the old code would
+ * mislead the resolver.
+ */
+export function resolveProjectRoot(cwd: string): string | null {
+  let current = resolve(cwd);
+  while (true) {
+    if (existsSync(join(current, '.git'))) return current;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
 export function detectConflictFiles(cwd: string, transcriptPath: string | undefined): string[] {
   if (!transcriptPath) return [];
   const dirtyFiles = new Set(getDirtyFiles(cwd));

package/templates/hooks/session-start-reentry.ts

@@ -19,7 +19,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { detectConflictFiles, type Entry, parseLogLine } from './lib/re-entry';
+import { detectConflictFiles, type Entry, parseLogLine, resolveProjectRoot } from './lib/re-entry';
 
 interface HookInput {
   session_id?: string;
@@ -54,7 +54,11 @@ async function main(): Promise<void> {
   const { session_id, cwd, source, transcript_path } = input;
   if (!session_id || !cwd) return;
 
-  const logPath = join(cwd, '.safeword-project', 're-entry.md');
+  // Same cwd-drift defense as stop-reentry: resolve real project root.
+  const projectRoot = resolveProjectRoot(cwd);
+  if (!projectRoot) return;
+
+  const logPath = join(projectRoot, '.safeword-project', 're-entry.md');
   const logExists = existsSync(logPath);
   const content = logExists ? readFileSync(logPath, 'utf8').trim() : '';
 
@@ -72,7 +76,7 @@ async function main(): Promise<void> {
     briefBody = renderBrief([allEntries[allEntries.length - 1]], { fromAnotherSession: true });
   }
 
-  const conflictFiles = detectConflictFiles(cwd, transcript_path);
+  const conflictFiles = detectConflictFiles(projectRoot, transcript_path);
   const conflictWarning = renderConflictWarning(conflictFiles);
 
   // Nothing to inject in either channel → stay silent.

package/templates/hooks/stop-reentry.ts

@@ -14,6 +14,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { getActiveTicket } from './lib/active-ticket';
+import { resolveProjectRoot } from './lib/re-entry';
 
 interface HookInput {
   session_id?: string;
@@ -96,18 +97,25 @@ async function main(): Promise<void> {
   const { session_id, transcript_path, cwd } = input;
   if (!session_id || !transcript_path || !cwd) return;
 
+  // Claude Code passes input.cwd = the session's current working directory,
+  // which can drift into a subdirectory. Resolve the real project root so we
+  // never write to a stray nested `.safeword-project/`. Bail silently if we
+  // can't find a git repo to anchor to.
+  const projectRoot = resolveProjectRoot(cwd);
+  if (!projectRoot) return;
+
   const assistantText = readLastAssistantText(transcript_path);
   if (!assistantText) return;
 
   const imperative = extractLastNextImperative(assistantText);
   if (!imperative) return;
 
-  const ticketField = resolveTicketField(cwd);
+  const ticketField = resolveTicketField(projectRoot);
 
   const timestamp = new Date().toISOString();
   const line = `${timestamp} ${session_id} ${ticketField} Next: ${imperative}\n`;
 
-  const projectDirectory = join(cwd, '.safeword-project');
+  const projectDirectory = join(projectRoot, '.safeword-project');
   if (!existsSync(projectDirectory)) {
     mkdirSync(projectDirectory, { recursive: true });
   }