universal-dev-standards 6.12.0 → 6.13.0-beta.2

package/bundled/hooks/check-turn-completion.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * UDS Hook: Turn Completion Integrity
+ * UDS Hook: Turn Completion Integrity — Claude Code adapter
  *
  * Runs at turn end. Blocks when the agent's final message states a first-person
  * commitment to a next action that the turn then ended without taking.
@@ -14,6 +14,13 @@
  * that can trap a session is worse than none, because the only recovery a human
  * has is to disable it, and they will disable it permanently.
  *
+ * This file is one of several per-harness adapters (see also
+ * check-turn-completion-codex.mjs, check-turn-completion-gemini.mjs). Judgement
+ * — packs, cooldown, the rolling window, the self-echo marker — lives in
+ * turn-completion/engine.mjs and is shared by all of them; this file's only job
+ * is reading Claude Code's stdin/transcript shape and writing Claude Code's
+ * output shape.
+ *
  * Usage: node check-turn-completion.mjs  (reads stdin)
  *        node check-turn-completion.mjs --self-test
  *        node check-turn-completion.mjs --languages
@@ -21,60 +28,13 @@
  * @see docs/specs/SPEC-HOOKS-001-core-standard-hooks.md
  * @see core/turn-completion-integrity.md
  */
-import { readFileSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { detectCommitment, userAskedToStop } from './turn-completion/detect.mjs';
-
-export const VERSION = '1.1.0';
-
-const COOLDOWN_SEC = 120;
-// A cap counted per session with no reset is an off switch on a delay: it
-// disarms silently in exactly the long session where the rule matters most.
-// A rolling window bounds runaway loops just as well and recovers by itself.
-const MAX_BLOCKS_PER_WINDOW = 6;
-const WINDOW_SEC = 3600;
-
-const STATE_DIR = join(homedir(), '.uds', 'turn-completion');
-const HERE = dirname(fileURLToPath(import.meta.url));
-
-/** Locales this hook ships. The self-test fails if any of them will not load. */
-export const SHIPPED_LOCALES = ['en', 'zh-TW'];
-
-/**
- * Load every shipped locale pack.
- *
- * At runtime a pack that fails to load is skipped (R5: a broken pack must not
- * stop the turn from ending). 🔴 But that swallow is also how a shipping
- * mistake hides: with zero packs loaded the hook runs, exits 0, and can never
- * fire — the same shape as good behaviour. So `failed` is returned rather than
- * discarded, and the self-test treats a non-empty `failed` as a failure.
- * Caught while renaming the packs to .mjs: the loader still asked for .js.
- */
-export async function loadPacks() {
-  const packs = [];
-  const failed = [];
-  for (const id of SHIPPED_LOCALES) {
-    try {
-      packs.push(await import(join(HERE, 'turn-completion', 'locales', `${id}.mjs`)));
-    } catch (e) {
-      failed.push({ id, why: String((e && e.message) || e) });
-    }
-  }
-  return { packs, failed };
-}
+import { readFileSync, existsSync } from 'node:fs';
+import {
+  VERSION, SHIPPED_LOCALES, SELF_ECHO, decide, loadPacks, isSelfEcho,
+  runSelfTest, printLanguages,
+} from './turn-completion/engine.mjs';
 
-/**
- * 🔴 This hook's own block message enters the transcript as a user turn. On the
- * next run it would therefore be read as "the human's last message", hiding the
- * real one ("pause, I'm going home") and silently voiding the R9 exemption.
- *
- * Same family as the detector matching the prose that documents it — except
- * here it reads its own output. The reason string carries this line so it can
- * recognise itself.
- */
-export const SELF_ECHO = 'UDS standard turn-completion-integrity (R1)';
+export { VERSION, SHIPPED_LOCALES, SELF_ECHO, loadPacks };
 
 /** Plain text of a transcript message, or '' if it carries none. */
 function textOf(msg) {
@@ -104,33 +64,11 @@ export function lastMessages(transcriptPath) {
     const t = textOf(msg);
     if (!t) continue;
     if (msg.role === 'assistant') assistant = t;
-    else if (msg.role === 'user' && !t.includes(SELF_ECHO)) user = t;
+    else if (msg.role === 'user' && !isSelfEcho(t)) user = t;
   }
   return { assistant, user };
 }
 
-function readState(path) {
-  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return {}; }
-}
-
-function reason(packId, sentence) {
-  return [
-    'Your last message stated a next action, and then the turn ended without taking it.',
-    '',
-    `Detected by the ${packId} pack, in: "${sentence}"`,
-    '',
-    'UDS standard turn-completion-integrity (R1): a stated next action is not optional.',
-    '',
-    'Do one of these now:',
-    '  (a) take the action you just said you would take;',
-    '  (b) if it is actually blocked, say what blocks it and what you need, then do',
-    '      the next item that is not blocked;',
-    '  (c) if everything is done or blocked, list every remaining item WITH the',
-    '      person or input it waits on. That itemized list is the only shape of',
-    '      ending that R2 accepts — "the main parts are done" is not one.',
-  ].join('\n');
-}
-
 async function main() {
   let raw = '';
   try {
@@ -147,87 +85,24 @@ async function main() {
   const tp = data.transcript_path;
   if (!tp || !existsSync(tp)) return;   // cannot tell is not the same as should block
 
-  const sid = String(data.session_id || 'unknown');
-  const statePath = join(STATE_DIR, `${sid}.json`);
-  const st = readState(statePath);
-  const now = Date.now() / 1000;
-
-  const stamps = (Array.isArray(st.stamps) ? st.stamps : [])
-    .filter((t) => typeof t === 'number' && now - t < WINDOW_SEC);
-  if (stamps.length >= MAX_BLOCKS_PER_WINDOW) return;
-  if (now - (st.last || 0) < COOLDOWN_SEC) return;
-
   let msgs;
   try { msgs = lastMessages(tp); } catch { return; }
-  if (!msgs.assistant.trim()) return;
 
-  const { packs } = await loadPacks();
-  if (packs.length === 0) return;
-
-  // The human asked for the turn to end. That is a legitimate ending, and the
-  // agent's own words cannot distinguish it from an abandoned commitment.
-  if (userAskedToStop(msgs.user, packs)) return;
-
-  const hit = detectCommitment(msgs.assistant, packs);
-  if (!hit.fired) return;
-
-  stamps.push(now);
-  try {
-    mkdirSync(STATE_DIR, { recursive: true });
-    writeFileSync(statePath, JSON.stringify({ stamps, last: now }));
-  } catch {
-    /* state is an optimisation; failing to write it must not change the verdict */
-  }
-
-  process.stdout.write(JSON.stringify({
-    decision: 'block',
-    reason: reason(hit.packId, hit.sentence),
-  }));
-}
-
-async function selfTest() {
-  const { packs, failed } = await loadPacks();
-  let ok = failed.length === 0 && packs.length === SHIPPED_LOCALES.length;
-  console.log(`[turn-completion] v${VERSION} — packs: ${packs.map((p) => p.id).join(', ')}`
-    + ` (${packs.length}/${SHIPPED_LOCALES.length} shipped locales)`);
-  for (const f of failed) console.log(`  x   locale ${f.id} failed to load — ${f.why}`);
-
-  for (const pack of packs) {
-    for (const [want, label, text] of pack.corpus) {
-      // Run against ALL packs, which is the shipped configuration. A pack that
-      // is correct alone and wrong beside another is not correct.
-      const got = detectCommitment(text, packs).fired;
-      const good = got === want;
-      ok &&= good;
-      console.log(`  ${good ? 'OK ' : 'x  '} [${pack.id}] ${want ? 'must block' : 'must pass'} — ${label}`
-        + (good ? '' : `   (got: ${got ? 'block' : 'pass'})`));
-    }
-    for (const [want, label, text] of pack.stopCorpus || []) {
-      const got = userAskedToStop(text, packs);
-      const good = got === want;
-      ok &&= good;
-      console.log(`  ${good ? 'OK ' : 'x  '} [${pack.id}] user ${want ? 'IS' : 'is NOT'} asking to stop — ${label}`
-        + (good ? '' : `   (got: ${got ? 'exempt' : 'not exempt'})`));
-    }
-  }
-  // The block message must contain the marker, or the hook cannot tell its own
-  // output from the human's next instruction.
-  const selfRecognised = reason('en', 'x').includes(SELF_ECHO);
-  ok &&= selfRecognised;
-  console.log(`  ${selfRecognised ? 'OK ' : 'x  '} block message carries the self-echo marker`);
+  const verdict = await decide({
+    sessionId: data.session_id,
+    assistantText: msgs.assistant,
+    userText: msgs.user,
+  });
+  if (!verdict.fire) return;
 
-  console.log(`[turn-completion] self-test ${ok ? 'passed' : 'FAILED'}`);
-  process.exit(ok ? 0 : 1);
+  process.stdout.write(JSON.stringify({ decision: 'block', reason: verdict.reason }));
 }
 
 const arg = process.argv[2];
 if (arg === '--self-test') {
-  await selfTest();
+  process.exit((await runSelfTest('turn-completion')) ? 0 : 1);
 } else if (arg === '--languages') {
-  const { packs } = await loadPacks();
-  console.log(packs.map((p) => `${p.id} (${p.label})`).join('\n'));
-  console.log('\nThis check reads prose. If you work in a language not listed above,'
-    + '\nit is installed and running but cannot fire. See turn-completion-integrity R8.');
+  await printLanguages();
 } else {
   try { await main(); } catch { /* R5 */ }
 }

package/bundled/hooks/turn-completion/engine.mjs

@@ -0,0 +1,206 @@
+/**
+ * Shared decision engine for the turn-completion-integrity check.
+ *
+ * Every harness adapter (Claude Code, Codex, Gemini CLI, ...) reduces its own
+ * stdin contract down to { sessionId, assistantText, userText } and hands it
+ * to decide() here. This file owns judgement — pack loading, cooldown, the
+ * rolling-window cap, the self-echo marker — so that three (or more) copies
+ * of that logic cannot drift out of sync with each other. An adapter's only
+ * remaining job is reading its tool's input and writing its tool's output
+ * shape for a block; neither of those touches this file.
+ *
+ * @see core/turn-completion-integrity.md
+ */
+import { readFileSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { detectCommitment, userAskedToStop } from './detect.mjs';
+
+export const VERSION = '1.2.0';
+
+const COOLDOWN_SEC = 120;
+// A cap counted per session with no reset is an off switch on a delay: it
+// disarms silently in exactly the long session where the rule matters most.
+// A rolling window bounds runaway loops just as well and recovers by itself.
+const MAX_BLOCKS_PER_WINDOW = 6;
+const WINDOW_SEC = 3600;
+
+// Overridable so tests (and anything else that must not touch the
+// developer's real state) can point this at a throwaway directory instead of
+// mocking fs. Read once per call, not once at import time, so a test can set
+// it per-case without re-importing the module.
+function stateDir() {
+  return process.env.UDS_TURN_COMPLETION_STATE_DIR || join(homedir(), '.uds', 'turn-completion');
+}
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+/** Locales this hook ships. The self-test fails if any of them will not load. */
+export const SHIPPED_LOCALES = ['en', 'zh-TW'];
+
+/**
+ * Load every shipped locale pack.
+ *
+ * At runtime a pack that fails to load is skipped (R5: a broken pack must not
+ * stop the turn from ending). 🔴 But that swallow is also how a shipping
+ * mistake hides: with zero packs loaded the hook runs, exits 0, and can never
+ * fire — the same shape as good behaviour. So `failed` is returned rather than
+ * discarded, and the self-test treats a non-empty `failed` as a failure.
+ */
+export async function loadPacks() {
+  const packs = [];
+  const failed = [];
+  for (const id of SHIPPED_LOCALES) {
+    try {
+      packs.push(await import(join(HERE, 'locales', `${id}.mjs`)));
+    } catch (e) {
+      failed.push({ id, why: String((e && e.message) || e) });
+    }
+  }
+  return { packs, failed };
+}
+
+/**
+ * 🔴 This hook's own block message can re-enter a transcript as a human turn
+ * (measured on Claude Code — the block reason is written back as the next
+ * "user" message). On the next run it would therefore be read as "the human's
+ * last message", hiding the real one ("pause, I'm going home") and silently
+ * voiding the R9 exemption. Every adapter that reads a transcript for the
+ * human's last message MUST strip a message containing this marker before
+ * treating it as the human's words; stripSelfEcho() below does that.
+ */
+export const SELF_ECHO = 'UDS standard turn-completion-integrity (R1)';
+
+/** True if this text is (or contains) the hook's own prior block message. */
+export function isSelfEcho(text) {
+  return typeof text === 'string' && text.includes(SELF_ECHO);
+}
+
+function readState(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return {}; }
+}
+
+export function reason(packId, sentence) {
+  return [
+    'Your last message stated a next action, and then the turn ended without taking it.',
+    '',
+    `Detected by the ${packId} pack, in: "${sentence}"`,
+    '',
+    'UDS standard turn-completion-integrity (R1): a stated next action is not optional.',
+    '',
+    'Do one of these now:',
+    '  (a) take the action you just said you would take;',
+    '  (b) if it is actually blocked, say what blocks it and what you need, then do',
+    '      the next item that is not blocked;',
+    '  (c) if everything is done or blocked, list every remaining item WITH the',
+    '      person or input it waits on. That itemized list is the only shape of',
+    '      ending that R2 accepts — "the main parts are done" is not one.',
+  ].join('\n');
+}
+
+/**
+ * Decide whether this turn should block, and own the per-session cooldown and
+ * rolling-window state shared by every adapter.
+ *
+ * @param {object} input
+ * @param {string} input.sessionId
+ * @param {string} input.assistantText - the agent's final message for this turn
+ * @param {string} input.userText - the human's most recent message. The
+ *   caller is responsible for excluding this hook's own SELF_ECHO from it
+ *   where that tool's transcript can carry it (see isSelfEcho/stripSelfEcho).
+ * @returns {Promise<{ fire: boolean, reason?: string, packId?: string, sentence?: string }>}
+ */
+export async function decide({ sessionId, assistantText, userText }) {
+  if (!assistantText || !assistantText.trim()) return { fire: false };
+
+  const statePath = join(stateDir(), `${String(sessionId || 'unknown')}.json`);
+  const st = readState(statePath);
+  const now = Date.now() / 1000;
+
+  const stamps = (Array.isArray(st.stamps) ? st.stamps : [])
+    .filter((t) => typeof t === 'number' && now - t < WINDOW_SEC);
+  if (stamps.length >= MAX_BLOCKS_PER_WINDOW) return { fire: false };
+  if (now - (st.last || 0) < COOLDOWN_SEC) return { fire: false };
+
+  const { packs } = await loadPacks();
+  if (packs.length === 0) return { fire: false };
+
+  // The human asked for the turn to end. That is a legitimate ending, and the
+  // agent's own words cannot distinguish it from an abandoned commitment.
+  if (userAskedToStop(userText, packs)) return { fire: false };
+
+  const hit = detectCommitment(assistantText, packs);
+  if (!hit.fired) return { fire: false };
+
+  stamps.push(now);
+  try {
+    mkdirSync(stateDir(), { recursive: true });
+    writeFileSync(statePath, JSON.stringify({ stamps, last: now }));
+  } catch {
+    /* state is an optimisation; failing to write it must not change the verdict */
+  }
+
+  return { fire: true, reason: reason(hit.packId, hit.sentence), packId: hit.packId, sentence: hit.sentence };
+}
+
+/**
+ * Run every locale pack's corpus and print the result. Shared by every
+ * adapter's `--self-test` so the corpus can only be correct or wrong once,
+ * not once per tool.
+ *
+ * @param {string} label - printed in the header, e.g. "turn-completion-codex"
+ * @returns {Promise<boolean>} true if every corpus case and the self-echo
+ *   marker check passed
+ */
+export async function runSelfTest(label = 'turn-completion') {
+  const { packs, failed } = await loadPacks();
+  let ok = failed.length === 0 && packs.length === SHIPPED_LOCALES.length;
+  console.log(`[${label}] v${VERSION} — packs: ${packs.map((p) => p.id).join(', ')}`
+    + ` (${packs.length}/${SHIPPED_LOCALES.length} shipped locales)`);
+  for (const f of failed) console.log(`  x   locale ${f.id} failed to load — ${f.why}`);
+
+  for (const pack of packs) {
+    for (const [want, caseLabel, text] of pack.corpus) {
+      // Run against ALL packs, which is the shipped configuration. A pack that
+      // is correct alone and wrong beside another is not correct.
+      const got = detectCommitment(text, packs).fired;
+      const good = got === want;
+      ok &&= good;
+      console.log(`  ${good ? 'OK ' : 'x  '} [${pack.id}] ${want ? 'must block' : 'must pass'} — ${caseLabel}`
+        + (good ? '' : `   (got: ${got ? 'block' : 'pass'})`));
+    }
+    for (const [want, caseLabel, text] of pack.stopCorpus || []) {
+      const got = userAskedToStop(text, packs);
+      const good = got === want;
+      ok &&= good;
+      console.log(`  ${good ? 'OK ' : 'x  '} [${pack.id}] user ${want ? 'IS' : 'is NOT'} asking to stop — ${caseLabel}`
+        + (good ? '' : `   (got: ${got ? 'exempt' : 'not exempt'})`));
+    }
+  }
+  // The block message must contain the marker, or a transcript-reading adapter
+  // cannot tell its own output from the human's next instruction.
+  const selfRecognised = reason('en', 'x').includes(SELF_ECHO);
+  ok &&= selfRecognised;
+  console.log(`  ${selfRecognised ? 'OK ' : 'x  '} block message carries the self-echo marker`);
+
+  console.log(`[${label}] self-test ${ok ? 'passed' : 'FAILED'}`);
+  return ok;
+}
+
+/**
+ * Print the languages this hook ships, and the R8 disclosure. Shared by every
+ * adapter's `--languages` so the installer's probeLanguageLimits() gets the
+ * same answer regardless of which tool's script it runs.
+ */
+export async function printLanguages() {
+  const { packs } = await loadPacks();
+  console.log(packs.map((p) => `${p.id} (${p.label})`).join('\n'));
+  console.log('\nThis check reads prose. If you work in a language not listed above,'
+    + '\nit is installed and running but cannot fire. See turn-completion-integrity R8.');
+}
+
+/** True if the given path exists — re-exported so adapters don't add their own fs import just for this. */
+export function pathExists(p) {
+  return !!p && existsSync(p);
+}

package/bundled/hooks/turn-completion/locales/en.mjs

@@ -46,6 +46,16 @@ const REPORTING =
 const ASKING =
   /(\bshould I\b|\bdo you want\b|\bwould you like\b|\bwhich (one|file|option)\b|\blet me know\b|\btell me\b|\bgive me\b|\bpaste\b|\bwaiting on you\b|\byour call\b|\bup to you\b|\?)/i;
 
+// "Once you pick, I'll ..." — the precondition is the human's decision, not a
+// request for information, so ASKING above never caught it (measured: the
+// zh-TW mirror of this shape fired as an unkept commitment). Grammar-based, not
+// a verb list, to match this pack's own design note above: "once/after/as soon
+// as you", up to 20 non-terminating characters, a comma, then "I".
+// Known limit, left uncovered on purpose rather than widened past this shape:
+// a version with no comma ("After you merged it I will …") still fires. See
+// the corpus entry below.
+const CONDITIONAL_ON_YOU = /\b(once|after|as soon as) you\b[^,.\n]{0,20},\s*I\b/i;
+
 /**
  * Expand contractions so the patterns below never have to fight an apostrophe.
  * Both the ASCII and typographic apostrophes appear in real transcripts.
@@ -96,7 +106,8 @@ export function isCommitment(sentence) {
 }
 
 export function isAsking(text) {
-  return ASKING.test(normalize(text));
+  const n = normalize(text);
+  return ASKING.test(n) || CONDITIONAL_ON_YOU.test(n);
 }
 
 /**
@@ -104,9 +115,18 @@ export function isAsking(text) {
  * here disables the check for the rest of the session, which is worse than a
  * missed block. It must read as an instruction to stop, not a mention of
  * stopping.
+ *
+ * 🔴 2026-09-27: `\bI'?m (heading|going) (home|out)\b` was dead code — it can
+ * never match, because isStopRequest() always calls normalize() first, and
+ * normalize() rewrites "I'm" to "I am" before this pattern ever sees the
+ * text (`\bI'll\b` -> "I will" etc. have the same shape, but no other branch
+ * here depended on the contracted form surviving normalize()). Verified: a
+ * bare "I'm heading out." tested false pre-fix, true once the pattern
+ * accounts for the post-normalize "I am" form. Written to match either form
+ * defensively, in case normalize()'s rewrite list ever changes.
  */
 const STOP_REQUEST =
-  /(\blet's (stop|pause|pick this up later)\b|\b(pause|stop) (here|for now|there)\b|\bhold (on|off)\b|\bthat's (enough|it) for (now|today)\b|\b(done|enough) for (now|today)\b|\bwrap (it |this )?up\b|\bcontinue (this )?later\b|\bpick (this|it) up (tomorrow|later)\b|\btake a break\b|\bI'?m (heading|going) (home|out)\b|\bgood ?night\b)/i;
+  /(\blet's (stop|pause|pick this up later)\b|\b(pause|stop) (here|for now|there)\b|\bhold (on|off)\b|\bthat's (enough|it) for (now|today)\b|\b(done|enough) for (now|today)\b|\bwrap (it |this )?up\b|\bcontinue (this )?later\b|\bpick (this|it) up (tomorrow|later)\b|\btake a break\b|\bI(?:'m| am) (heading|going) (home|out)\b|\bgood ?night\b)/i;
 
 export function isStopRequest(text) {
   return STOP_REQUEST.test(normalize(text));
@@ -142,6 +162,23 @@ export const corpus = [
   [false, 'legitimate stop: the next move is the human\'s', 'I will wait for your key before deploying.'],
   [false, 'conditional: asking in the same paragraph',
     'Tell me which file you meant and I will check it.'],
+  // 🔴 A third shape of conditional: the precondition is the human's decision,
+  // not a request for information or a report-back. Mirrors a false block
+  // measured in the zh-TW pack for the same grammar ("你選定後，我會…").
+  [false, 'conditional: once you pick, I will',
+    "Once you pick a model, I'll wire it into the config."],
+  [false, 'conditional: after you confirm, I will',
+    'After you confirm the plan, I will kick off the deploy.'],
+  [false, 'conditional: once you decide, I will',
+    'Once you decide, I will draft the ADR and file the tickets.'],
+  [true, 'subject is not you, still commits',
+    "After I fix this, I'll push it up."],
+  // Known limit, not fixed here: no comma between the precondition and "I"
+  // still fires. Widening past a comma risks swallowing real unkept
+  // commitments ("After you leave I will still ship it" has no comma either),
+  // so this stays a documented gap rather than a wider pattern.
+  [true, 'known limit: same shape, no comma — still fires',
+    'After you merged it I will follow up.'],
 ];
 
 /**
@@ -156,4 +193,15 @@ export const stopCorpus = [
   [false, 'mentions stopping but is not one', 'Explain why the hook stops the turn.'],
   [false, 'asks for work', 'Stop using the hardcoded list and walk the registry instead.'],
   [false, 'ordinary instruction', 'Fix the detector and push it.'],
+  // 🔴 the "I'm heading (home|out)" branch above was dead code before this
+  // fix — normalize() rewrites "I'm" to "I am" before the pattern is tested,
+  // and the pattern required the contracted form. This case exercises it
+  // directly (no "let's pause"/"hold on" alongside it, unlike the two cases
+  // above that already passed for a different reason).
+  [true, "bare 'heading out', no other stop phrase nearby", "I'm heading out."],
+  [false, 'a leaving verb alone is an instruction to finish something BEFORE leaving, not a stop request', 'Before I head out, please finish the migration.'],
 ];
+// Mutation check (verified by hand, then reverted — see commit/handback
+// notes): reverting STOP_REQUEST's `I(?:'m| am)` back to the dead-code
+// `I'?m`-only form turns the "bare 'heading out'" case above false, which
+// fails `--self-test`.

package/bundled/hooks/turn-completion/locales/zh-TW.mjs

@@ -44,7 +44,15 @@ const ASKING = new RegExp(
   // 「跟我說一聲，我會到 PC15 上確認」 — the precondition sat in a heading one paragraph up, so
   // the paragraph opens with the request. A report-back phrase, a comma, then 我 at once is
   // "you tell me, then I act". A report-back phrase alone does not qualify.
-  '|(跟我說|告訴我|回報我|讓我知道)(一聲)?[，,]\\s*我)'
+  '|(跟我說|告訴我|回報我|讓我知道)(一聲)?[，,]\\s*我' +
+  // 「你選定後，我會…」— the precondition is the human's decision, not a request
+  // for information or a report-back, so neither branch above caught it. Measured:
+  // fired as an unkept commitment. Narrow on purpose: literal 你, then 1-6 chars
+  // that are not another 我/你 or punctuation (a short decision verb — 選定/選好/
+  // 決定/確認/回覆/點頭 — not a whole clause), then 後, then a comma and 我. 你 with
+  // no 後 right after (「你選定的那份我會接著處理」) and 後 with no 你 right before
+  // (「改好後我接著合併」, 「他確認後，我會…」) must both still fall through and block.
+  '|你[^，,。\\n我你]{1,6}(之)?後[，,]\\s*我)'
 );
 
 // First person + future marker + action verb, within one sentence.
@@ -85,15 +93,28 @@ export function isAsking(text) {
   return ASKING.test(text);
 }
 
+// 🔴 2026-09-25 實測缺口：「我要出門了，等我回來再繼續」與「暫停，我要出門」
+// 都沒有被下面任何一支既有樣式接住——前者當天真的誤擋了一次真實的 Claude
+// Code 回合。R10 說叫停樣式放寬是危險方向（錯誤豁免會讓整個 session 的檢查
+// 失效），所以這裡刻意寫窄：離開類詞必須跟「稍後再續」或裸的「暫停」同時
+// 出現在同一小段裡，單獨出現的離開詞不算——「出門前把這三件做完」只有離開
+// 詞、沒有稍後再續，仍必須判 false（見下方 stopCorpus 的反例）。
+const LEAVING = '(出門|離開一下|先走)';
+const RESUME_LATER = '(等我回來|回來再|明天再|晚點再|待會再|待会再)';
+const LEAVE_THEN_LATER = `${LEAVING}[^。！？\\n]{0,12}${RESUME_LATER}|${RESUME_LATER}[^。！？\\n]{0,12}${LEAVING}`;
+const LEAVE_WITH_PAUSE = `暫停[^。！？\\n]{0,12}${LEAVING}|${LEAVING}[^。！？\\n]{0,12}暫停`;
+
 /**
  * The human asking for the turn to end. Kept narrow on purpose: a false
  * positive disables the check for the rest of the session.
  */
-const STOP_REQUEST =
+const STOP_REQUEST = new RegExp(
   // 🔴 `先停` 曾寫成裸的，而語料當場抓到「先**停用**那份硬編碼清單」——
   // 一句要求做事的指令被讀成叫我停。這個方向的誤判會把守衛整場關掉，
   // 所以 `停` 後面接得出動詞的字一律排除。
-  /(先暫停|暫停一下|先停(?![用止掉住])|停一下|先不要(做|動)|不用繼續|今天(先)?到這|先這樣|收工|下班|我要回家|明天再(說|弄|做)|改天再|先擱著|睡了|晚安)/;
+  '(先暫停|暫停一下|先停(?![用止掉住])|停一下|先不要(做|動)|不用繼續|今天(先)?到這|先這樣|收工|下班|我要回家|明天再(說|弄|做)|改天再|先擱著|睡了|晚安' +
+  `|${LEAVE_THEN_LATER}|${LEAVE_WITH_PAUSE})`
+);
 
 export function isStopRequest(text) {
   return STOP_REQUEST.test(text);
@@ -150,6 +171,26 @@ export const corpus = [
     '我先去確認有沒有新的發現。'],
   [true, '沒有要求回報的承諾（仍必須擋）',
     '設定檔已經改好了。我接著把驗證結果寫進規格，然後回報。'],
+  // 🔴 條件式承諾的第三種形狀：前提是使用者的決定，不是資訊或回報。
+  // 09-25 實測：「你選定後，我會…」被判成未兌現承諾（fired=true）。
+  [false, '條件式承諾：你選定後，我會…',
+    '你選定後，我會把這一輪的發想寫成正式決策紀錄，再分別派工給 UDS 和 EGR。'],
+  [false, '條件式承諾：你決定後',
+    '你決定後，我會接著把設定寫回 repo。'],
+  [false, '條件式承諾：你確認後',
+    '你確認後，我會把清單送出。'],
+  [false, '條件式承諾：你回覆後',
+    '你回覆後，我會接著處理。'],
+  [false, '條件式承諾：你選好後',
+    '你選好後，我會接著跑一次測試。'],
+  [false, '條件式承諾：你點頭後',
+    '你點頭後，我會接著把這份規格送出。'],
+  [true, '主詞不是你，仍必須擋——「後」在，但前面不是你',
+    '改好後我接著合併。'],
+  [true, '主詞不是你，仍必須擋——第三人稱的「後」',
+    '他確認後，我會把清單整理好。'],
+  [true, '你在句中，但後面沒有「後」，仍必須擋',
+    '你選定的那份我會接著處理。'],
 ];
 
 /**
@@ -163,4 +204,14 @@ export const stopCorpus = [
   [false, '提到停止但不是叫停', '解釋一下這支 hook 為什麼會擋下回合。'],
   [false, '要求做事而句中有停', '先停用那份硬編碼清單，改成走訪註冊表。'],
   [false, '一般指令', '把偵測器修好然後推上去。'],
+  // 🔴 2026-09-25 真實使用者原話——當時真的誤擋了一次回合，見上方 STOP_REQUEST 的註解。
+  [true, '離開＋稍後再續（真實原話）', '我要出門了，等我回來再繼續'],
+  [true, '暫停＋離開（真實原話）', '暫停，我要出門'],
+  // 窄性反例：單獨的離開詞、或單獨的「稍後」詞，都不算叫停——那是要求
+  // 「在離開前」把事情做完，不是要收掉這一輪。
+  [false, '離開詞單獨出現：這是要求離開前做完，不是叫停', '出門前把這三件做完'],
+  [false, '稍後詞單獨出現，沒有離開詞：一樣是要求先做完', '等我回來前先把測試跑完'],
 ];
+// 突變驗證（手動跑過、已還原——見 commit/交接紀錄）：把 STOP_REQUEST 的
+// `LEAVE_THEN_LATER`／`LEAVE_WITH_PAUSE` 兩個新分支拿掉，上面兩筆「真實原話」
+// 會變 false，`--self-test` 隨之變紅，證明這兩筆真的在測新加的規則。

package/bundled/locales/zh-CN/CHANGELOG.md

@@ -1,8 +1,8 @@
 ---
 source: ../../CHANGELOG.md
-source_version: 6.12.0
-translation_version: 6.12.0
-last_synced: 2026-09-24
+source_version: 6.13.0-beta.2
+translation_version: 6.13.0-beta.2
+last_synced: 2026-09-26
 status: current
 ---
 
@@ -17,6 +17,30 @@ status: current
 
 ## [Unreleased]
 
+## [6.13.0-beta.2] - 2026-09-26
+
+> **测试版** — 以 `npm install -g universal-dev-standards@beta` 安装。要测什么、已知限制、如何退回正式版：见 [docs/PRE-RELEASE.md](../../docs/PRE-RELEASE.md)。
+
+### 修复
+
+- **`uds uninstall` 从未移除 `installHooks()`／`installCodexHooks()`／`installGeminiHooks()` 写入的关卡——不只是 Codex 与 Gemini CLI（6.13.0-beta.1 记载的已知限制），Claude Code 自己的 `.claude/settings.json` 也有一模一样的缺口，而且从未被记录过。** `hooks` 这个 uninstall 分类原本只处理 `.husky/pre-commit` 与 `.git/hooks/pre-commit`；三个安装函数实际写入的配置文件完全没有任何 uninstaller 在管，导致每一个关卡在 `uds uninstall` 之后仍持续运行。新增的 `uninstallClaudeCodeHooks`／`uninstallCodexHooks`／`uninstallGeminiHooks`（`src/uninstallers/hook-uninstaller.js`）现在会精准移除 `.claude/settings.json`、`.codex/hooks.json`、`.gemini/settings.json` 里 UDS 安装的条目——判断依据是命令路径**加上**一份 UDS 目前确实有发布的脚本文件名清单，不是只看路径，这样用户自己放进 UDS 同一个 `scripts/hooks/` 目录下的 hook 就不会被误删。移除后变空的事件数组会一并从配置里移除；配置文件若因此变成完全空的对象（代表整份都是 UDS 写入的）就直接删除文件，否则保留文件并写回其余内容。JSON 格式损坏时报告错误并保持原样，不会覆写。已接入 `uds uninstall` 既有的 `hooks` 分类、`--dry-run` 预览，以及交互菜单里该分类的说明文字。
+- **Codex 适配层的 R9 豁免（「用户叫停就放行」）在真实 Codex 安装上从未真正生效过——`scripts/hooks/check-turn-completion-codex.mjs` 的 `bestEffortLastUserMessage()` 试过的两种记录形状都读不到字段。** 已对真实 codex-cli 0.156.1 的 `~/.codex/sessions/**/*.jsonl` 对话记录坐实：一条用户消息记录长这样——`{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":...}]}}`——消息位于 `payload` 之下，不在该条记录最外层、也不在 `message` 键下，所以该字段一直被读成不存在，R9 从未真正豁免过任何一轮 Codex 对话。现在优先读取 `payload.type === "message"`（其余记录类型若刚好用到原来那两种形状仍保留为后备），同时支持 `input_text` 内容项（与既有的 `text` 形状并存），且不把 `role: "developer"` 的记录当成用户消息。`core/turn-completion-integrity.md`「支持的执行环境」一节与 `docs/PRE-RELEASE.md` 已从「未对照真实安装验证过」更新为已坐实的真实形状。
+- **R9 的 zh-TW 叫停检测漏掉了「要离开、稍后再继续」这一族——已实测：「我要出门了，等我回来再继续」在 2026-09-25 真的误挡了一次 Claude Code 的对话完成关卡。** 这句与「暂停，我要出门」都没有被既有的任何一个 `STOP_REQUEST` 模式接住。新增两个窄模式：离开类词（出门／离开一下／先走）必须跟「稍后再续」类词（等我回来／回来再／明天再／晚点再／待会再）或裸的「暂停」同时出现在同一小段里——单独的离开词（例如「出门前把这三件做完」，这是要求离开前做完，不是叫停）语料仍必须判 false。顺手查了 en 语料包有没有同样的缺口，发现 `\bI'?m (heading|going) (home|out)\b` 是永远打不中的死代码：`isStopRequest()` 一律先调用 `normalize()`，会把 "I'm" 改写成 "I am"，只认缩写形式的模式因此永远匹配不到；已改为 `I(?:'m| am) (heading|going) (home|out)`，坐实裸的 "I'm heading out." 修复前为 false、修复后为 true。
+
+## [6.13.0-beta.1] - 2026-09-26
+
+> **测试版** — 以 `npm install -g universal-dev-standards@beta` 安装。要测什么、已知限制、如何退回正式版：见 [docs/PRE-RELEASE.md](../../docs/PRE-RELEASE.md)。已知限制：`uds uninstall` 尚不会移除 Codex／Gemini CLI 设置里的关卡。
+
+### 新增
+
+- **`turn-completion-integrity` 1.4.0 把 Stop 关卡推广到 Codex 与 Gemini CLI，与既有的 Claude Code 适配层并存。** 判断逻辑（语料包、冷却、滚动窗口、自我回音标记）抽到共用的 `turn-completion/engine.mjs`，三个工具脚本各自只转译自己工具的契约，不再各带一份判断逻辑。Codex（`.codex/hooks.json`，Stop 事件）直接从 stdin 读取 `last_assistant_message`，在 exit 0 时于 stdout 输出 `{"decision":"block","reason":...}` 来拦截——官方文档写明这个事件纯文本或空输出无效，这点与 Claude Code「沉默即放行」不同；用户的最后一条消息用 `transcript_path` 尽力读取，因为其确切格式未对照真实安装验证过，所以 R9（豁免用户主动喊停的回合）在 Codex 上是文档记载的已知落差，不是静默失效。Gemini CLI（`.gemini/settings.json`，`AfterAgent` 事件）的 stdin 直接给出 `prompt` 与 `prompt_response`，完全不需要解析对话记录，拦截方式是 `{"decision":"deny","reason":...}`——官方文档标记为优先于 exit code 2 的做法。`uds init --with-hooks` 现在也会调用 `installCodexHooks`／`installGeminiHooks`，门槛是采用者有没有选那个工具，没用到 Codex 或 Gemini CLI 的项目不会被写入任何东西。Cursor 已评估，明确标记为不支持（Cursor 的 stop hook 能不能真的拦下一个回合仍未确定）。见[支持的执行环境](../../core/turn-completion-integrity.md#supported-harnesses)与 [CLI-INIT-OPTIONS.md](../../docs/CLI-INIT-OPTIONS.md#claude-code-以外的强制执行-hooks)。
+
+- **`developer-memory` 1.2.0：新增 `code-reference` 过期检查——记忆引用的文件路径或符号一旦搬走或不存在，浮现前就会被标记，不再被悄悄沿用。** 沿用 `knowledge-graph-memory` 1.0.0 已定义的双模式（§2），不另外发明第三种：降级模式（没有图引擎——AI 自己用 Glob／Grep／Read 确认引用还在，与既有的记忆验证原则同一套机制）与引擎模式（有图引擎时，例如 EngramGraph 的 `egr refs check`，报告每个引用的状态：`present`／`moved`（附新位置）／`missing`／`unresolvable`）。`unresolvable` 一律不得当成 `present` 或 `missing`——它代表检查器无法判断，不是引用没事或已消失。时机挂在既有的 `proactive-surfacing` 规则（§4.1），检查在记忆浮现**之前**进行，不是之后。第一批只涵盖文件路径与符号名称（函数／类）；`file:line` 明确排除在外——行号会随任何不相关的编辑漂移，属于不同种类的过期（见 DEC-115 OQ-1，2027-01-31 前重新评估）。`core/developer-memory.md` §11 加入一段非规范性的 Claude Code `SessionStart` hook 范例；其他工具则改走各自 repo 的说明文件（CLAUDE.md／AGENTS.md／.cursorrules 等）。（DEC-115-L1）
+
+### 修复
+
+- **`turn-completion-integrity` 的 zh-TW 与 en 检测器，会在前提是用户自己决定的条件式承诺上误拦。** 「你选定后，我会把这一轮的发想写成正式决策记录…」被判成未兑现的承诺——既有的豁免只涵盖「要求信息」与「要求回报」，没有涵盖「前提是用户的决定」这种条件句。zh-TW 新增一个窄模式：你 + 短决定动词（选定/选好/决定/确认/回覆/点头）+ 后 + 逗号 + 我；en 新增以语法为准（不是动词清单，延续本包既有设计）的 `(once|after|as soon as) you ..., I` 模式。两份语料都补了成对的反例（主语不是你/you，或只有一半的形状），证明收窄没有连带漏拦真的未兑现承诺；en 版本也记下一个刻意留下未解的已知限制（前提与 "I" 之间没有逗号时仍会误拦——放宽会漏拦真的未兑现承诺）。
+
 ## [6.12.0] - 2026-09-25
 
 ### 新增