@ngockhoale/ukit 3.4.81 → 3.4.83
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.
- package/CHANGELOG.md +30 -400
- package/package.json +1 -1
- package/src/diagnostics/failurePatterns.js +7 -4
- package/src/index/taskRouting.js +19 -1
- package/src/learning/codeProposals.js +36 -15
- package/template_project/.claude/hooks/auto-allow-bash.sh +155 -10
- package/template_project/.claude/hooks/completion-gate.sh +68 -15
- package/template_project/.claude/hooks/skill-router.sh +115 -14
- package/template_project/.claude/hooks/task-watchdog.sh +19 -3
- package/template_project/.claude/settings.json +2 -2
- package/template_project/.claude/ukit/index/reset-auto-permissions.mjs +3 -1
- package/template_project/.claude/ukit/index/route-task.mjs +27 -2
- package/template_project/.claude/ukit/runtime/execution-ledger.mjs +99 -19
- package/template_project/.claude/ukit/runtime/handoff-provenance.mjs +6 -0
- package/template_project/.claude/ukit/runtime/hook-telemetry.mjs +14 -0
- package/template_project/.claude/ukit/runtime/stop-coordinator.mjs +38 -8
|
@@ -33,27 +33,36 @@ const DENIED_TARGET_RES = [
|
|
|
33
33
|
/secret|credential|token/i,
|
|
34
34
|
];
|
|
35
35
|
|
|
36
|
-
// Whitelist — bounded deterministic mapping only.
|
|
36
|
+
// Whitelist — bounded deterministic mapping only. Classification needs evidence,
|
|
37
|
+
// not a word that happens to occur in a command's text: the ledger records no
|
|
38
|
+
// timed-out/killed/signal marker, only `exitCode` (mined onto pattern.exitCodes),
|
|
39
|
+
// so timeout-hang keys on exit 124 (GNU timeout(1)). Text markers are a fallback:
|
|
40
|
+
// whole words only, matched against the command's invocation lines — never
|
|
41
|
+
// heredoc bodies, comments, env-var names or file names.
|
|
42
|
+
const TIMEOUT_EXIT_CODES = new Set([124]);
|
|
43
|
+
|
|
37
44
|
const FIX_CLASSES = [
|
|
38
45
|
{
|
|
39
46
|
id: 'timeout-hang',
|
|
40
|
-
matches: (
|
|
47
|
+
matches: (text, pattern) => (Array.isArray(pattern.exitCodes)
|
|
48
|
+
&& pattern.exitCodes.some((code) => TIMEOUT_EXIT_CODES.has(code)))
|
|
49
|
+
|| /\b(?:timed out|timeout (?:exceeded|expired)|hangs|hanging|hung)\b/.test(text.commands),
|
|
41
50
|
change: 'Increase the timeout, add an explicit deadline, and retry once before giving up.',
|
|
42
51
|
},
|
|
43
52
|
{
|
|
44
53
|
id: 'missing-fallback',
|
|
45
|
-
matches: (
|
|
46
|
-
|| (
|
|
54
|
+
matches: (text) => /\bmissing-fallback\b/.test(text.all)
|
|
55
|
+
|| (/\bfallback\b/.test(text.all) && /\b(?:decision|decisionruntime)\b/.test(text.all)),
|
|
47
56
|
change: 'Add a `fallbackCode` path plus a deterministic default so the caller never blocks on the decision call.',
|
|
48
57
|
},
|
|
49
58
|
{
|
|
50
59
|
id: 'empty-output',
|
|
51
|
-
matches: (
|
|
60
|
+
matches: (text) => /\bempty[-_ ]?output\b|\bno output\b|\bempty stdout\b/.test(text.all),
|
|
52
61
|
change: 'Keep the chain alive on empty output (`|| true` or equivalent) and log stderr for diagnosis.',
|
|
53
62
|
},
|
|
54
63
|
{
|
|
55
64
|
id: 'stale-doc',
|
|
56
|
-
matches: (
|
|
65
|
+
matches: (text) => /\bstale[-_ ]?doc\b|\bdoc drift\b|\bdocs?\s+drift\b|\bout[- ]?of[- ]?date\s+doc\b/.test(text.all),
|
|
57
66
|
change: 'Re-render or refresh the flagged documentation file to match current source.',
|
|
58
67
|
},
|
|
59
68
|
];
|
|
@@ -62,21 +71,33 @@ function isObject(value) {
|
|
|
62
71
|
return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
|
|
63
72
|
}
|
|
64
73
|
|
|
65
|
-
//
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
74
|
+
// Invocation text of a shell command: drop comment lines and everything from the
|
|
75
|
+
// line that opens a heredoc (body = prose/data, not the command).
|
|
76
|
+
function invocationText(command) {
|
|
77
|
+
const kept = [];
|
|
78
|
+
for (const line of String(command).split('\n')) {
|
|
79
|
+
if (/^\s*#/.test(line)) continue;
|
|
80
|
+
kept.push(line);
|
|
81
|
+
if (/<<-?\s*['"]?\w+/.test(line)) break;
|
|
82
|
+
}
|
|
83
|
+
return kept.join(' ');
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
// Evidence text, lowercased: `commands` = invocation text only; `all` adds signature + files.
|
|
87
|
+
function evidenceText(pattern) {
|
|
88
|
+
const commands = (Array.isArray(pattern.commands) ? pattern.commands : [])
|
|
89
|
+
.filter((c) => typeof c === 'string').map(invocationText).join(' ').toLowerCase();
|
|
90
|
+
const all = [pattern.signature, commands, ...(Array.isArray(pattern.files) ? pattern.files : [])]
|
|
91
|
+
.join(' ').toLowerCase();
|
|
92
|
+
return { commands, all };
|
|
72
93
|
}
|
|
73
94
|
|
|
74
95
|
/** Map a mined pattern to a whitelisted fix class; null = none. */
|
|
75
96
|
export function mapPatternToFixTarget(pattern) {
|
|
76
97
|
if (!isObject(pattern)) return null;
|
|
77
|
-
const
|
|
98
|
+
const text = evidenceText(pattern);
|
|
78
99
|
for (const fixClass of FIX_CLASSES) {
|
|
79
|
-
if (fixClass.matches(
|
|
100
|
+
if (fixClass.matches(text, pattern)) return { id: fixClass.id, change: fixClass.change };
|
|
80
101
|
}
|
|
81
102
|
return null;
|
|
82
103
|
}
|
|
@@ -81,26 +81,171 @@ if [ -z "$COMMAND" ]; then
|
|
|
81
81
|
exit 0
|
|
82
82
|
fi
|
|
83
83
|
|
|
84
|
-
#
|
|
85
|
-
#
|
|
86
|
-
#
|
|
87
|
-
|
|
84
|
+
# Binary resolution: a small shell-word scanner (NOT `for token in $COMMAND`).
|
|
85
|
+
# Leading env assignments (`NAME=value`) are skipped as WHOLE shell words — the
|
|
86
|
+
# value may be '...'/"..." quoted or a $(...)/`...` substitution containing
|
|
87
|
+
# spaces, which plain whitespace splitting cut in half and minted junk such as
|
|
88
|
+
# Bash(HEAD:*) or Bash(-td:*). If the first command word cannot be determined
|
|
89
|
+
# confidently (unbalanced quote/substitution, leading operator, redirection,
|
|
90
|
+
# subshell) BIN stays empty: nothing is minted and the normal permission prompt
|
|
91
|
+
# applies, which is always safe. Pure bash, 3.2 compatible (no globbing involved,
|
|
92
|
+
# so no `set -f` is needed either).
|
|
93
|
+
__ukit_scan_sq() { # I is after the opening '
|
|
94
|
+
local rest="${COMMAND:I}"
|
|
95
|
+
case "$rest" in
|
|
96
|
+
*"'"*) rest="${rest%%\'*}"; I=$((I + ${#rest} + 1)); return 0 ;;
|
|
97
|
+
esac
|
|
98
|
+
return 1
|
|
99
|
+
}
|
|
100
|
+
__ukit_scan_bt() { # I is after the opening backtick
|
|
101
|
+
local c
|
|
102
|
+
while [ "$I" -lt "$N" ]; do
|
|
103
|
+
c="${COMMAND:I:1}"
|
|
104
|
+
case "$c" in
|
|
105
|
+
'\') I=$((I + 2)) ;;
|
|
106
|
+
'`') I=$((I + 1)); return 0 ;;
|
|
107
|
+
*) I=$((I + 1)) ;;
|
|
108
|
+
esac
|
|
109
|
+
done
|
|
110
|
+
return 1
|
|
111
|
+
}
|
|
112
|
+
# I is AT a `$`. Only three forms are understood: `$(...)`, a plain `$NAME`-style
|
|
113
|
+
# expansion, and a simple `${NAME}`. Everything else whose end this scanner
|
|
114
|
+
# cannot prove — `${x:- a b }` (spaces/quotes/braces inside), `$[ ... ]`, and
|
|
115
|
+
# outside double quotes ANSI-C/locale quoting ($'..\'..' / $"..") — returns 1,
|
|
116
|
+
# so nothing is minted. $1 = "dq" when scanning inside double quotes, where
|
|
117
|
+
# `$'` and `$"` are a literal dollar.
|
|
118
|
+
# Name classes are spelled out: a locale-collated `[A-Za-z]` range also matches
|
|
119
|
+
# letters such as `É`, which bash itself never accepts in a variable name.
|
|
120
|
+
__ukit_n1='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
|
|
121
|
+
__ukit_simple_brace_re="^[\$][{][${__ukit_n1}][${__ukit_n1}0123456789]*[}]"
|
|
122
|
+
__ukit_assign_re="^[${__ukit_n1}][${__ukit_n1}0123456789]*[+]?="
|
|
123
|
+
__ukit_scan_dollar() {
|
|
124
|
+
case "${COMMAND:I+1:1}" in
|
|
125
|
+
'(') I=$((I + 2)); __ukit_scan_paren || return 1 ;;
|
|
126
|
+
'{')
|
|
127
|
+
if [[ "${COMMAND:I}" =~ $__ukit_simple_brace_re ]]; then
|
|
128
|
+
I=$((I + ${#BASH_REMATCH[0]}))
|
|
129
|
+
else
|
|
130
|
+
return 1
|
|
131
|
+
fi
|
|
132
|
+
;;
|
|
133
|
+
'[') return 1 ;;
|
|
134
|
+
"'"|'"')
|
|
135
|
+
[ "${1:-}" = "dq" ] || return 1
|
|
136
|
+
I=$((I + 1))
|
|
137
|
+
;;
|
|
138
|
+
*) I=$((I + 1)) ;;
|
|
139
|
+
esac
|
|
140
|
+
return 0
|
|
141
|
+
}
|
|
142
|
+
__ukit_scan_dq() { # I is after the opening "
|
|
143
|
+
local c
|
|
144
|
+
while [ "$I" -lt "$N" ]; do
|
|
145
|
+
c="${COMMAND:I:1}"
|
|
146
|
+
case "$c" in
|
|
147
|
+
'\') I=$((I + 2)) ;;
|
|
148
|
+
'"') I=$((I + 1)); return 0 ;;
|
|
149
|
+
'`') I=$((I + 1)); __ukit_scan_bt || return 1 ;;
|
|
150
|
+
'$') __ukit_scan_dollar dq || return 1 ;;
|
|
151
|
+
*) I=$((I + 1)) ;;
|
|
152
|
+
esac
|
|
153
|
+
done
|
|
154
|
+
return 1
|
|
155
|
+
}
|
|
156
|
+
__ukit_scan_paren() { # I is after an opening ( — consume through its matching )
|
|
157
|
+
# Not a full parser: constructs whose `)`/quote does not delimit what this
|
|
158
|
+
# scanner assumes — anything __ukit_scan_dollar rejects, a `#` (comment), a
|
|
159
|
+
# heredoc (`<<`), and `case` patterns (`a)`) — make it give up (return 1 →
|
|
160
|
+
# nothing is minted) rather than guess where the substitution ends.
|
|
161
|
+
local c start=$I
|
|
162
|
+
while [ "$I" -lt "$N" ]; do
|
|
163
|
+
c="${COMMAND:I:1}"
|
|
164
|
+
case "$c" in
|
|
165
|
+
')')
|
|
166
|
+
I=$((I + 1))
|
|
167
|
+
case "${COMMAND:start:I-start}" in
|
|
168
|
+
*case*) return 1 ;;
|
|
169
|
+
esac
|
|
170
|
+
return 0
|
|
171
|
+
;;
|
|
172
|
+
'#') return 1 ;;
|
|
173
|
+
'<') [ "${COMMAND:I+1:1}" = "<" ] && return 1; I=$((I + 1)) ;;
|
|
174
|
+
'$') __ukit_scan_dollar || return 1 ;;
|
|
175
|
+
'(') I=$((I + 1)); __ukit_scan_paren || return 1 ;;
|
|
176
|
+
"'") I=$((I + 1)); __ukit_scan_sq || return 1 ;;
|
|
177
|
+
'"') I=$((I + 1)); __ukit_scan_dq || return 1 ;;
|
|
178
|
+
'`') I=$((I + 1)); __ukit_scan_bt || return 1 ;;
|
|
179
|
+
'\') I=$((I + 2)) ;;
|
|
180
|
+
*) I=$((I + 1)) ;;
|
|
181
|
+
esac
|
|
182
|
+
done
|
|
183
|
+
return 1
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
# Bounded scan: the per-character substring scan is quadratic in the command
|
|
187
|
+
# length (a 100 KB assignment value stalled the hook for 45s+). Only the first
|
|
188
|
+
# 4096 characters are scanned; if the first command word is not fully resolved
|
|
189
|
+
# inside that window, nothing is minted.
|
|
88
190
|
BIN=""
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
191
|
+
__ukit_cut=0
|
|
192
|
+
if [ "${#COMMAND}" -gt 4096 ]; then
|
|
193
|
+
COMMAND="${COMMAND:0:4096}"
|
|
194
|
+
__ukit_cut=1
|
|
195
|
+
fi
|
|
196
|
+
N=${#COMMAND}
|
|
197
|
+
I=0
|
|
198
|
+
while :; do
|
|
199
|
+
while [ "$I" -lt "$N" ]; do
|
|
200
|
+
case "${COMMAND:I:1}" in
|
|
201
|
+
' '|' ') I=$((I + 1)) ;;
|
|
202
|
+
*) break ;;
|
|
203
|
+
esac
|
|
204
|
+
done
|
|
205
|
+
[ "$I" -ge "$N" ] && break
|
|
206
|
+
case "${COMMAND:I:1}" in
|
|
207
|
+
';'|'|'|'&'|'('|')'|'<'|'>'|'
|
|
208
|
+
') break ;;
|
|
209
|
+
esac
|
|
210
|
+
__ukit_ws=$I
|
|
211
|
+
__ukit_ok=1
|
|
212
|
+
while [ "$I" -lt "$N" ]; do
|
|
213
|
+
__ukit_c="${COMMAND:I:1}"
|
|
214
|
+
case "$__ukit_c" in
|
|
215
|
+
' '|' '|';'|'|'|'&'|'('|')'|'<'|'>'|'
|
|
216
|
+
') break ;;
|
|
217
|
+
'\') I=$((I + 2)) ;;
|
|
218
|
+
"'") I=$((I + 1)); __ukit_scan_sq || { __ukit_ok=0; break; } ;;
|
|
219
|
+
'"') I=$((I + 1)); __ukit_scan_dq || { __ukit_ok=0; break; } ;;
|
|
220
|
+
'`') I=$((I + 1)); __ukit_scan_bt || { __ukit_ok=0; break; } ;;
|
|
221
|
+
'$') __ukit_scan_dollar || { __ukit_ok=0; break; } ;;
|
|
222
|
+
*) I=$((I + 1)) ;;
|
|
223
|
+
esac
|
|
224
|
+
done
|
|
225
|
+
[ "$__ukit_ok" -eq 1 ] || break
|
|
226
|
+
# The word ran into the scan window's edge: it may continue past it.
|
|
227
|
+
if [ "$__ukit_cut" -eq 1 ] && [ "$I" -ge "$N" ]; then break; fi
|
|
228
|
+
__ukit_word="${COMMAND:__ukit_ws:I-__ukit_ws}"
|
|
229
|
+
if [[ "$__ukit_word" =~ $__ukit_assign_re ]]; then
|
|
230
|
+
continue
|
|
231
|
+
fi
|
|
232
|
+
case "$__ukit_word" in
|
|
92
233
|
time|command|env) continue ;;
|
|
93
|
-
'|'|'||'|'&&'|';') break ;;
|
|
94
234
|
esac
|
|
95
|
-
BIN="$
|
|
235
|
+
BIN="$__ukit_word"
|
|
96
236
|
break
|
|
97
237
|
done
|
|
98
|
-
set +f
|
|
99
238
|
|
|
100
239
|
if [ -z "$BIN" ]; then
|
|
101
240
|
exit 0
|
|
102
241
|
fi
|
|
103
242
|
|
|
243
|
+
# A leading dash is an option of a skipped wrapper (`command -v`, `env -i`,
|
|
244
|
+
# `time -p`) or leftover junk, never a binary — never mint it.
|
|
245
|
+
case "$BIN" in
|
|
246
|
+
-*) exit 0 ;;
|
|
247
|
+
esac
|
|
248
|
+
|
|
104
249
|
if [[ ! "$BIN" =~ ^[a-zA-Z0-9._/-]+$ ]]; then
|
|
105
250
|
exit 0
|
|
106
251
|
fi
|
|
@@ -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:-
|
|
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:-
|
|
93
|
-
case "$__ukit_coord_ms" in ''|*[!0-9]*) __ukit_coord_ms=
|
|
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
|
-
|
|
101
|
-
|
|
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
|
-
#
|
|
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
|
|
114
|
-
# Byte-append one marker per
|
|
115
|
-
# is consecutive
|
|
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="$
|
|
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
|
|
139
|
-
|
|
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 (
|
|
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
|
-
|
|
4522
|
-
|
|
4523
|
-
|
|
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
|
-
|
|
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
|
-
//
|
|
4588
|
-
//
|
|
4589
|
-
|
|
4590
|
-
|
|
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
|
|
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
|