claude-code-autoconfig 1.0.192 → 1.0.194

package/.claude/hooks/terminal-title.directive.md

@@ -11,6 +11,7 @@
 
   Tokens (substituted at runtime):
     {{TITLE_FILE}} — absolute path to this session's title file the model writes
+    {{ASK_FILE}}   — absolute path to this session's one-shot {sid}.ask flag (PENDING block)
     {{FOLDER}}     — the working-directory folder name (scope fallback)
     {{EMDASH}}     — the ' — ' segment separator
     {{CMD}}        — the slash-command name (COMMAND block only)
@@ -63,9 +64,14 @@ already exists, read it first then overwrite.
 <!-- /DIRECTIVE:SHIFT -->
 
 <!-- DIRECTIVE:PENDING -->
-Pending-question signal: if you END this turn by asking the user a question they must answer
-before you can proceed, phrase it so your FINAL line ends with a question mark ('?') -- the tab
-indicator then flips to the AWAITING half-circle automatically (instead of the idle asterisk).
+Pending-question signal: when you END this turn on a question the user must answer before you can
+proceed, do BOTH of these as near-final actions so the tab flips to the AWAITING half-circle
+(instead of the idle asterisk):
+  1. Write the flag file {{ASK_FILE}} (any short content, e.g. "1"). This is the RELIABLE trigger --
+     it is on disk before the turn ends, so it never misses (the transcript-text check in 2 can race
+     the turn-end write and silently miss). The flag is one-shot: it is consumed at turn end and
+     auto-cleared next turn, so write it ONLY on a turn you are genuinely blocked on an answer.
+  2. Phrase your FINAL line so it ends with a question mark ('?') -- a backup signal, and good UX.
 Make the closing question self-contained: answerable from the question alone, without re-reading
-the response above it. Only end on a '?' for a genuine blocking question, never a rhetorical one.
+the response above it. Only do this for a genuine blocking question, never a rhetorical one or a recap.
 <!-- /DIRECTIVE:PENDING -->

package/.claude/hooks/terminal-title.js

@@ -2,7 +2,8 @@
 /**
  * Terminal Title — distributable plugin hook (installed to <project>/.claude/hooks/terminal-title.js).
  * ONE self-dispatching hook for five events (keyed on hook_event_name):
- *   UserPromptSubmit -> ⬤ working  + inject the title directive into the model's context
+ *   UserPromptSubmit -> ⬤ working  + inject the title directive (incl. the {sid}.ask path) +
+ *                       clear any stale {sid}.ask flag so it reflects only the turn about to run
  *   PostToolUse      -> ⬤ working  (refresh, so a mid-turn title flip shows live + clears a stale ◐)
  *   Notification     -> ◐ awaiting your approval (permission_prompt matcher only)
  *   Stop             -> ✻ idle / done — OR ◐ awaiting (+ a 2nd BEL = gold tab) when the turn ended
@@ -40,18 +41,23 @@ const GLYPH = {
 // Per-invocation context for the optional debug log (populated in handle, read by titleLog).
 let logCtx = null;
 
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => (input += chunk));
-process.stdin.on('end', () => {
-  try {
-    handle(JSON.parse(input));
-  } catch (err) {
-    process.exit(0); // never break the turn on a title error — emit nothing
-  }
-});
+// Only drive from stdin when run AS the hook (`node terminal-title.js`). When require()'d by a test the
+// functions below are exported instead, so the stdin read doesn't hang the runner. async because the
+// Stop branch may await a short re-read beat (see the flush-race guard in handle).
+if (require.main === module) {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => (input += chunk));
+  process.stdin.on('end', async () => {
+    try {
+      await handle(JSON.parse(input));
+    } catch (err) {
+      process.exit(0); // never break the turn on a title error — emit nothing
+    }
+  });
+}
 
-function handle(data) {
+async function handle(data) {
   const event = data.hook_event_name || '';
   const sid = data.session_id || '';
   const cwd = data.cwd || process.cwd();
@@ -65,6 +71,10 @@ function handle(data) {
     // Ensure the state dir exists, but NOT the file — the model's Write tool refuses to overwrite a
     // file it hasn't read, so a pre-created empty file would make its first title write fail.
     try { fs.mkdirSync(dir, { recursive: true }); } catch (_) { /* ignore */ }
