@ngockhoale/ukit 2.6.0 → 2.6.2

package/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 All notable changes to UKit are documented here.
 
+## 2.6.2 - 2026-09-18
+
+Stability release — 17 confirmed hang / silent-idle / silent-hook defects fixed with
+root causes (full register: `docs/AI_HANDOFF/BUGS-2.6.2.md`), focused on the "system
+goes quiet and does nothing" failure class.
+
+- **No more silent degraded input (§8 contract, BUG-C21-01/02/03)**: every hook that
+  stages stdin now *announces* when staging fails, stalls, or refuses — fail-closed
+  hooks (`block-dangerous`, `protect-files`, `context-hardcap-gate`,
+  `sensitive-data-guard`) emit an `ask`/`systemMessage` JSON + stderr `BLOCKED` +
+  `exit 2`; advisory hooks emit a `systemMessage` + `exit 0`. The old bounded-cut
+  silently truncated and proceeded. `sensitive-data-guard` now also fails closed
+  (exit 2) on any non-refusal staging failure and mirrors its deadline block to
+  stderr so the reason survives `process.exit` truncation.
+- **Sync-fs defeats inside self-deadlines removed (BUG-C21-04)**: the
+  deadline-guarded node blocks in `context-window-guard.sh` and
+  `context-hardcap-gate.sh` no longer call synchronous `fs.*Sync` inside the kill
+  window — a stalled `.ukit` mount can no longer freeze the gate so the unref'd
+  deadline can never fire. (Residual call-frame past the grant boundary recorded
+  as BUG-C21-R1/R2 for the next cycle.)
+- **Host timeouts now cover internal budgets (BUG-C21-05)**: every hook registered
+  in `settings.json` gets `timeout ≥ stage bound + node deadline + margin`; the
+  regression test iterates *all* registered hooks instead of a hand-picked list,
+  and four under-budgeted hooks (`auto-allow-bash`, `vision-router`,
+  `auto-prune-bash`, `reset-compact-pressure`) were raised to 12s.
+- **Missing `await` in skill-router (review major)**: an un-awaited async context
+  snapshot could leave the router writing a stale/partial decision silently.
+- **CLI hangs eliminated (BUG-C21-12/13)**: `ukit update`/`install` `spawnSync`
+  calls now carry timeouts with `killSignal: 'SIGKILL'` (SIGTERM alone keeps
+  waiting on signal-resistant children); a wedged `npm root -g` now reports
+  `global-root-query-timeout` instead of hanging forever. `promptYesNo` resolves
+  on stdin EOF / `ERR_USE_AFTER_CLOSE` instead of hanging or crashing.
+- **Unbounded growth bounded (BUG-C21-07/09/10/11)**: `tee/` cache, hook-errors
+  jsonl, hook-latency and exec-ledger session files now have count caps; the
+  ledger protects receipt files (`.journal`, `.quarantine`, gate crash counter)
+  from count-cap eviction, and the overflow basis uses `entries.length`
+  (post-filter) everywhere.
+- **Handoff machinery (BUG-C21-15)**: all four `RUN.md` `Phase:` consumers treat
+  `done`/`blocked` as terminal — dead runs no longer nag forever.
+- **Wiring/parity (BUG-C21-06/08/14/16/17)**: stale-spec-guard deadline exits
+  distinguish "stall" from "match"; `provision-worktree` spawnSync calls carry
+  timeouts; `task-budget-validator.mjs` is manifest-covered so the documented
+  command works on fresh installs; `verification-guard.sh` is actually registered
+  on PreToolUse Bash; shipped `config.json` regained `codex-context-budget` and a
+  parity test now guards every array field under `subagents`.
+
+
 ## 2.6.0 - 2026-09-18
 
 handoff-fullstack v2 — autonomous create→implement→review loop that runs to 100%

package/manifests/platform.full.yaml

@@ -1548,6 +1548,22 @@ items:
     packs:
       - core
 
