@ngockhoale/ukit 3.4.79 → 3.4.82

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -113,6 +113,31 @@ export function runInstallAfterUpdate({
113
113
  return { ran: true, reason: null };
114
114
  }
115
115
 
116
+ /**
117
+ * Refresh the user-scoped Codex advisor with the freshly installed global package when no
118
+ * project install ran (that install already refreshes it). Advisory: never throws.
119
+ */
120
+ export function runAdvisorRefreshAfterUpdate({
121
+ spawnSync = defaultSpawnSync,
122
+ execPath = process.execPath,
123
+ } = {}) {
124
+ try {
125
+ const { binPath } = resolveGlobalUkitBinDetailed({ spawnSync });
126
+ if (!binPath) return { ran: false, reason: 'global-bin-not-found' };
127
+ // --refresh-only: upgrade an advisor UKit already installed; never seed it for users
128
+ // who did not select the Codex adapter.
129
+ const result = spawnSync(execPath, [binPath, 'advisor', 'install', '--refresh-only'], {
130
+ stdio: 'inherit',
131
+ timeout: NPM_QUERY_TIMEOUT_MS,
132
+ killSignal: KILL_ON_TIMEOUT,
133
+ });
134
+ if (result.error) return { ran: false, reason: result.error.message };
135
+ return { ran: result.status === 0, reason: result.status === 0 ? null : `exited-${result.status}` };
136
+ } catch (error) {
137
+ return { ran: false, reason: error?.message ?? String(error) };
138
+ }
139
+ }
140
+
116
141
  export function updateUkit({ spawnSync = defaultSpawnSync } = {}) {
117
142
  const result = spawnNpm(['install', '-g', UKIT_PACKAGE_NAME], {
118
143
  stdio: 'inherit',
@@ -1205,8 +1205,16 @@ export function classifyAdvisorRequest({ promptText = '', commandText = '' } = {
1205
1205
  // Used by hasAdvisoryOnlyAssertion (assertion + no order → advisory) and by
1206
1206
  // the question-shape gate below (question + no order → consult, even when the
1207
1207
  // subject vocabulary fires debug/failure/implement signal scores).
1208
+ // Tone-folding turns unrelated Vietnamese words into mutation verbs: "cái" (this/thing) -> cai (cài),
1209
+ // "chính" (main/exactly) -> chinh (chỉnh), "Việt" -> viet (viết), "đợi/đời/đối/đội/đôi/đói" -> doi (đổi),
1210
+ // "cháy/chảy" -> chay (chạy), "sữa" -> sua (sửa), "thèm" -> them (thêm). Mask the toned non-verbs BEFORE
1211
+ // folding, so "Cái này là gì, tại sao…" is not read as an install order (3.4.81 telemetry audit).
1212
+ function maskTonedNonVerbs(text = '') {
1213
+ return String(text ?? '').normalize('NFC')
1214
+ .replace(/(?<![\p{L}\p{N}_])(?:cái|chính|việt|cháy|chảy|đợi|đời|đối|đội|đôi|đói|sữa|thèm)(?![\p{L}\p{N}_])/giu, ' _ ');
1215
+ }
1208
1216
  function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
1209
- const folded = `${promptText ?? ''}\n${commandText ?? ''}`
1217
+ const folded = `${maskTonedNonVerbs(promptText)}\n${commandText ?? ''}`
1210
1218
  .toLowerCase()
1211
1219
  .normalize('NFD')
1212
1220
  .replace(/[\u0300-\u036f]/g, '')
@@ -1255,6 +1263,11 @@ function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
1255
1263
  .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
1256
1264
  // 'đối chiếu' (cross-check) folds to 'doi chieu' and is not the verb 'đổi' (change).
1257
1265
  .replace(/\bdoi\s+chieu\b/g, ' ')
1266
+ // Field telemetry (3.4.81 audit): words that fold onto a mutation verb but name no order.
1267
+ // "chưa được cấp quyền cập nhật" / "no permission to update" reports a missing permission (read-only
1268
+ // banners); "gì thêm [nữa]" / "thêm nữa không" mean "anything else", never the verb "add".
1269
+ .replace(/\b(?:(?:chua|khong)\s+(?:duoc\s+)?(?:cap\s+|co\s+)?quyen|(?:no|not\s+have|without|lacks?)\s+permission\s+to)\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![a-z0-9_])/g, ' ')
1270
+ .replace(/(?<=\b(?:con|co)\b[^.?!,;:\n]{0,40})\b(?:gi|nao)\s+them(?:\s+nua)?(?:\s+(?:khong|ko))?\s*(?=[?.!,;:\n]|$)|\bthem\s+nua\s+(?:khong|ko)\s*(?=[?.!\n]|$)/g, ' ')
1258
1271
  // R2: a deferred/future clause ("chua sua", "how we would later implement", "R2 onward: ...",
1259
1272
  // "fix strategy ...") describes work for a LATER round, not an order for this turn.
1260
1273
  .replace(new RegExp(`\\bchua\\s+(?:sua|fix|implement|trien\\s+khai|viet|thay\\s+doi)\\b${WAIT_TAIL}`, 'g'), ' ')
@@ -1345,6 +1358,11 @@ function deriveExecutionMode({
1345
1358
  const questionShapedPrompt = /\?\s*$/.test(trimmedPromptText)
1346
1359
  || leadingInterrogative
1347
1360
  || /\b(?:la gi|duoc khong)\s*$/.test(foldedPromptText)
1361
+ // Field telemetry (3.4.81 audit): a what-is question mid-prompt ("… là gì, …") and a leading
1362
+ // explanation request ("giải thích …", "explain …") ask for an answer. Both still pass the
1363
+ // hasMutationOrder/targetFile veto below, so "giải thích rồi sửa luôn" stays an order.
1364
+ || /\bla gi\s*(?:[,.?!;:\n]|$)/.test(foldedPromptText)
1365
+ || /^(?:hay\s+|vui\s+long\s+|lam\s+on\s+|please\s+)?(?:giai\s+thich|explain)\b/.test(foldedPromptText)
1348
1366
  // C85-019: Vietnamese status/consult tails without a '?' — "… chưa",
1349
1367
  // "… chưa nhỉ", "… không nhỉ", "… đúng không". A question about a defect
1350
1368
  // must not mint the bug-fix floor's write/repro debt.
@@ -54,8 +54,7 @@ else
54
54
  __ukit_waiter=$!
55
55
  wait "$__ukit_reader" 2>/dev/null
56
56
  __ukit_stage_rc=$?
57
- kill "$__ukit_waiter" 2>/dev/null
58
- wait "$__ukit_waiter" 2>/dev/null
57
+ { kill "$__ukit_waiter"; wait "$__ukit_waiter"; } 2>/dev/null
59
58
  exec 8<&-
60
59
  __ukit_size="$(wc -c < "$UKIT_INPUT_FILE" 2>/dev/null | tr -d '[:space:]')"
61
60
  if [ "$__ukit_stage_rc" -ne 0 ] || [ "$__ukit_size" -gt 2097152 ]; then
@@ -87,34 +86,86 @@ fi
87
86
  __ukit_coord_out="$(mktemp "${TMPDIR:-/tmp}/ukit-coord-out.XXXXXX")"
88
87
  __ukit_coord_err="$(mktemp "${TMPDIR:-/tmp}/ukit-coord-err.XXXXXX" 2>/dev/null)" || __ukit_coord_err=/dev/null
89
88
  __ukit_coord_t0=$SECONDS
90
- printf '%s' "$INPUT" | UKIT_HARNESS="${UKIT_HARNESS:-claude-code}" UKIT_HOOK_DEADLINE_MS="${UKIT_HOOK_DEADLINE_MS:-3000}" node "$SCRIPT" --evaluate-stop > "$__ukit_coord_out" 2>"$__ukit_coord_err" &
89
+ printf '%s' "$INPUT" | UKIT_HARNESS="${UKIT_HARNESS:-claude-code}" UKIT_HOOK_DEADLINE_MS="${UKIT_HOOK_DEADLINE_MS:-5000}" node "$SCRIPT" --evaluate-stop > "$__ukit_coord_out" 2>"$__ukit_coord_err" &
91
90
  __ukit_coord_pid=$!
92
- __ukit_coord_ms="${UKIT_HOOK_DEADLINE_MS:-3000}"
93
- case "$__ukit_coord_ms" in ''|*[!0-9]*) __ukit_coord_ms=3000 ;; esac
91
+ __ukit_coord_ms="${UKIT_HOOK_DEADLINE_MS:-5000}"
92
+ case "$__ukit_coord_ms" in ''|*[!0-9]*) __ukit_coord_ms=5000 ;; esac
94
93
  __ukit_coord_ms=$((__ukit_coord_ms + 1500))
95
94
  printf -v __ukit_coord_s '%d.%03d' $((__ukit_coord_ms / 1000)) $((__ukit_coord_ms % 1000))
96
95
  ( sleep "$__ukit_coord_s" 2>/dev/null; kill -9 "$__ukit_coord_pid" 2>/dev/null ) <&- >/dev/null 2>&1 &
97
96
  __ukit_killer_pid=$!
98
97
  wait "$__ukit_coord_pid" 2>/dev/null
99
98
  STATUS=$?
100
- kill "$__ukit_killer_pid" 2>/dev/null
101
- wait "$__ukit_killer_pid" 2>/dev/null
99
+ # One redirect around both: bash 3.2 can reap the killed job between the two commands and would print its
100
+ # "Terminated: 15" job notice on the hook's stderr.
101
+ { kill "$__ukit_killer_pid"; wait "$__ukit_killer_pid"; } 2>/dev/null
102
102
  OUTPUT="$(cat "$__ukit_coord_out" 2>/dev/null)"
103
103
  rm -f "$__ukit_coord_out"
104
- # Bounded diagnostic for a crashed coordinator (status>128 = killed by signal N-128, e.g. 137 = the deadline killer's SIGKILL).
104
+ # A coordinator that exits 0 but could not get a verdict out of the completion evaluator (killed at its time
105
+ # slice, hook deadline hit, evaluator crashed) answers with a fixed fail-closed block. Field telemetry: on a
106
+ # loaded machine one session took 170+ such blocks in a row — nothing the agent can do changes the outcome, so
107
+ # every block is a wasted turn. It is the same infrastructure failure as a crashed coordinator and shares its
108
+ # consecutive-failure breaker. The marker is JSON structure (a quote inside a reason string is escaped), so
109
+ # reason text can never forge it.
110
+ INFRA_BLOCK=0
111
+ if [ "$STATUS" -eq 0 ]; then
112
+ case "$OUTPUT" in *'"policyOwner":"fail-closed"'*) INFRA_BLOCK=1 ;; esac
113
+ # A handoff-cursor or task-watchdog block riding on the same decision is a real verdict about unfinished
114
+ # work: never count it toward a release (those lanes own their own stall breakers).
115
+ case "$OUTPUT" in *'also requested a block: '*) INFRA_BLOCK=0 ;; esac
116
+ fi
117
+ # Bounded diagnostic for a failed evaluation (status>128 = killed by signal N-128, e.g. 137 = the deadline killer's SIGKILL).
105
118
  # Written to a private cache file only; never part of the decision text (the reason stays fixed and redacted).
106
- if [ "$STATUS" -ne 0 ]; then
119
+ if [ "$STATUS" -ne 0 ] || [ "$INFRA_BLOCK" -eq 1 ]; then
107
120
  mkdir -p "$PROJECT_ROOT/.ukit/storage/cache" 2>/dev/null
108
121
  { printf 'status=%s elapsed_s=%s deadline_ms=%s\n' "$STATUS" "$((SECONDS - __ukit_coord_t0))" "${__ukit_coord_ms}"; head -c 400 "$__ukit_coord_err" 2>/dev/null; printf '\n'; } > "$PROJECT_ROOT/.ukit/storage/cache/completion-gate-crash.last" 2>/dev/null
109
122
  fi
110
123
  [ "$__ukit_coord_err" = /dev/null ] || rm -f "$__ukit_coord_err"
111
124
 
125
+ CACHE_DIR="$PROJECT_ROOT/.ukit/storage/cache"
126
+ SESSION_KEY="$(printf '%s' "$INPUT" | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1 | tr -c 'A-Za-z0-9_-' '_' | cut -c1-80)"
127
+ [ -n "$SESSION_KEY" ] || SESSION_KEY="unknown"
128
+ INFRA_FILE="$CACHE_DIR/completion-gate-infra.$SESSION_KEY.streak"
129
+ if [ "$INFRA_BLOCK" -eq 1 ]; then
130
+ # Evaluator-failure breaker. Separate from the crash breaker below on purpose:
131
+ # - keyed per session, so one session's failures never count toward releasing another;
132
+ # - one epoch stamp per failure, and a release needs BOTH more than the cap of consecutive failures AND
133
+ # at least INFRA_MIN_SPAN_S of wall clock between the first failure and this one — an agent that
134
+ # simply stops again a few times in a row cannot talk its way out;
135
+ # - the release is announced as a blocked, non-complete outcome, never as a pass.
136
+ INFRA_MIN_SPAN_S=120
137
+ mkdir -p "$CACHE_DIR" 2>/dev/null
138
+ NOW_S="$(date +%s)"
139
+ # Consecutive means close in time as well: a failure left over from an earlier burst (the session then
140
+ # sat idle with no real verdict to clear it) must not lend its age to a new burst of quick stops.
141
+ INFRA_MAX_GAP_S=600
142
+ LAST_S="$(grep '^[0-9][0-9]*$' "$INFRA_FILE" 2>/dev/null | tail -1)"
143
+ case "$LAST_S" in ''|*[!0-9]*) LAST_S="$NOW_S" ;; esac
144
+ [ $((NOW_S - LAST_S)) -le "$INFRA_MAX_GAP_S" ] || : > "$INFRA_FILE" 2>/dev/null
145
+ printf '%s\n' "$NOW_S" >> "$INFRA_FILE" 2>/dev/null
146
+ STREAK="$(grep -c '^[0-9][0-9]*$' "$INFRA_FILE" 2>/dev/null)"
147
+ case "$STREAK" in ''|*[!0-9]*) STREAK=1 ;; esac
148
+ FIRST_S="$(grep -m1 '^[0-9][0-9]*$' "$INFRA_FILE" 2>/dev/null)"
149
+ case "$FIRST_S" in ''|*[!0-9]*) FIRST_S="$NOW_S" ;; esac
150
+ MAX_STREAK="$(sed -n 's/.*"stopGateMaxCrashStreaks"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$PROJECT_ROOT/.ukit/storage/config.json" 2>/dev/null | head -1)"
151
+ case "$MAX_STREAK" in ''|*[!0-9]*) MAX_STREAK=3 ;; esac
152
+ SPAN_S=$((NOW_S - FIRST_S))
153
+ if [ "$STREAK" -gt "$MAX_STREAK" ] && [ "$SPAN_S" -ge "$INFRA_MIN_SPAN_S" ]; then
154
+ : > "$INFRA_FILE" 2>/dev/null
155
+ printf '%s\n' '{"systemMessage":"UKit stop coordinator released this stop after '"$STREAK"' consecutive stops over '"$SPAN_S"'s on which the completion evaluator could not finish (out of time or failed — usually a busy machine or slow disk). Completion was NOT verified: this is a blocked, non-complete outcome, not a pass — do not report the task as done on the strength of this release. If this keeps happening on an idle machine, run `ukit install`.","outcome":"blocked","complete":false}'
156
+ exit 0
157
+ fi
158
+ # Under the cap: the coordinator's own fixed, redacted block goes through unchanged.
159
+ printf '%s\n' "$OUTPUT"
160
+ exit 0
161
+ fi
162
+
112
163
  if [ "$STATUS" -ne 0 ]; then