+    // Clear any stale {sid}.ask left by an interrupted prior turn (Stop never ran to consume it), so a
+    // leftover flag can't paint a false ◐ on this turn's end. The flag must reflect ONLY this turn.
+    const askFile = path.join(dir, `${sid}.ask`);
+    if (fileExists(askFile)) { try { fs.unlinkSync(askFile); } catch (_) { /* ignore */ } }
     const title = normalize(readTitle(file) || folderName(cwd));
     const out = setTitle(GLYPH.working, title);
     out.hookSpecificOutput = {
@@ -100,11 +110,32 @@ function handle(data) {
   // so VS Code paints the (otherwise bell-less) tab gold. "Ended on a question" = last visible
   // assistant text ends in '?' (transcript heuristic) OR an explicit {sid}.ask flag (consumed here).
   const askFile = path.join(dir, `${sid}.ask`);
-  let pending = lastResponseEndsWithQuestion(data.transcript_path);
+  const askPresent = fileExists(askFile);
+
+  // Grade the transcript, guarding the flush race: the final assistant text can land in the JSONL a beat
+  // AFTER Stop fires (the screen renders from the live stream; the file append lags by ~200ms). The tell
+  // is `suspectRace`: the freshest on-disk assistant block is text-less (thinking/tool_use only), or no
+  // text was found at all — both mean the real final message is still flushing. When that's the case,
+  // re-read a few times (~120ms apart) before grading, so a turn that actually ended on '?' isn't painted
+  // ✻ idle off a stale earlier block. A fully-flushed turn hits the text block first → suspectRace=false →
+  // zero delay. The {sid}.ask flag remains the race-proof backstop.
+  let q = inspectLastResponse(data.transcript_path);
+  let reread = 0;
+  while (!q.ends && (q.suspectRace || !q.found) && reread < 7) {
+    await delay(120);
+    reread++;
+    q = inspectLastResponse(data.transcript_path);
+    if (q.ends || (q.found && !q.suspectRace)) break;
+  }
+
+  let pending = q.ends;
   let note = pending ? 'q-mark' : 'idle';
-  if (!pending && fileExists(askFile)) { pending = true; note = 'ask-flag'; }
-  if (fileExists(askFile)) { try { fs.unlinkSync(askFile); } catch (_) { /* ignore */ } }
-  if (logCtx) logCtx.note = note;
+  if (!pending && askPresent) { pending = true; note = 'ask-flag'; }
+  if (askPresent) { try { fs.unlinkSync(askFile); } catch (_) { /* ignore */ } }
+  if (logCtx) {
+    logCtx.note = note;
+    logCtx.diag = `ask=${askPresent ? 1 : 0} qmark=${q.ends ? 1 : 0} found=${q.found ? 1 : 0} reread=${reread} tail="${q.tail}"`;
+  }
   const glyph = pending ? GLYPH.awaiting : GLYPH.idle;
   emit(setTitle(glyph, normalize(readTitle(file) || folderName(cwd)), pending));
 }
@@ -130,9 +161,10 @@ function titleLog(glyph, title, ring) {
     const name = glyph === GLYPH.working ? 'working'
       : glyph === GLYPH.awaiting ? 'awaiting'
       : glyph === GLYPH.idle ? 'idle' : 'other';
+    const diag = logCtx.diag ? `  ${logCtx.diag}` : '';
     const line = `${new Date().toISOString()}  ${logCtx.event.padEnd(16)} `
       + `${name.padEnd(8)} ring=${ring ? 1 : 0} note=${(logCtx.note || '-').padEnd(8)} `
-      + `sid=${logCtx.sid} | ${title}\n`;
+      + `sid=${logCtx.sid} | ${title}${diag}\n`;
     const f = path.join(logCtx.dir, '_debug.log');
     try { if (fs.statSync(f).size > 512 * 1024) fs.renameSync(f, `${f}.1`); } catch (_) { /* none yet */ }
     fs.appendFileSync(f, line);
@@ -145,16 +177,26 @@ function fileExists(file) {
 
 // Stop heuristic: did the turn end on a question? Read the JSONL transcript, find the most-recent
 // assistant message with VISIBLE text (skip pure tool_use turns so a final title/memory Write doesn't
-// mask the question), test whether it ends in '?' (allowing trailing whitespace / ) * _ "). Any error → false.
-function lastResponseEndsWithQuestion(transcriptPath) {
-  if (!transcriptPath) return false;
+// mask the question), test whether it ends in '?' (allowing trailing whitespace / ) * _ "). Returns a
+// diagnostic record { ends, found, tail }: `ends` is the old boolean the caller branches on; `found`
+// and `tail` feed the debug log so a missing half-circle can be told apart — a transcript-flush race
+// shows found=0 (or a stale tail), a genuine regex miss shows a tail that's present but doesn't end
+// in '?'. Any error → a blank record (treated as "no question"), matching the old false return.
+function inspectLastResponse(transcriptPath) {
+  const blank = { ends: false, found: false, tail: '', suspectRace: false };
+  if (!transcriptPath) return blank;
   let content;
   try {
     content = fs.readFileSync(transcriptPath, 'utf8');
   } catch (_) {
-    return false;
+    return blank;
   }
   const lines = content.split('\n');
+  // Did we pass a TEXT-LESS assistant block (thinking-only / tool_use-only) on the way back to the last
+  // text block? At a fully-flushed Stop the final assistant message HAS text, so we hit it first and this
+  // stays false. If it's true, the turn's real final text is most likely still being appended to the
+  // JSONL (the flush race) — the caller re-reads after a beat before grading rather than trust this block.
+  let sawTextlessAssistant = false;
   for (let i = lines.length - 1; i >= 0; i--) {
     const line = lines[i].trim();
     if (!line) continue;
@@ -171,11 +213,21 @@ function lastResponseEndsWithQuestion(transcriptPath) {
         .map(b => b.text)
         .join('\n');
     }
-    if (text.trim()) return /\?[\s)*_"]*$/.test(text);
+    if (text.trim()) {
+      // last ~60 chars, collapsed to one line and quote-stripped so it can't break the log framing
+      const tail = text.trim().slice(-60).replace(/\s+/g, ' ').replace(/"/g, "'");
+      return { ends: /\?[\s)*_"]*$/.test(text), found: true, tail, suspectRace: sawTextlessAssistant };
+    }
+    // assistant message with no visible text = a thinking-only or tool_use-only block sitting AFTER the
+    // last text we'll grade — a strong hint the final text line hasn't flushed yet.
+    sawTextlessAssistant = true;
   }
-  return false;
+  return blank;
 }
 
+// Event-loop-friendly sleep for the Stop flush-race re-read beat (handle awaits this; no busy-wait).
+function delay(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+
 function readTitle(file) {
   try {
     if (fs.existsSync(file)) return fs.readFileSync(file, 'utf8').trim();
@@ -221,6 +273,7 @@ function buildDirective(data, file, cwd) {
   const combined = pending ? `${block}\n\n${pending}` : block;
   return combined
     .split('{{TITLE_FILE}}').join(file)
+    .split('{{ASK_FILE}}').join(file.replace(/\.txt$/, '.ask'))
     .split('{{FOLDER}}').join(folderName(cwd))
     .split('{{EMDASH}}').join(EMDASH)
     .split('{{CMD}}').join(cmd);
@@ -233,3 +286,6 @@ function extractBlock(tpl, name) {
   const m = tpl.match(re);
   return m ? m[1].trim() : '';
 }
+
+// Exported for tests (require()'d when require.main !== module). The hook itself never reads these.
+module.exports = { inspectLastResponse, normalize, GLYPH };

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v1.0.194
+- fix(terminal-title): guard the Stop question-grade against the transcript-flush race
+
+## v1.0.193
+- fix(installer): always refresh cca-managed title hooks on upgrade
+- fix(terminal-title): arm the {sid}.ask flag so awaiting ◐ is race-free
+- docs(publish): document web-auth/passkey publish flow in Discoveries
+
 ## v1.0.192
 - fix(pkg): exclude runtime .titles/ from published tarball
 
@@ -142,6 +150,3 @@
 ## v1.0.144
 - feat: swagger-style docs, wider layout, better install UX
 
-## v1.0.143
-- feat: add /validate-cca-install command
-

package/CLAUDE.md

@@ -42,6 +42,18 @@ See `.claude/feedback/` for corrections and guidance from the team.
 ## Discoveries
 <!-- Claude: append project-specific learnings, gotchas, and context below. This section persists across /autoconfig runs. -->
 
+### Publishing to npm — web-auth (passkey) flow, run by the human
+
+`npm publish` for this package is a **two-actor** flow; a bare in-agent `npm publish` will FAIL. (Supersedes the auto-generated "## Publishing" one-liner above.)
+
+- The npm account has **2FA**. A sandboxed/agent shell can't open a browser, so `npm publish` there dies with `npm error code EOTP`. Don't retry it in-agent; don't default to asking for a typed OTP.
+- **Working flow:** the agent runs `npm test` + `npm version patch` (commit + tag), then the **human runs the publish in their own terminal** (needs a browser):
+  ```
+  cd C:\CODE\claude-code-autoconfig && npm login --auth-type=web && npm publish
+  ```
+  → browser opens → pick the Google passkey → close it → `+ claude-code-autoconfig@<version>`.
+- **After** the success line, the agent pushes: `git push origin main --follow-tags`. Never double-bump if the version is already bumped. Full procedure: `.claude/commands/publish.md`.
+
 ## Debugging Methodology — Evidence Before Solutions
 
 **NEVER jump to a fix based on assumptions.** When investigating a bug:

package/bin/cli.js

@@ -767,10 +767,21 @@ if (fs.existsSync(feedbackSrc)) {
   copyFn(feedbackSrc, path.join(claudeDest, 'feedback'));
 }
 
-// Copy hooks directory (preserve user customizations unless --force)
+// Copy hooks directory. Genuinely user-authorable hooks are preserved on upgrade
+// (copyDirIfMissing), BUT the cca-managed title-hook files are ALWAYS refreshed so bug-fixes
+// reach existing installs — without this, copyDirIfMissing leaves stale hooks in place forever
+// (same always-overwrite rationale as scripts/ below). --force already overwrites everything.
+const MANAGED_HOOKS = ['terminal-title.js', 'terminal-title.directive.md'];
 if (fs.existsSync(hooksSrc)) {
   const copyFn = forceMode ? copyDir : copyDirIfMissing;
   copyFn(hooksSrc, path.join(claudeDest, 'hooks'));
+  if (!forceMode) {
+    const hooksDestDir = path.join(claudeDest, 'hooks');
+    for (const name of MANAGED_HOOKS) {
+      const src = path.join(hooksSrc, name);
+      if (fs.existsSync(src)) fs.copyFileSync(src, path.join(hooksDestDir, name));
+    }
+  }
 }
 
 // Copy scripts directory (always overwrite — these are utility scripts, not user-customizable)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-autoconfig",
-  "version": "1.0.192",
+  "version": "1.0.194",
   "description": "Intelligent, self-configuring setup for Claude Code. One command analyzes your project, configures Claude, and shows you what it did.",
   "author": "ADAC 1001 <info@adac1001.com>",
   "license": "MIT",