+  # BUG-C21-14: this file shipped in templates/ but was never manifest-listed, so
+  # autoDiscoverTemplates:false silently skipped it and the agent-documented
+  # `node .claude/ukit/index/task-budget-validator.mjs` command 404'd on installs.
+  # tests/manifest/settingsHookCoverage.test.js now asserts every file under
+  # templates/.claude/ukit/index/ is covered, which immunizes the next added module.
+  - id: ukit-index-task-budget-validator-script
+    type: config
+    sourceTemplate: .claude/ukit/index/task-budget-validator.mjs
+    targetPath: .claude/ukit/index/task-budget-validator.mjs
+    requires: []
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: gitignore-root
     type: config
     sourceTemplate: .gitignore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "Install/update an index-first AI workspace for Claude Code, OpenAI Codex, OpenCode, and omp (Oh My Pi).",
   "license": "MIT",
   "type": "module",

package/src/cli/commands/install.js

@@ -81,9 +81,46 @@ async function loadTrackedManagedPathSet(projectRoot) {
   );
 }
 
+// BUG-C21-13: `readline/promises` `question()` does not settle when the input
+// stream hits EOF without a pending newline — the promise stays pending after
+// the interface `close` event, so an unattended Ctrl+D / piped stdin froze
+// `runInstall` forever. Race every question against the interface's `close`
+// event; on EOF treat it as the default answer (decline → retain) and stop.
+// A post-EOF `question()` also throws ERR_USE_AFTER_CLOSE — same treatment.
+function onceInterfaceClosed(line) {
+  return new Promise((resolve) => {
+    if (typeof line.once === 'function') {
+      line.once('close', resolve);
+    }
+  });
+}
+
+async function askWithEofGuard(line, question) {
+  if (line.closed === true) {
+    return null;
+  }
+  try {
+    const answer = await Promise.race([line.question(question), onceInterfaceClosed(line)]);
+    return typeof answer === 'string' ? answer : null;
+  } catch (error) {
+    if (error?.code === 'ERR_USE_AFTER_CLOSE') {
+      return null;
+    }
+    throw error;
+  }
+}
+
 async function promptYesNo(line, question) {
   while (true) {
-    const answer = (await line.question(question)).trim().toLowerCase();
+    const raw = await askWithEofGuard(line, question);
+
+    if (raw === null) {
+      // EOF / interface closed: default answer (No) — never re-prompt a dead stream.
+      console.log('[UKit] Input ended (EOF) — keeping existing files.');
+      return false;
+    }
+
+    const answer = raw.trim().toLowerCase();
 
     if (answer === '') {
       return false;
@@ -97,6 +134,12 @@ async function promptYesNo(line, question) {
       return false;
     }
 
+    // A real terminal stays open after a bad answer, so re-prompting is safe —
+    // but if the stream just closed mid-loop, bail out as EOF.
+    if (line.closed === true) {
+      console.log('[UKit] Input ended (EOF) — keeping existing files.');
+      return false;
+    }
     console.log('[UKit] Please answer y/yes or n/no.');
   }
 }
@@ -191,7 +234,11 @@ export async function pruneDeselectedAdapters({
       console.log(`[UKit] Removed ${removedCount} ${adapter.label} path(s).`);
     }
   } finally {
-    line.close();
+    try {
+      line.close();
+    } catch {
+      // close() is best-effort cleanup — never let it mask the real result.
+    }
   }
 
   return { retainedManagedPaths: [...new Set(retainedManagedPaths)] };

package/src/cli/commands/update.js

@@ -44,6 +44,11 @@ export async function runUpdate({ packageVersion, argv = [], cwd = process.cwd()
     console.log('[UKit] Run `ukit install` inside a project to set it up.');
     return;
   }
+  if (reason === 'global-root-query-timeout') {
+    console.log('[UKit] Update complete, but locating the upgraded CLI timed out.');
+    console.log('[UKit] `npm root -g` did not answer within 15s — check for a wedged npm/network, then run `ukit install` to refresh this project.');
+    return;
+  }
   if (reason === 'global-bin-not-found') {
     console.log('[UKit] Update complete, but the upgraded CLI could not be located.');
     console.log('[UKit] Run `ukit install` to refresh this project.');

package/src/core/output/index.js

@@ -353,6 +353,81 @@ function buildRecoveryHintSummary(summary, rawPath, { tokensBefore = 0 } = {}) {
   return null;
 }
 
+// --- tee/ cache bound (BUG-C21-07, FR-006) -----------------------------------
+// Mirror of the bound in templates/.claude/ukit/runtime/output-compression.mjs —
+// keep the two implementations identical. persistRawOutput wrote one preserved
+// file per compression and nothing ever deleted from tee/. Sweeps are SAMPLED
+// (~1/16 writes, UKIT_TEE_SWEEP_PROBABILITY to force/disable) and BOUNDED
+// (<= maxEntries stats, <= maxRemovals unlinks per sweep).
+const TEE_SWEEP_PROBABILITY_DEFAULT = 1 / 16;
+const TEE_SWEEP_MAX_ENTRIES = 128;
+const TEE_SWEEP_MAX_REMOVALS = 64;
+const TEE_MAX_FILES = 500;
+const TEE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+function teeSweepProbabilityFromEnv() {
+  const raw = Number(process.env.UKIT_TEE_SWEEP_PROBABILITY);
+  if (!Number.isFinite(raw)) return TEE_SWEEP_PROBABILITY_DEFAULT;
+  return Math.min(1, Math.max(0, raw));
+}
+
+// See the runtime mirror for the contract: removes entries older than maxAgeMs,
+// then the oldest scanned entries while the dir count exceeds maxFiles — all
+// bounded by maxEntries/maxRemovals so an oversized dir is amortized down.
+export async function sweepTeeCache(dir, {
+  now = Date.now,
+  maxAgeMs = TEE_MAX_AGE_MS,
+  maxFiles = TEE_MAX_FILES,
+  maxEntries = TEE_SWEEP_MAX_ENTRIES,
+  maxRemovals = TEE_SWEEP_MAX_REMOVALS,
+} = {}) {
+  let names;
+  try {
+    names = await fs.readdir(dir);
+  } catch {
+    return { sampled: true, scanned: 0, removed: 0 };
+  }
+  const cutoff = now() - maxAgeMs;
+  const entries = [];
+  let scanned = 0;
+  for (const name of names) {
+    if (scanned >= maxEntries) break;
+    scanned += 1;
+    try {
+      const stats = await fs.stat(path.join(dir, name));
+      if (stats.isFile()) entries.push({ name, mtimeMs: stats.mtimeMs });
+    } catch { /* raced away — fine */ }
+  }
+  entries.sort((a, b) => a.mtimeMs - b.mtimeMs);
+  // Overflow counts eligible FILES only — foreign entries (non-matching names,
+  // dirs) inflate `names.length` and would evict real entries while the dir is
+  // actually under the cap.
+  const overflow = Math.max(0, entries.length - maxFiles);
+  let removed = 0;
+  for (const entry of entries) {
+    if (removed >= maxRemovals) break;
+    if (removed < overflow || entry.mtimeMs < cutoff) {
+      try {
+        await fs.rm(path.join(dir, entry.name), { force: true });
+        removed += 1;
+      } catch { /* raced away — fine */ }
+    }
+  }
+  return { sampled: true, scanned, removed };
+}
+
+export async function maybeSweepTeeCache(dir, {
+  probability,
+  random = Math.random,
+  ...options
+} = {}) {
+  const p = Number.isFinite(probability)
+    ? Math.min(1, Math.max(0, probability))
+    : teeSweepProbabilityFromEnv();
+  if (random() >= p) return { sampled: false, scanned: 0, removed: 0 };
+  return sweepTeeCache(dir, options);
+}
+
 async function persistRawOutput(projectRoot, {
   command = '',
   summary = '',
@@ -379,6 +454,8 @@ async function persistRawOutput(projectRoot, {
 
   await fs.mkdir(teeCacheDir, { recursive: true });
   await fs.writeFile(absolutePath, rawOutputText, 'utf8');
+  // Bounded, sampled tee/ prune (BUG-C21-07): advisory only.
+  await maybeSweepTeeCache(teeCacheDir).catch(() => {});
 
   return {
     rawSaved: true,

package/src/core/update.js

@@ -10,6 +10,22 @@ export const UKIT_PACKAGE_NAME = '@ngockhoale/ukit';
 // CLAUDE.md and edits .gitignore — an unwanted surprise in, say, a home directory).
 const INSTALLED_MARKERS = ['.ukit', '.claude', 'CLAUDE.md', 'AGENTS.md', '.codex'];
 
+// BUG-C21-12 (SPEC FR-005): spawnSync defaults to NO timeout, so a wedged npm
+// (network partition, hung credential helper) would block the CLI forever.
+// Per-operation CLI budgets: a pure `npm root -g` resolution is cheap (~15s);
+// `npm install -g` and the post-update reinstall child get a generous 10-minute
+// bound so slow-but-alive installs still finish.
+// killSignal SIGKILL, not the default SIGTERM: a wedged child that ignores
+// SIGTERM (npm's signal-exit cleanup handler can itself wedge) would keep
+// spawnSync waiting past the timeout — verified on Node v22: SIGTERM on a
+// signal-ignoring child blocks indefinitely, SIGKILL returns ~immediately with
+// ETIMEDOUT. Direct-child kill only (no process-group tree kill): these are
+// short-lived CLI one-shots; the detached-group TERM→KILL posture stays in
+// templates/.claude/ukit/runtime/hook-process.mjs where hooks need it.
+export const NPM_QUERY_TIMEOUT_MS = 15_000;
+export const NPM_INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
+const KILL_ON_TIMEOUT = 'SIGKILL';
+
 export function hasUkitInstalled(projectRoot) {
   return INSTALLED_MARKERS.some((marker) => fs.existsSync(path.join(projectRoot, marker)));
 }
@@ -23,12 +39,23 @@ export function hasUkitInstalled(projectRoot) {
  * Only a fresh child process picks up the newly written package.
  */
 export function resolveGlobalUkitBin({ spawnSync = defaultSpawnSync } = {}) {
-  const result = spawnSync('npm', ['root', '-g'], { encoding: 'utf8' });
+  return resolveGlobalUkitBinDetailed({ spawnSync }).binPath;
+}
+
+// Detailed variant: also reports WHY resolution failed, so callers can surface
+// a timeout as actionable ("npm query timed out — is the network/proxy wedged?")
+// instead of misattributing it to a missing file.
+function resolveGlobalUkitBinDetailed({ spawnSync = defaultSpawnSync } = {}) {
+  const result = spawnSync('npm', ['root', '-g'], {
+    encoding: 'utf8',
+    timeout: NPM_QUERY_TIMEOUT_MS,
+    killSignal: KILL_ON_TIMEOUT,
+  });
   if (result.error || result.status !== 0 || typeof result.stdout !== 'string') {
-    return null;
+    return { binPath: null, timedOut: result.error?.code === 'ETIMEDOUT' };
   }
   const binPath = path.join(result.stdout.trim(), ...UKIT_PACKAGE_NAME.split('/'), 'bin', 'ukit');
-  return fs.existsSync(binPath) ? binPath : null;
+  return { binPath: fs.existsSync(binPath) ? binPath : null, timedOut: false };
 }
 
 /**
@@ -45,14 +72,16 @@ export function runInstallAfterUpdate({
     return { ran: false, reason: 'not-a-ukit-project' };
   }
 
-  const binPath = resolveGlobalUkitBin({ spawnSync });
+  const { binPath, timedOut } = resolveGlobalUkitBinDetailed({ spawnSync });
   if (!binPath) {
-    return { ran: false, reason: 'global-bin-not-found' };
+    return { ran: false, reason: timedOut ? 'global-root-query-timeout' : 'global-bin-not-found' };
   }
 
   const result = spawnSync(execPath, [binPath, 'install'], {
     cwd: projectRoot,
     stdio: 'inherit',
+    timeout: NPM_INSTALL_TIMEOUT_MS,
+    killSignal: KILL_ON_TIMEOUT,
   });
   if (result.error) {
     return { ran: false, reason: `install-failed: ${result.error.message}` };
@@ -66,6 +95,8 @@ export function runInstallAfterUpdate({
 export function updateUkit({ spawnSync = defaultSpawnSync } = {}) {
   const result = spawnSync('npm', ['install', '-g', UKIT_PACKAGE_NAME], {
     stdio: 'inherit',
+    timeout: NPM_INSTALL_TIMEOUT_MS,
+    killSignal: KILL_ON_TIMEOUT,
   });
 
   if (result.error) {

package/templates/.claude/commands/ukit/handoff-clear.md

@@ -49,8 +49,8 @@ PLAN.md  → "# PLAN\n_(empty)_"
 SPEC.md  → restore the untouched template (keep section headings, clear content)
 INDEX.md → empty table header only
 ACTIVE.md → "# ACTIVE\n_(no active cycle)_"
-RUN.md   → set `Phase: done` (or delete) — a live non-done cursor makes the Stop gate
-           refuse the next session's stops; clearing a cycle MUST close the cursor.
+RUN.md   → set `Phase: done` (or delete) — a live cursor that is neither `done` nor `blocked`
+           makes the Stop gate refuse the next session's stops; clearing a cycle MUST close the cursor.
 tasks/TASK-*.md → delete all (keep _TEMPLATE.md)
 ```
 

package/templates/.claude/commands/ukit/handoff-fullstack.md

@@ -77,13 +77,16 @@ interrupted run into a continuable one.
 
 ### Resume — when the run is re-invoked mid-flight
 
-If `docs/AI_HANDOFF/RUN.md` exists with `Phase:` not `done`, this is a **continuation, not a
-new cycle**. Do NOT re-plan, do NOT overwrite `PLAN.md`, do NOT ask the human whether to
-continue. Read the cursor, then jump straight to `Next:` and carry on. Tasks already `done`
-or `pending_review` are skipped; only `ready`, `in_progress`, `changes_requested` and
-`blocked` tasks are picked up.
-
-Only when `RUN.md` is absent or `Phase: done` does a new request start a fresh cycle.
+If `docs/AI_HANDOFF/RUN.md` exists with `Phase:` not `done` or `blocked`, this is a
+**continuation, not a new cycle**. Do NOT re-plan, do NOT overwrite `PLAN.md`, do NOT ask
+the human whether to continue. Read the cursor, then jump straight to `Next:` and carry on.
+Tasks already `done` or `pending_review` are skipped; only `ready`, `in_progress`,
+`changes_requested` and `blocked` tasks are picked up.
+
+`Phase: blocked` is terminal for the run — the machinery (Stop gate, hooks, stop-coordinator)
+all treats it as closed. It is *paused*, not abandoned: an explicit `/ukit:handoff-fullstack`
+re-invocation resumes it as a continuation; `ukit handoff-clear` abandons it. Only when
+`RUN.md` is absent or `Phase: done` does a new request start a fresh cycle.
 
 ---
 

package/templates/.claude/hooks/auto-allow-bash.sh

@@ -11,7 +11,15 @@ if source "$SCRIPT_DIR/../ukit/runtime/hook-input.sh" 2>/dev/null; then
 source "$SCRIPT_DIR/../ukit/runtime/hook-telemetry.sh" 2>/dev/null || true
   trap ukit_cleanup_hook_input EXIT
   # Bounded stdin (H01): stage before anything reads it; the shell var is capped.
-  ukit_stage_hook_input 2097152 truncate || exit 0
+  ukit_stage_hook_input 2097152 truncate
+  __ukit_main_stage_rc=$?
+  if [ "$__ukit_main_stage_rc" -ne 0 ]; then
+    # Infra failure during staging (mktemp/truncate): payload was never
+    # inspected — announce the degrade (SPEC §8), never a silent pass.
+    ukit_emit_input_degraded advisory "auto-allow-bash"
+  fi
+# BUG-C21-01: a truncated/stalled staged payload must be announced (SPEC §8), never silently passed.
+ukit_input_degraded && ukit_emit_input_degraded advisory "auto-allow-bash"
 else
   # Runtime helper missing (pre-install tree): the SAME bounded staging,
   # inline - `cat >/dev/null` used to block forever on a producer that never
@@ -38,10 +46,14 @@ else
   wait "$__ukit_waiter" 2>/dev/null
   exec 8<&-
   __ukit_size="$(wc -c < "$UKIT_INPUT_FILE" 2>/dev/null | tr -d '[:space:]')"
-  # A bounded cut (rc != 0) leaves a short payload that the JSON consumer
-  # already degrades on - the shared helper's truncate posture (R4.5).
-  if [ "$__ukit_size" -gt 2097152 ]; then
-    truncate -s 2097152 "$UKIT_INPUT_FILE" 2>/dev/null
+  if [ "$__ukit_stage_rc" -ne 0 ] || [ "$__ukit_size" -gt 2097152 ]; then
+    # BUG-C21-01 fallback parity (SPEC §8): a truncated/stalled staged payload
+    # must be announced, never silently acted on — same shape as the helper
+    # path's ukit_emit_input_degraded.
+    rm -f "$UKIT_INPUT_FILE"
+    UKIT_INPUT_FILE=""
+    printf '%s\n' '{"systemMessage":"UKit auto-allow-bash: tool-call payload was truncated or stalled during stdin staging; skipped this pass rather than act on incomplete input."}'
+    exit 0
   fi
   trap '[ -n "$UKIT_INPUT_FILE" ] && rm -f "$UKIT_INPUT_FILE"' EXIT
 fi

package/templates/.claude/hooks/block-dangerous.sh

@@ -11,7 +11,15 @@ if source "$SCRIPT_DIR/../ukit/runtime/hook-input.sh" 2>/dev/null; then
 source "$SCRIPT_DIR/../ukit/runtime/hook-telemetry.sh" 2>/dev/null || true
   trap ukit_cleanup_hook_input EXIT
   # Bounded stdin (H01): stage before anything reads it; the shell var is capped.
-  ukit_stage_hook_input 2097152 truncate || exit 0
+  ukit_stage_hook_input 2097152 truncate
+  __ukit_main_stage_rc=$?
+  if [ "$__ukit_main_stage_rc" -ne 0 ]; then
+    # Infra failure during staging (mktemp/truncate): payload was never
+    # inspected — announce the degrade (SPEC §8), never a silent pass.
+    ukit_emit_input_degraded failclosed "dangerous-command gate"
+  fi
+# BUG-C21-01: a truncated/stalled staged payload must be announced (SPEC §8), never silently passed.
+ukit_input_degraded && ukit_emit_input_degraded failclosed "dangerous-command gate"
 else
   # Runtime helper missing (pre-install tree): the SAME bounded staging,
   # inline - `cat >/dev/null` used to block forever on a producer that never
@@ -38,10 +46,15 @@ else
   wait "$__ukit_waiter" 2>/dev/null
   exec 8<&-
   __ukit_size="$(wc -c < "$UKIT_INPUT_FILE" 2>/dev/null | tr -d '[:space:]')"
-  # A bounded cut (rc != 0) leaves a short payload that the JSON consumer
-  # already degrades on - the shared helper's truncate posture (R4.5).
-  if [ "$__ukit_size" -gt 2097152 ]; then
-    truncate -s 2097152 "$UKIT_INPUT_FILE" 2>/dev/null
+  if [ "$__ukit_stage_rc" -ne 0 ] || [ "$__ukit_size" -gt 2097152 ]; then
+    # BUG-C21-01 fallback parity (SPEC §8): a truncated/stalled staged payload
+    # must be announced, never silently acted on — same shape as the helper
+    # path's ukit_emit_input_degraded.
+    rm -f "$UKIT_INPUT_FILE"
+    UKIT_INPUT_FILE=""
+    printf '%s\n' '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"ask","permissionDecisionReason":"UKit could not fully read this tool-call payload (stdin staging was cut at the deadline/size bound), so dangerous-command gate cannot prove it safe. UKit defers this to a human decision."}}'
+    echo "BLOCKED: dangerous-command gate could not inspect a truncated/stalled payload; deferred to human." >&2
+    exit 2
   fi
   trap '[ -n "$UKIT_INPUT_FILE" ] && rm -f "$UKIT_INPUT_FILE"' EXIT
 fi

package/templates/.claude/hooks/completion-gate.sh

@@ -22,7 +22,15 @@ if source "$SCRIPT_DIR/../ukit/runtime/hook-input.sh" 2>/dev/null; then
 source "$SCRIPT_DIR/../ukit/runtime/hook-telemetry.sh" 2>/dev/null || true
   trap ukit_cleanup_hook_input EXIT
   # Bounded stdin (H01): stage before anything reads it; the shell var is capped.
-  ukit_stage_hook_input 2097152 truncate || exit 0
+  ukit_stage_hook_input 2097152 truncate
+  __ukit_main_stage_rc=$?
+  if [ "$__ukit_main_stage_rc" -ne 0 ]; then
+    # Infra failure during staging (mktemp/truncate): payload was never
+    # inspected — announce the degrade (SPEC §8), never a silent pass.
+    ukit_emit_input_degraded advisory "stop gate"
+  fi
+# BUG-C21-01: a truncated/stalled staged payload must be announced (SPEC §8), never silently passed.
+ukit_input_degraded && ukit_emit_input_degraded advisory "stop gate"
 else
   # wrapper's own fail-loud behavior below alive.
   # Runtime helper missing (pre-install tree): the SAME bounded staging,
@@ -50,10 +58,14 @@ else
   wait "$__ukit_waiter" 2>/dev/null
   exec 8<&-
   __ukit_size="$(wc -c < "$UKIT_INPUT_FILE" 2>/dev/null | tr -d '[:space:]')"
-  # A bounded cut (rc != 0) leaves a short payload that the JSON consumer
-  # already degrades on - the shared helper's truncate posture (R4.5).
-  if [ "$__ukit_size" -gt 2097152 ]; then
-    truncate -s 2097152 "$UKIT_INPUT_FILE" 2>/dev/null
+  if [ "$__ukit_stage_rc" -ne 0 ] || [ "$__ukit_size" -gt 2097152 ]; then
+    # BUG-C21-01 fallback parity (SPEC §8): a truncated/stalled staged payload
+    # must be announced, never silently acted on — same shape as the helper
+    # path's ukit_emit_input_degraded.
+    rm -f "$UKIT_INPUT_FILE"
+    UKIT_INPUT_FILE=""
+    printf '%s\n' '{"systemMessage":"UKit stop gate: tool-call payload was truncated or stalled during stdin staging; skipped this pass rather than act on incomplete input."}'
+    exit 0
   fi
   trap '[ -n "$UKIT_INPUT_FILE" ] && rm -f "$UKIT_INPUT_FILE"' EXIT
 fi

package/templates/.claude/hooks/compress-output.sh

@@ -18,7 +18,15 @@ if [ -f "$SCRIPT_PATH" ]; then
     trap ukit_cleanup_hook_input EXIT
     # Bounded stdin (H01): compressed tool output can be large, so the staged
     # file is the transport and the shell var only mirrors the capped payload.
-    ukit_stage_hook_input 33554432 temp-file || exit 0
+    ukit_stage_hook_input 33554432 temp-file
+    __ukit_main_stage_rc=$?
+    if [ "$__ukit_main_stage_rc" -ne 0 ]; then
+      # Infra failure during staging (mktemp/truncate): payload was never
+      # inspected — announce the degrade (SPEC §8), never a silent pass.
+      ukit_emit_input_degraded advisory "output compression"
+    fi
+    # BUG-C21-01: a truncated/stalled staged payload must be announced (SPEC §8), never silently passed.
+    ukit_input_degraded && ukit_emit_input_degraded advisory "output compression"
   else
       # Runtime helper missing (pre-install tree): the SAME bounded staging,
   # inline — `cat >/dev/null` used to block forever on a producer that never
@@ -45,14 +53,15 @@ if [ -f "$SCRIPT_PATH" ]; then
   wait "$__ukit_waiter" 2>/dev/null
   exec 8<&-
   __ukit_size="$(wc -c < "$UKIT_INPUT_FILE" 2>/dev/null | tr -d '[:space:]')"
-  if [ "$__ukit_stage_rc" -ne 0 ]; then
-    # Unstaged: the hook cannot inspect this payload.
+  if [ "$__ukit_stage_rc" -ne 0 ] || [ "$__ukit_size" -gt 33554432 ]; then
+    # Unstaged or oversized: the hook cannot inspect this payload — announce
+    # the degrade (SPEC §8) instead of silently compressing an empty or
+    # truncated input (SUS-02 / BUG-C21-01 fallback parity).
     rm -f "$UKIT_INPUT_FILE"
     UKIT_INPUT_FILE=""
+    printf '%s\n' '{"systemMessage":"UKit output compression: tool-call payload was truncated or stalled during stdin staging; skipped this pass rather than act on incomplete input."}'
+    exit 0
   else
-    if [ "$__ukit_size" -gt 33554432 ]; then
-      truncate -s 33554432 "$UKIT_INPUT_FILE" 2>/dev/null
-    fi
     trap '[ -n "$UKIT_INPUT_FILE" ] && rm -f "$UKIT_INPUT_FILE"' EXIT
   fi
   fi