113
- # BUG-C22-05: a PERSISTENT coordinator crash must not block every Stop forever.
114
- # Byte-append one marker per crash; a clean run deletes the file, so the count
115
- # is consecutive crashes, not lifetime crashes. File-based (no node) so the
164
+ # BUG-C22-05: a PERSISTENT infrastructure failure must not block every Stop forever.
165
+ # Byte-append one marker per failure; a clean run deletes the file, so the count
166
+ # is consecutive failures, not lifetime failures. File-based (no node) so the
116
167
  # breaker still works when node itself is what is crashing.
117
- CRASH_FILE="$PROJECT_ROOT/.ukit/storage/cache/completion-gate-crash.streak"
168
+ CRASH_FILE="$CACHE_DIR/completion-gate-crash.streak"
118
169
  mkdir -p "$(dirname "$CRASH_FILE")" 2>/dev/null
119
170
  printf '.' >> "$CRASH_FILE" 2>/dev/null
120
171
  STREAK="$(wc -c < "$CRASH_FILE" 2>/dev/null | tr -d '[:space:]')"
@@ -135,8 +186,10 @@ if [ "$STATUS" -ne 0 ]; then
135
186
  exit 0
136
187
  fi
137
188
 
138
- # A clean coordinator run resets the consecutive-crash streak.
139
- rm -f "$PROJECT_ROOT/.ukit/storage/cache/completion-gate-crash.streak" 2>/dev/null
189
+ # A real verdict resets both consecutive-failure counts: the crash streak, and THIS session's
190
+ # evaluator-failure streak (other sessions keep theirs).
191
+ rm -f "$CACHE_DIR/completion-gate-crash.streak" 2>/dev/null
192
+ [ -s "$INFRA_FILE" ] && : > "$INFRA_FILE" 2>/dev/null
140
193
 
