universal-dev-standards 6.11.0 → 6.13.0-beta.1

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);
 }
 
 /**
@@ -142,6 +153,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.'],
 ];
 
 /**

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.
@@ -150,6 +158,26 @@ export const corpus = [
     '我先去確認有沒有新的發現。'],
   [true, '沒有要求回報的承諾（仍必須擋）',
     '設定檔已經改好了。我接著把驗證結果寫進規格，然後回報。'],
+  // 🔴 條件式承諾的第三種形狀：前提是使用者的決定，不是資訊或回報。
+  // 09-25 實測：「你選定後，我會…」被判成未兌現承諾（fired=true）。
+  [false, '條件式承諾：你選定後，我會…',
+    '你選定後，我會把這一輪的發想寫成正式決策紀錄，再分別派工給 UDS 和 EGR。'],
+  [false, '條件式承諾：你決定後',
+    '你決定後，我會接著把設定寫回 repo。'],
+  [false, '條件式承諾：你確認後',
+    '你確認後，我會把清單送出。'],
+  [false, '條件式承諾：你回覆後',
+    '你回覆後，我會接著處理。'],
+  [false, '條件式承諾：你選好後',
+    '你選好後，我會接著跑一次測試。'],
+  [false, '條件式承諾：你點頭後',
+    '你點頭後，我會接著把這份規格送出。'],
+  [true, '主詞不是你，仍必須擋——「後」在，但前面不是你',
+    '改好後我接著合併。'],
+  [true, '主詞不是你，仍必須擋——第三人稱的「後」',
+    '他確認後，我會把清單整理好。'],
+  [true, '你在句中，但後面沒有「後」，仍必須擋',
+    '你選定的那份我會接著處理。'],
 ];
 
 /**

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

@@ -1,8 +1,8 @@
 ---
 source: ../../CHANGELOG.md
-source_version: 6.11.0
-translation_version: 6.11.0
-last_synced: 2026-09-18
+source_version: 6.13.0-beta.1
+translation_version: 6.13.0-beta.1
+last_synced: 2026-09-25
 status: current
 ---
 
@@ -17,6 +17,26 @@ status: current
 
 ## [Unreleased]
 
+## [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
+
+### 新增
+
+- **新标准 `open-work-tracking`——`deferred-item-exit` 的下游一半。** `deferred-item-exit` 要求被推迟的条目离开原文件、走向可追溯的出口，但刻意不规定出口的承载处；条目进入承载处之后，没有任何规则防止承载处本身腐坏。本标准以 16 条要求（OWT-001～016）补上：低摩擦的记录点（必填字段至多两个）、每个等待中的条目旁写明解除条件、可推导的字段由生成而非手写、以内容证明"最新"而非可随手改的时间戳、覆盖率数字要写出它看不到什么，以及每轮结束时报告未完成工作但**从不阻挡**的检查点。最后一点刻意与挂在同一事件、会阻挡的 `turn-completion-integrity` 相反；标准内附对照表，避免采用者把两者接成同一件事。其中两个数字门槛标明为初始判断、非测量结果。
+
 ## [6.11.0] - 2026-09-18
 
 ### 修复

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

@@ -14,7 +14,7 @@ status: current
 
 Universal Development Standards 是一个语言无关、框架无关的文件化标准框架。它提供：
 
-- **核心规范** (`core/`)：152 个基础开发标准
+- **核心规范** (`core/`)：153 个基础开发标准
 - **AI 技能** (`skills/`)：用于 AI 辅助开发的 Claude Code 技能
 - **CLI 工具** (`cli/`)：用于采用标准的 Node.js CLI
 - **整合** (`integrations/`)：各种 AI 工具的配置

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

@@ -15,7 +15,7 @@ status: current
 
 > **语言**: [English](../../README.md) | [繁體中文](../zh-TW/README.md) | 简体中文
 
-**版本**: 6.11.0 | **发布日期**: 2026-09-16 | **授权**: [双重授权](../../LICENSE) (CC BY 4.0 + MIT)
+**版本**: 6.13.0-beta.1 (Pre-release) | **发布日期**: 2026-09-26 | **授权**: [双重授权](../../LICENSE) (CC BY 4.0 + MIT)
 
 语言无关、框架无关的软件项目文档标准。通过 AI 原生工作流，确保不同技术栈之间的一致性、质量和可维护性。
 
@@ -76,7 +76,7 @@ npx universal-dev-standards init
 <!-- UDS_STATS_TABLE_START -->
 | 类别 | 数量 | 说明 |
 |----------|-------|-------------|
-| **核心标准** | 152 | 通用开发准则 |
+| **核心标准** | 153 | 通用开发准则 |
 | **AI Skills** | 55 | 互动式技能 |
 | **斜线命令** | 51 | 快速操作 |
 | **CLI 命令** | 23 | 项目设置与维护 |

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

@@ -13,7 +13,8 @@ status: current
 <!-- UDS_SUPPORTED_VERSIONS_START -->
 | 版本 | 支持状态 |
 |------|--------|
-| 6.11.0 | ✅ 最新正式版 |
+| 6.13.0-beta.1 | ✅ 预发布版本 |
+| 6.12.0 | ✅ 最新正式版 |
 | < 6.0.0 | ❌ 已终止支持 |
 <!-- UDS_SUPPORTED_VERSIONS_END -->