141
194
  if [ -n "$OUTPUT" ]; then
142
195
  printf '%s\n' "$OUTPUT"
@@ -2908,6 +2908,9 @@ function applyTaskSemantics(contract, semantic) {
2908
2908
  'hi', 'hello', 'hey', 'yo', 'chao', 'xin', 'good',
2909
2909
  'morning', 'afternoon', 'evening',
2910
2910
  'thanks', 'thank', 'cam', 'on', 'bye', 'tam', 'biet',
2911
+ // Bare acknowledgements ("ok", "có", "được rồi", "yes") are social turns, not work orders:
2912
+ // they must never mint a fresh implementation contract (3.4.81 audit).
2913
+ 'ok', 'okay', 'oke', 'yes', 'yep', 'yeah', 'co', 'duoc', 'vang', 'da', 'u', 'uh', 'um', 'roi', 'dong', 'y',
2911
2914
  ]);
2912
2915
  const filler = new Set([
2913
2916
  'you', 'u', 'there', 'guys', 'everyone', 'all',
@@ -2915,7 +2918,11 @@ function applyTaskSemantics(contract, semantic) {
2915
2918
  'ok', 'okay', 'again', 'still',
2916
2919
  ]);
2917
2920
  let coreHit = false;
2918
- for (const token of tokens) {
2921
+ for (let i = 0; i < tokens.length; i += 1) {
2922
+ const token = tokens[i];
2923
+ // Tone-folding makes "đóng" (close) and "đồng" (as in "đồng ý", agreed) the same token:
2924
+ // only the pair "dong y" is an acknowledgement; "đóng nhé" is an order to close something.
2925
+ if (token === 'dong' && tokens[i + 1] !== 'y') return false;
2919
2926
  if (core.has(token)) {
2920
2927
  coreHit = true;
2921
2928
  } else if (!filler.has(token)) {
@@ -2992,8 +2999,16 @@ function applyTaskSemantics(contract, semantic) {
2992
2999
  return !mutationOrder;
2993
3000
  }
2994
3001
 
3002
+ // Tone-folding turns unrelated Vietnamese words into mutation verbs: "cái" (this/thing) -> cai (cài),
3003
+ // "chính" (main/exactly) -> chinh (chỉnh), "Việt" -> viet (viết), "đợi/đời/đối/đội/đôi/đói" -> doi (đổi),
3004
+ // "cháy/chảy" -> chay (chạy), "sữa" -> sua (sửa), "thèm" -> them (thêm). Mask the toned non-verbs BEFORE
3005
+ // folding, so "Cái này là gì, tại sao…" is not read as an install order (3.4.81 telemetry audit).
3006
+ function maskTonedNonVerbs(text = '') {
3007
+ return String(text ?? '').normalize('NFC')
3008
+ .replace(/(?<![\p{L}\p{N}_])(?:cái|chính|việt|cháy|chảy|đợi|đời|đối|đội|đôi|đói|sữa|thèm)(?![\p{L}\p{N}_])/giu, ' _ ');
3009
+ }
2995
3010
  function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
2996
- const folded = `${publicationScope(promptText).text}\n${commandText ?? ''}`
3011
+ const folded = `${publicationScope(maskTonedNonVerbs(promptText)).text}\n${commandText ?? ''}`
2997
3012
  .toLowerCase()
2998
3013
  .normalize('NFD')
2999
3014
  .replace(/[\u0300-\u036f]/g, '')
@@ -3029,6 +3044,11 @@ function applyTaskSemantics(contract, semantic) {
3029
3044
  .replace(new RegExp(`\\bchua\\s+(?:can|nen|phai)\\s+${WAIT_TAIL}`, 'g'), ' ')
3030
3045
  .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
3031
3046
  .replace(/\bdoi\s+chieu\b/g, ' ')
3047
+ // Field telemetry (3.4.81 audit): words that fold onto a mutation verb but name no order.
3048
+ // "chưa được cấp quyền cập nhật" / "no permission to update" reports a missing permission (read-only
3049
+ // banners); "gì thêm [nữa]" / "thêm nữa không" mean "anything else", never the verb "add".
3050
+ .replace(/\b(?:(?:chua|khong)\s+(?:duoc\s+)?(?:cap\s+|co\s+)?quyen|(?:no|not\s+have|without|lacks?)\s+permission\s+to)\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![a-z0-9_])/g, ' ')
3051
+ .replace(/(?<=\b(?:con|co)\b[^.?!,;:\n]{0,40})\b(?:gi|nao)\s+them(?:\s+nua)?(?:\s+(?:khong|ko))?\s*(?=[?.!,;:\n]|$)|\bthem\s+nua\s+(?:khong|ko)\s*(?=[?.!\n]|$)/g, ' ')
3032
3052
  .replace(new RegExp(`\\bchua\\s+(?:sua|fix|implement|trien\\s+khai|viet|thay\\s+doi)\\b${WAIT_TAIL}`, 'g'), ' ')
3033
3053
  .replace(/\bhow\s+(?:we|i|you|they)\s+(?:would|will|could|should|might)\b[^.,;\n?]*/g, ' ')
3034
3054
  .replace(/\b(?:would|will|could|might)\s+later\b[^.,;\n?]*/g, ' ')
@@ -3212,6 +3232,11 @@ function applyTaskSemantics(contract, semantic) {
3212
3232
  const questionShapedPrompt = /\?\s*$/.test(trimmedPromptText)
3213
3233
  || leadingInterrogative
3214
3234
  || /\b(?:la gi|duoc khong)\s*$/.test(foldedPromptText)
3235
+ // Field telemetry (3.4.81 audit): a what-is question mid-prompt ("… là gì, …") and a leading
3236
+ // explanation request ("giải thích …", "explain …") ask for an answer. Both still pass the
3237
+ // hasMutationOrder/targetFile veto below, so "giải thích rồi sửa luôn" stays an order.
3238
+ || /\bla gi\s*(?:[,.?!;:\n]|$)/.test(foldedPromptText)
3239
+ || /^(?:hay\s+|vui\s+long\s+|lam\s+on\s+|please\s+)?(?:giai\s+thich|explain)\b/.test(foldedPromptText)
3215
3240
  || /\b(?:chua|duoc khong|dung khong|khong nhi|khong|nhi)\s*[.!?]*\s*$/.test(foldedPromptText);
3216
3241
  // it with hasMutationOrder keeps "sửa file cho tôi?" mutating while
3217
3242
  // "lỗi này chưa nhỉ" / "should I fix the hook?" consult. A targetFile
@@ -4518,9 +4543,19 @@ function applyTaskSemantics(contract, semantic) {
4518
4543
  if (fresh?.taskKind) {
4519
4544
  const identity = semanticContractIdentity({ promptText: previous.routingContext.lastExplicitUserPromptText,
4520
4545
  targetFile: persisted.routingContext?.targetFile || '', taskInstanceId });
4521
- const comparison = compareSemanticContracts({ stored: storedContract,
4522
- fresh: applyTaskSemantics(buildExecutionContract(persisted.routeSummary?.executionMode || 'local-build'), fresh),
4523
- previousIdentity: previous.semanticIdentity, identity });
4546
+ // The execution mode is re-scored on every tool event while the contract stays the task's own, so
4547
+ // the mode of THIS event is not the mode the contract was derived under. A stored contract is
4548
+ // consistent when it equals the derivation under any mode base (telemetry: 170+ false
4549
+ // "invariant violation" Stop blocks from mode churn alone).
4550
+ const derive = (mode) => compareSemanticContracts({ stored: storedContract,
4551
+ fresh: applyTaskSemantics(buildExecutionContract(mode), fresh), previousIdentity: previous.semanticIdentity, identity });
4552
+ let comparison = derive(persisted.routeSummary?.executionMode || 'local-build');
4553
+ if (comparison.status === 'invariant-violation') {
4554
+ for (const mode of ['tiny-fix', 'local-fix', 'local-build', 'find-cause', 'shared-edit', 'map-impact', 'review-release']) {
4555
+ const other = derive(mode);
4556
+ if (other.status === 'equal') { comparison = other; break; }
4557
+ }
4558
+ }
4524
4559
  if (comparison.status === 'invariant-violation') persisted.semanticDiagnostic = comparison;
4525
4560
  else if (comparison.status !== 'equal') semanticFromPrompt = fresh;
4526
4561
  }
@@ -4541,7 +4576,12 @@ function applyTaskSemantics(contract, semantic) {
4541
4576
  && (semantic.taskKind === 'CODE_IMPLEMENTATION' || answerQuestion)
4542
4577
  && (isInformationalPrompt({ promptText: turnPrompt })
4543
4578
  || isPureGreetingPrompt({ promptText: turnPrompt }));
4544
- const unownedToolTurn = !extractPrompt(payload) && payload.tool_name && !storedContract;
4579
+ // A system-injected turn (wakeup / compaction summary) resumes the previous task; when that task holds
4580
+ // no contract (the owner's last turn was a question), the injected wording must not mint one: it was
4581
+ // classified from the wakeup text but bound to the owner's prompt identity, which the gate then
4582
+ // reported as a contradiction on every stop.
4583
+ const unownedToolTurn = (!extractPrompt(payload) && payload.tool_name && !storedContract)
4584
+ || (systemOriginTurn && !storedContract?.taskKind);
4545
4585
  if (informationalTurn || unownedToolTurn) {
4546
4586
  // An answer-only turn must not enforce carried write debt, but it must not ERASE the
4547
4587
  // contract either: park it (session- and task-bound) so a continuation or the next
@@ -4581,13 +4621,14 @@ function applyTaskSemantics(contract, semantic) {
4581
4621
  const kept = { ...persisted.routeSummary.executionContract };
4582
4622
  // statusReport / verificationOnly are only stripped on re-derivation: for a NEW task they drive the
4583
4623
  // carried-status rebuild below, so they must survive to be recognised there.
4584
- const staleKeys = semanticFromPrompt ? ['publication', 'operationGoal', 'configurationScope', 'releasePolicy', 'conditionalObligations', 'reportArtifact', 'verificationOnly', 'statusReport']
4585
- : ['publication', 'operationGoal', 'configurationScope', 'releasePolicy', 'conditionalObligations', 'reportArtifact'];
4624
+ const staleKeys = semanticFromPrompt ? ['publication', 'operationGoal', 'operationGoals', 'configurationScope', 'releasePolicy', 'conditionalObligations', 'reportArtifact', 'verificationOnly', 'statusReport']
4625
+ : ['publication', 'operationGoal', 'operationGoals', 'configurationScope', 'releasePolicy', 'conditionalObligations', 'reportArtifact', 'stateVerification', 'stateAction', 'stateConditionalStop', 'stateTargets'];
4586
4626
  for (const key of staleKeys) delete kept[key];
4587
- // MIXED/OPERATIONAL evidence tags belong to the previous task's classification: a new task starts from
4588
- // the mode's base evidence so it is not asked for operation proof its own prompt never ordered.
4589
- if ((!continuingTask || semanticFromPrompt) && semantic.taskKind !== 'MIXED' && semantic.taskKind !== 'OPERATIONAL'
4590
- && Array.isArray(kept.completionEvidence) && kept.completionEvidence.includes('operation-verification')) {
4627
+ // Evidence tags belong to the previous task's classification (operation-verification, a READ_ONLY
4628
+ // task's impact-evidence, state-verification, ...): a new task starts from the mode's base evidence so
4629
+ // it is not asked for proof its own prompt never ordered. A leaked tag also made the stored contract
4630
+ // differ from its own re-derivation, which the gate reported as an invariant violation.
4631
+ if ((!continuingTask || semanticFromPrompt) && Array.isArray(kept.completionEvidence) && kept.statusReport !== true) {
4591
4632
  const baseMode = persisted.routeSummary.executionMode === 'informational' ? 'local-build' : persisted.routeSummary.executionMode;
4592
4633
  const base = buildExecutionContract(baseMode);
4593
4634
  if (Array.isArray(base?.completionEvidence)) kept.completionEvidence = base.completionEvidence;
@@ -4603,6 +4644,12 @@ function applyTaskSemantics(contract, semantic) {
4603
4644
  if (!carriedStatus || persisted.routingContext?.mutationOrder === true) {
4604
4645
  persisted.routeSummary.executionContract = applyTaskSemantics(
4605
4646
  persisted.routeSummary.executionContract || buildExecutionContract(persisted.routeSummary.executionMode === 'informational' ? 'local-build' : persisted.routeSummary.executionMode), semantic);
4647
+ // A continuing turn re-applies the task's own contract: its evidence list stays as classified, never
4648
+ // re-unioned with the base of whatever mode this tool event happened to score.
4649
+ if (continuingTask && !semanticFromPrompt && semantic === previous.routeSummary?.executionContract
4650
+ && Array.isArray(semantic.completionEvidence) && semantic.completionEvidence.length > 0) {
4651
+ persisted.routeSummary.executionContract.completionEvidence = [...semantic.completionEvidence];
4652
+ }
4606
4653
  if (persisted.contractOrigin !== 'carried-system') persisted.contractOrigin = 'classified';
4607
4654
  }
4608
4655
  if (semantic.taskKind === 'OPERATIONAL' || semantic.taskKind === 'READ_ONLY'
@@ -4716,8 +4763,62 @@ function applyTaskSemantics(contract, semantic) {
4716
4763
  let previous = sessionId
4717
4764
  ? [storedPrevious, sidecarPrevious].find((state) => String(state?.sessionId || '').trim() === sessionId && publishedPrevious(state)) || {}
4718
4765
  : storedPrevious;
4719
- const continuationPrompt = /^(?:continue|resume|keep going|go on|proceed|tiep tuc|lam tiep)(?:\s+(?:with\s+)?(?:the\s+|this\s+)?(?:previous\s+|last\s+|current\s+|same\s+)?(?:implementation\s+)?(?:task|work))?(?:\s+(?:thoi|di|đi|nhe|nao|nua|a|ha|please|pls|now|then))*\s*[.!]?$/i.test(
4766
+ const explicitContinuationPrompt = /^(?:continue|resume|keep going|go on|proceed|tiep tuc|lam tiep)(?:\s+(?:with\s+)?(?:the\s+|this\s+)?(?:previous\s+|last\s+|current\s+|same\s+)?(?:implementation\s+)?(?:task|work))?(?:\s+(?:thoi|di|đi|nhe|nao|nua|a|ha|please|pls|now|then))*\s*[.!]?$/i.test(
4720
4767
  extractPrompt(payload).normalize('NFD').replace(/[̀-ͯ]/g, '').trim());
4768
+ // A bare "yes / ok / có / được / ừ" is normally a social turn that parks the previous contract. When it
4769
+ // ANSWERS a question the agent itself just asked ("shall I apply the fix?"), it is the owner's go-ahead for
4770
+ // that same task: parking the contract there let the agent stop without the edit it had just offered.
4771
+ // Proof is host-authored only: the last assistant text in this session's transcript must end with a
4772
+ // question. No transcript (or anything else in between) keeps the conservative parking behaviour.
4773
+ const affirmativeAnswerTurn = (() => {
4774
+ if (payload.tool_name || !sessionId) return false;
4775
+ const armed = previous.routeSummary?.executionContract?.completionEvidence?.length
4776
+ || previous.suspendedContract?.routeSummary?.executionContract?.completionEvidence?.length;
4777
+ if (!armed) return false;
4778
+ const raw = extractPrompt(payload).trim();
4779
+ if (!raw || raw.length > 40) return false;
4780
+ const tokens = raw.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/đ/g, 'd')
4781
+ .replace(/[^a-z0-9\s]/g, ' ').split(/\s+/).filter(Boolean);
4782
+ if (tokens.length === 0 || tokens.length > 4) return false;
4783
+ const yes = new Set(['ok', 'okay', 'oke', 'yes', 'yep', 'yeah', 'co', 'duoc', 'vang', 'da', 'u', 'uh', 'dong', 'y']);
4784
+ const soft = new Set(['nhe', 'nha', 'please', 'pls']);
4785
+ if (!tokens.some((t) => yes.has(t)) || !tokens.every((t) => yes.has(t) || soft.has(t))) return false;
4786
+ if (tokens.some((t, i) => t === 'dong' && tokens[i + 1] !== 'y')) return false;
4787
+ const tp = payload.transcript_path ?? payload.transcriptPath;
4788
+ if (!tp || typeof tp !== 'string') return false;
4789
+ try {
4790
+ const fd = fs.openSync(tp, 'r');
4791
+ try {
4792
+ const size = fs.fstatSync(fd).size;
4793
+ const len = Math.min(size, 256 * 1024);
4794
+ const buf = Buffer.alloc(len);
4795
+ fs.readSync(fd, buf, 0, len, size - len);
4796
+ const lines = buf.toString('utf8').split('\n');
4797
+ const textOf = (entry) => {
4798
+ const content = entry?.message?.content;
4799
+ if (typeof content === 'string') return content;
4800
+ if (!Array.isArray(content)) return '';
4801
+ return content.filter((part) => part?.type === 'text' && typeof part.text === 'string').map((part) => part.text).join('\n');
4802
+ };
4803
+ for (let i = lines.length - 1; i >= 0; i -= 1) {
4804
+ const line = lines[i];
4805
+ if (!line || !(line.includes('"assistant"') || line.includes('"user"'))) continue;
4806
+ let entry; try { entry = JSON.parse(line); } catch { continue; }
4807
+ if (entry?.isSidechain === true || (entry?.sessionId && entry.sessionId !== sessionId)) continue;
4808
+ const text = textOf(entry).trim();
4809
+ if (!text) continue; // tool calls / tool results carry no prose
4810
+ if (entry.type === 'user') {
4811
+ if (entry.isMeta === true || text === raw) continue; // this very prompt, already written by the host
4812
+ return false; // another owner turn sits between the question and this reply
4813
+ }
4814
+ if (entry.type !== 'assistant') continue;
4815
+ return /[??][\s)\]"'*_`]*$/.test(text.slice(-400));
4816
+ }
4817
+ } finally { fs.closeSync(fd); }
4818
+ } catch { /* unreadable transcript: no proof */ }
4819
+ return false;
4820
+ })();
4821
+ const continuationPrompt = explicitContinuationPrompt || affirmativeAnswerTurn;
4721
4822
  // Restore a contract parked by an informational turn: only for the SAME session, and only
4722
4823
  // on an explicit continuation or a mutating tool event (never a fresh prompt, which routes on its own,
4723
4824
  // and never a read during an answer/status turn: that must not resurrect write debt).
@@ -5352,7 +5453,7 @@ function applyTaskSemantics(contract, semantic) {
5352
5453
  || hasAdvisoryOnlyAssertion({ promptText, commandText })) && !filePath;
5353
5454
  // Greeting fast-path: a pure greeting gets the same read-only stamp as an
5354
5455
  // informational question — never a mutating lane, never task debt.
5355
- const greetingFastPath = !filePath && isPureGreetingPrompt({ promptText, commandText });
5456
+ const greetingFastPath = !filePath && !affirmativeAnswerTurn && isPureGreetingPrompt({ promptText, commandText });
5356
5457
  // A delivery-only prompt ("push this to git", "đẩy bộ này lên git") starts a new,
5357
5458
  // mutation-free action and typically matches no skill. It must not inherit the
5358
5459
  // previous request's completion contract — carrying find-cause/map-impact debt
@@ -212,8 +212,8 @@
212
212
  "hooks": [
213
213
  {
214
214
  "type": "command",
215
- "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/completion-gate.sh\":8",
216
- "timeout": 18
215
+ "command": "node \"$CLAUDE_PROJECT_DIR/.claude/ukit/runtime/hook-chain-runner.mjs\" --emit-verdict - \"$CLAUDE_PROJECT_DIR/.claude/hooks/completion-gate.sh\":12",
216
+ "timeout": 22
217
217
  }
218
218
  ]
219
219
  }
@@ -4596,6 +4596,9 @@ const GREETING_CORE_TOKENS = new Set([
4596
4596
  'hi', 'hello', 'hey', 'yo', 'chao', 'xin', 'good',
4597
4597
  'morning', 'afternoon', 'evening',
4598
4598
  'thanks', 'thank', 'cam', 'on', 'bye', 'tam', 'biet',
4599
+ // Bare acknowledgements ("ok", "có", "được rồi", "yes") are social turns, not work orders:
4600
+ // they must never mint a fresh implementation contract (3.4.81 audit).
4601
+ 'ok', 'okay', 'oke', 'yes', 'yep', 'yeah', 'co', 'duoc', 'vang', 'da', 'u', 'uh', 'um', 'roi', 'dong', 'y',
4599
4602
  ]);
4600
4603
  const GREETING_FILLER_TOKENS = new Set([
4601
4604
  'you', 'u', 'there', 'guys', 'everyone', 'all',
@@ -4616,7 +4619,11 @@ function isPureGreetingPrompt({ promptText = '', commandText = '', targetFile =
4616
4619
  const tokens = foldRouteText(raw).replace(/[^a-z0-9\s]/g, ' ').split(/\s+/).filter(Boolean);
4617
4620
  if (tokens.length === 0 || tokens.length > 6) return false;
4618
4621
  let coreHit = false;
4619
- for (const token of tokens) {
4622
+ for (let i = 0; i < tokens.length; i += 1) {
4623
+ const token = tokens[i];
4624
+ // Tone-folding makes "đóng" (close) and "đồng" (as in "đồng ý", agreed) the same token:
4625
+ // only the pair "dong y" is an acknowledgement; "đóng nhé" is an order to close something.
4626
+ if (token === 'dong' && tokens[i + 1] !== 'y') return false;
4620
4627
  if (GREETING_CORE_TOKENS.has(token)) {
4621
4628
  coreHit = true;
4622
4629
  } else if (!GREETING_FILLER_TOKENS.has(token)) {
@@ -4865,8 +4872,16 @@ export function classifyAdvisorRequest({ promptText = '', commandText = '' } = {
4865
4872
  // Used by hasAdvisoryOnlyAssertion (assertion + no order → advisory) and by
4866
4873
  // the question-shape gate below (question + no order → consult, even when the
4867
4874
  // subject vocabulary fires debug/failure/implement signal scores).
4875
+ // Tone-folding turns unrelated Vietnamese words into mutation verbs: "cái" (this/thing) -> cai (cài),
4876
+ // "chính" (main/exactly) -> chinh (chỉnh), "Việt" -> viet (viết), "đợi/đời/đối/đội/đôi/đói" -> doi (đổi),
4877
+ // "cháy/chảy" -> chay (chạy), "sữa" -> sua (sửa), "thèm" -> them (thêm). Mask the toned non-verbs BEFORE
4878
+ // folding, so "Cái này là gì, tại sao…" is not read as an install order (3.4.81 telemetry audit).
4879
+ function maskTonedNonVerbs(text = '') {
4880
+ return String(text ?? '').normalize('NFC')
4881
+ .replace(/(?<![\p{L}\p{N}_])(?:cái|chính|việt|cháy|chảy|đợi|đời|đối|đội|đôi|đói|sữa|thèm)(?![\p{L}\p{N}_])/giu, ' _ ');
4882
+ }
4868
4883
  function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
4869
- const folded = `${promptText ?? ''}\n${commandText ?? ''}`
4884
+ const folded = `${maskTonedNonVerbs(promptText)}\n${commandText ?? ''}`
4870
4885
  .toLowerCase()
4871
4886
  .normalize('NFD')
4872
4887
  .replace(/[\u0300-\u036f]/g, '')
@@ -4919,6 +4934,11 @@ function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
4919
4934
  .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
4920
4935
  // 'đối chiếu' (cross-check) folds to 'doi chieu' and is not the verb 'đổi' (change).
4921
4936
  .replace(/\bdoi\s+chieu\b/g, ' ')
4937
+ // Field telemetry (3.4.81 audit): words that fold onto a mutation verb but name no order.
4938
+ // "chưa được cấp quyền cập nhật" / "no permission to update" reports a missing permission (read-only
4939
+ // banners); "gì thêm [nữa]" / "thêm nữa không" mean "anything else", never the verb "add".
4940
+ .replace(/\b(?:(?:chua|khong)\s+(?:duoc\s+)?(?:cap\s+|co\s+)?quyen|(?:no|not\s+have|without|lacks?)\s+permission\s+to)\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![a-z0-9_])/g, ' ')
4941
+ .replace(/(?<=\b(?:con|co)\b[^.?!,;:\n]{0,40})\b(?:gi|nao)\s+them(?:\s+nua)?(?:\s+(?:khong|ko))?\s*(?=[?.!,;:\n]|$)|\bthem\s+nua\s+(?:khong|ko)\s*(?=[?.!\n]|$)/g, ' ')
4922
4942
  // R2: a deferred/future clause ("chua sua", "how we would later implement", "R2 onward: ...",
4923
4943
  // "fix strategy ...") describes work for a LATER round, not an order for this turn.
4924
4944
  .replace(new RegExp(`\\bchua\\s+(?:sua|fix|implement|trien\\s+khai|viet|thay\\s+doi)\\b${WAIT_TAIL}`, 'g'), ' ')
@@ -5019,6 +5039,11 @@ function deriveExecutionMode({
5019
5039
  const questionShapedPrompt = /\?\s*$/.test(trimmedPromptText)
5020
5040
  || leadingInterrogative
5021
5041
  || /\b(?:la gi|duoc khong)\s*$/.test(foldedPromptText)
5042
+ // Field telemetry (3.4.81 audit): a what-is question mid-prompt ("… là gì, …") and a leading
5043
+ // explanation request ("giải thích …", "explain …") ask for an answer. Both still pass the
5044
+ // hasMutationOrder/targetFile veto below, so "giải thích rồi sửa luôn" stays an order.
5045
+ || /\bla gi\s*(?:[,.?!;:\n]|$)/.test(foldedPromptText)
5046
+ || /^(?:hay\s+|vui\s+long\s+|lam\s+on\s+|please\s+)?(?:giai\s+thich|explain)\b/.test(foldedPromptText)
5022
5047
  // C85-019: Vietnamese status/consult tails without a '?' — "… chưa",
5023
5048
  // "… chưa nhỉ", "… không nhỉ", "… đúng không", "… à". A question about a
5024
5049
  // defect must not mint the bug-fix floor's write/repro debt (user-reported