@ngockhoale/ukit 3.4.0 → 3.4.2

package/template_project/.claude/ukit/index/stale-spec-check.mjs

@@ -85,6 +85,11 @@ function formatRisk(risk) {
   return risk.labels.length > 0 ? risk.labels.join(',') : 'low';
 }
 
+function getReplaceAll(payload = {}) {
+  const value = payload.tool_input?.replace_all ?? payload.replace_all;
+  return value === true || value === 'true';
+}
+
 export async function checkStaleSpec({ projectRoot = process.cwd(), payload = {} } = {}) {
   const config = await readRuntimeSafePatchConfig(projectRoot);
   if (config.enabled === false) {
@@ -167,17 +172,22 @@ export async function checkStaleSpec({ projectRoot = process.cwd(), payload = {}
   }
 
   const occurrence = countOccurrences(profile.text, oldString);
-  if (occurrence.count === 1) {
+  if (occurrence.count === 1 || (occurrence.count > 1 && getReplaceAll(payload))) {
+    // W3-04: replace_all:true is an explicit whole-file replace of every match —
+    // a multi-match old_string is the contract, not ambiguity.
+    const replaceAll = occurrence.count > 1;
     return {
       status: 'ok',
-      specStatus: 'exact',
+      specStatus: replaceAll ? 'replace-all' : 'exact',
       file: resolved.relative,
       risk,
       profile: publicTextProfile(profile),
       line: lineNumberForIndex(profile.text, occurrence.indexes[0]),
+      ...(replaceAll ? { matchCount: occurrence.count } : {}),
     };
   }
 
+
   const code = occurrence.count === 0 ? 'stale-spec' : 'ambiguous-spec';
   const message = occurrence.count === 0
     ? `BLOCKED: stale spec for '${resolved.relative}' — old_string was not found in current file. Re-read current source, then choose Apply as-is / Adapt to current code / Skip.`
@@ -238,7 +248,7 @@ async function main() {
   if (args.json) {
     process.stdout.write(`${JSON.stringify(result)}\n`);
   } else if (result.status === 'ok') {
-    process.stdout.write(`[ukit-safe-patch] spec=exact file=${result.file} line=${result.line} risk=${formatRisk(result.risk)}\n`);
+    process.stdout.write(`[ukit-safe-patch] spec=${result.specStatus || 'exact'} file=${result.file} line=${result.line} risk=${formatRisk(result.risk)}${result.matchCount ? ` matches=${result.matchCount}` : ''}\n`);
   } else if (result.status === 'warn') {
     process.stderr.write(`[ukit-safe-patch] ${result.message}\n`);
   }

package/template_project/.claude/ukit/index/task-budget-validator.mjs

@@ -27,6 +27,12 @@ const VERIFICATION_MINUTE_TABLE = Object.freeze({
   'node scripts/release/verify-release.mjs': 2,
 });
 
+// W3-05: `yarn test` / `yarn vitest run` with NO file args runs the entire
+// suite — the single most expensive verification command a task can carry.
+// Estimating it at 0 let verification-heavy tasks slip maxVerificationMinutes;
+// floor it at the release-core cost.
+const WHOLE_SUITE_MINUTES = 3;
+
 export function estimateVerificationMinutes(commands) {
   if (!Array.isArray(commands)) return 0;
   let total = 0;
@@ -46,7 +52,7 @@ export function estimateVerificationMinutes(commands) {
       const runIdx = tokens.indexOf('run');
       const tail = runIdx >= 0 ? tokens.slice(runIdx + 1) : tokens.slice(2);
       const fileArgs = tail.filter((t) => !t.startsWith('-') && t.length > 0);
-      total += fileArgs.length * 0.5;
+      total += fileArgs.length === 0 ? WHOLE_SUITE_MINUTES : fileArgs.length * 0.5;
       continue;
     }
     total += 1;

package/template_project/.claude/ukit/index/unic-decision.mjs

@@ -534,13 +534,27 @@ function isTransientStatus(status) {
 function parseMaybeSse(text) {
   const trimmed = String(text ?? '').trim();
   if (!trimmed.startsWith('{')) {
-    // Pure SSE frames: join data payloads.
-    const payload = trimmed
+    // SSE frames: a single full-completion payload parses directly; a chunked
+    // stream is one chunk object per `data:` frame and needs delta merge.
+    const payloads = trimmed
       .split('\n')
       .filter((line) => line.startsWith('data:') && !line.includes('[DONE]'))
-      .map((line) => line.slice(5).trim())
-      .join('');
-    return JSON.parse(payload || trimmed);
+      .map((line) => line.slice(5).trim());
+    const chunks = [];
+    for (const payload of payloads) {
+      try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed === 'object') chunks.push(parsed);
+      } catch { /* unparseable frame — drop it, merge what survives */ }
+    }
+    try {
+      const joined = JSON.parse(payloads.join('') || trimmed);
+      // A lone `data:` frame may itself be one chunk object — merge it so
+      // callers always see a completion, never a raw chunk.
+      if (joined?.choices?.[0]?.delta === undefined) return joined;
+    } catch { /* joined payload is not one object — merge chunks below */ }
+    if (chunks.length > 0) return mergeSseChunks(chunks);
+    return JSON.parse(trimmed); // let the caller map the parse error
   }
   // JSON object possibly followed by a glued SSE trailer (`}data: [DONE]`,
   // observed live) — extract the balanced object, strings/comments aware.
@@ -563,6 +577,60 @@ function parseMaybeSse(text) {
   return JSON.parse(trimmed);
 }
 
+// Fold chat.completion.chunk frames into a single completion-shaped object:
+// deltas merge into `choices[0].message`, per-index tool_calls arguments
+// concatenate. Throws (typed malformed-response upstream) when no chunk is
+// usable.
+function mergeSseChunks(chunks) {
+  const mergedCalls = [];
+  let finishReason = null;
+  let role = null;
+  for (const chunk of chunks) {
+    const choice = chunk?.choices?.[0];
+    if (!choice) continue;
+    if (choice.finish_reason) finishReason = choice.finish_reason;
+    const delta = choice.delta ?? {};
+    if (delta.role) role = delta.role;
+    for (const call of delta.tool_calls ?? []) {
+      const slot = mergedCalls[call.index ?? 0] ??= {
+        id: call.id ?? null,
+        type: call.type ?? 'function',
+        function: { name: call.function?.name ?? '', arguments: '' },
+      };
+      if (call.function?.arguments) slot.function.arguments += call.function.arguments;
+    }
+  }
+  if (mergedCalls.length === 0) {
+    throw new SyntaxError('unusable SSE stream — no tool_call chunks');
+  }
+  return {
+    choices: [{
+      index: 0,
+      finish_reason: finishReason,
+      message: { role: role ?? 'assistant', content: null, tool_calls: mergedCalls },
+    }],
+  };
+}
+
+// Abort-aware race: fetch's signal does not cover res.text()/res.json() once
+// headers arrived, and injected transports may ignore it entirely — the read
+// is bounded by the caller's remaining deadline either way.
+function abortError() {
+  return new DOMException('The operation was aborted.', 'AbortError');
+}
+
+function raceAbort(promise, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) { reject(signal.reason ?? abortError()); return; }
+    const onAbort = () => reject(signal.reason ?? abortError());
+    signal?.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (v) => { signal?.removeEventListener('abort', onAbort); resolve(v); },
+      (e) => { signal?.removeEventListener('abort', onAbort); reject(e); },
+    );
+  });
+}
+
 async function readResponseBody(res) {
   if (res && typeof res.text === 'function') return parseMaybeSse(await res.text());
   if (res && typeof res.json === 'function') return res.json();
@@ -595,19 +663,53 @@ function sensitiveGate(serialized, config) {
   return scan.hasSecret ? { blocked: true, labels: scan.labels } : { blocked: false };
 }
 
-async function postWithDeadline(transport, url, headers, body, deadlineMs) {
+// `deadlineAt` covers the WHOLE request lifetime — headers plus body
+// consumption — not just the fetch() call. The abort timer is cleared only
+// by release(), invoked after readBody()/discard() settle or on transport
+// failure; until then a stalled body still aborts (W3-UD1).
+async function postWithDeadline(transport, url, headers, body, deadlineAt, now = () => Date.now()) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), deadlineMs);
-  try {
-    return await transport(url, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json', ...headers },
-      body,
-      signal: controller.signal,
-    });
-  } finally {
+  const remaining = () => deadlineAt - now();
+  const timer = setTimeout(() => controller.abort(), Math.max(0, remaining()));
+  const release = () => {
     clearTimeout(timer);
+    controller.abort(); // signal any stale readers; settled callers unaffected
+  };
+  let res;
+  try {
+    // Race the transport await too — a transport that ignores the abort
+    // signal (or a hung socket before headers) must not outlive deadlineAt.
+    res = await raceAbort(
+      transport(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', ...headers },
+        body,
+        signal: controller.signal,
+      }),
+      controller.signal,
+    );
+  } catch (err) {
+    release();
+    throw err;
   }
+  const readBody = async (target = res) => {
+    try {
+      return await raceAbort(readResponseBody(target), controller.signal);
+    } finally {
+      release();
+    }
+  };
+  // Release the socket without parsing — the caller only needed headers.
+  const discard = async () => {
+    try {
+      if (typeof res?.body?.cancel === 'function') await res.body.cancel();
+      else if (typeof res?.text === 'function') {
+        await raceAbort(res.text(), controller.signal);
+      } else if (typeof res?.destroy === 'function') res.destroy();
+    } catch { /* best-effort release */ }
+    release();
+  };
+  return { res, readBody, discard };
 }
 
 function outcome(status, extra = {}) {
@@ -696,18 +798,27 @@ export async function requestBatch(batch, {
       detail: error?.message ?? String(error),
     });
   }
-  const fingerprint = requestFingerprint(body);
+  let fingerprint = requestFingerprint(body);
   const timeoutMs = Number.isFinite(dp.timeoutMs) ? dp.timeoutMs : DEFAULT_TIMEOUT_MS;
   const deadlineMs = Number.isFinite(batch?.deadlineMs) ? batch.deadlineMs : timeoutMs;
+  // Cumulative budget: every attempt (headers AND body read) must finish
+  // before deadlineAt — retries share the caller's budget, they do not
+  // each get a fresh deadlineMs (W3-UD2).
+  const deadlineAt = now() + deadlineMs;
 
   const maxAttempts = 1 + DEFAULT_MAX_RETRIES;
   let lastError = null;
   let lastStatus = null;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const startedAt = now();
-    let res;
+    if (deadlineAt - startedAt <= 0) {
+      lastError = 'timeout';
+      lastStatus = null;
+      break;
+    }
+    let call;
     try {
-      res = await postWithDeadline(transport, endpoint.url, endpoint.headers, body, deadlineMs);
+      call = await postWithDeadline(transport, endpoint.url, endpoint.headers, body, deadlineAt, now);
     } catch (err) {
       const isTimeout = err?.name === 'AbortError' || err?.code === 'ABORT_ERR';
       lastError = isTimeout ? 'timeout' : 'unavailable';
@@ -715,6 +826,7 @@ export async function requestBatch(batch, {
       if (isTimeout || attempt + 1 >= maxAttempts) break;
       continue;
     }
+    const { res, readBody, discard } = call;
 
     const status = res?.status ?? (res?.ok === false ? 500 : 200);
     if (res?.ok === false || status < 200 || status >= 300) {
@@ -722,21 +834,30 @@ export async function requestBatch(batch, {
       // model_not_found body — retry once on the bare `unic-decision` model.
       if (checkpoint !== 'unic-decision') {
         let notFound = status === 404;
+        let consumed = false;
         try {
           const clone = typeof res?.clone === 'function' ? res.clone() : null;
-          const errBody = clone ? parseMaybeSse(await clone.text()) : null;
-          if (errBody?.error?.code === 'model_not_found') notFound = true;
+          if (clone) {
+            const errBody = await readBody(clone);
+            consumed = true;
+            if (errBody?.error?.code === 'model_not_found') notFound = true;
+          }
         } catch { /* keep status-based guess */ }
         if (notFound) {
+          if (!consumed) await discard();
           checkpoint = 'unic-decision';
           try {
             body = JSON.stringify(
               encodeBatch({ model: checkpoint, statePacket: serialized, questions }),
             );
           } catch { /* keep prior body */ }
+          // The receipt hash must cover the bytes actually sent — after the
+          // fallback re-encode the original fingerprint is stale.
+          fingerprint = requestFingerprint(body);
           continue;
         }
       }
+      await discard();
       if (isTransientStatus(status) && attempt + 1 < maxAttempts) continue;
       if (status === 401 || status === 403) {
         lastError = 'unavailable';
@@ -753,10 +874,17 @@ export async function requestBatch(batch, {
 
     let parsed;
     try {
-      parsed = await readResponseBody(res);
-    } catch {
-      lastError = 'invalid';
-      lastStatus = 'malformed-response';
+      parsed = await readBody();
+    } catch (err) {
+      if (err?.name === 'AbortError' || err?.code === 'ABORT_ERR') {
+        // The body stream outlived the deadline — typed timeout, not a
+        // malformed response.
+        lastError = 'timeout';
+        lastStatus = null;
+      } else {
+        lastError = 'invalid';
+        lastStatus = 'malformed-response';
+      }
       break;
     }
 
@@ -807,14 +935,17 @@ export async function runHealthProbe({
     max_tokens: 1,
   });
   try {
-    const res = await postWithDeadline(
+    const { res, discard } = await postWithDeadline(
       transport,
       decisionCompletionsUrl(base.baseUrl),
       buildAuthHeaders(key),
       body,
-      timeoutMs,
+      Date.now() + timeoutMs,
     );
     const status = res?.status ?? (res?.ok === false ? 500 : 200);
+    // The probe only needed the headers — cancel the body so the keep-alive
+    // socket is released instead of idling to its own timeout (W3-UD5).
+    await discard();
     if (res?.ok === false || status < 200 || status >= 300) {
       return { status: 'unavailable', httpStatus: status };
     }
@@ -848,12 +979,26 @@ function readFlagValue(argv, flag) {
   return value && !value.startsWith('--') ? value : null;
 }
 
+// W3-UD6: stdin must not accumulate unboundedly — a held pipe writing forever
+// would grow memory without limit. Bytes beyond the cap are still drained
+// (so the writer finishes and we exit promptly) but never appended.
+const MAX_STDIN_BYTES = 1024 * 1024;
+
 function readStdin() {
   return new Promise((resolve, reject) => {
     let data = '';
+    let overLimit = false;
     process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('data', (chunk) => {
+      if (overLimit) return;
+      if (Buffer.byteLength(data, 'utf8') + Buffer.byteLength(chunk, 'utf8') > MAX_STDIN_BYTES) {
+        overLimit = true;
+        data = '';
+        return;
+      }
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(overLimit ? null : data));
     process.stdin.on('error', reject);
   });
 }
@@ -889,6 +1034,12 @@ async function main() {
   }
 
   const raw = await readStdin();
+  if (raw === null) {
+    process.stderr.write(
+      `unic-decision: stdin batch exceeds the ${MAX_STDIN_BYTES}-byte limit\n`,
+    );
+    return 1;
+  }
   let batch;
   try {
     batch = JSON.parse(raw);

package/template_project/.claude/ukit/index/unic-gateway.mjs

@@ -3,7 +3,8 @@
  * unic-gateway.mjs (TASK-003, narrowed by TASK-007; alias-availability contract flipped 2026-09-11)
  *
  * Detects whether THIS Claude Code session's own outbound endpoint is pointed at the UNIC gateway
- * — i.e. `ANTHROPIC_BASE_URL` contains "unicjsc.com" — so the vision lane can pin `unic-vision`.
+ * — i.e. the `ANTHROPIC_BASE_URL` hostname is `unicjsc.com` or a `*.unicjsc.com` subdomain — so the
+ * vision lane can pin `unic-vision`.
  * The Codex model catalog can CONFIRM the alias (listing it) but its silence never denies it:
  * it is another tool's config and says nothing about what the gateway resolves server-side for
  * this session (live dispatch STATUS: OK on a machine whose catalog omits the alias, 2026-09-11).
@@ -53,7 +54,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-const UNIC_TOKEN = 'unicjsc.com';
+const UNIC_HOST = 'unicjsc.com';
 const VISION_MODEL_ALIAS = 'unic-vision';
 
 // RESOLVED 2026-08-22 against a real omp v17.4.2 install -- both omp-specific probes that
@@ -104,9 +105,30 @@ function resolveRootDir(overrideRoot) {
   return process.cwd();
 }
 
+// Host-exact match (W3-UG1): the token must be the URL's hostname — `unicjsc.com` itself or a
+// subdomain like `anthropic.unicjsc.com`. A bare `includes()` substring check also matched spoofed
+// superdomains (`unicjsc.com.evil.example`), path segments (`localhost:8080/unicjsc.com`), and
+// userinfo (`unicjsc.com@evil.example`) — none of which route traffic to the gateway.
+function urlPointsAtUnicGateway(value) {
+  if (typeof value !== 'string' || !value.trim()) return false;
+  const hostname = (() => {
+    try {
+      return new URL(value).hostname;
+    } catch {
+      // Tolerate scheme-less hosts (`anthropic.unicjsc.com`); the retry with an https://
+      // prefix still validates that the token sits in the hostname position.
+      try {
+        return new URL(`https://${value.trim()}`).hostname;
+      } catch {
+        return null;
+      }
+    }
+  })();
+  return hostname === UNIC_HOST || hostname?.endsWith(`.${UNIC_HOST}`) === true;
+}
+
 function probeEnvVar(name) {
-  const value = process.env[name];
-  return typeof value === 'string' && value.includes(UNIC_TOKEN);
+  return urlPointsAtUnicGateway(process.env[name]);
 }
 
 // Key-scoped: only the ANTHROPIC_BASE_URL entry of the env block decides Claude Code's own
@@ -116,8 +138,7 @@ function probeClaudeSettings(filePath) {
   const json = safeReadJson(filePath);
   const envBlock = json && typeof json === 'object' ? json.env : null;
   if (!envBlock || typeof envBlock !== 'object') return false;
-  const value = envBlock.ANTHROPIC_BASE_URL;
-  return typeof value === 'string' && value.includes(UNIC_TOKEN);
+  return urlPointsAtUnicGateway(envBlock.ANTHROPIC_BASE_URL);
 }
 
 // Narrow anchored regex probe (no YAML parsing) for the omp config file's `baseUrl` key. A
@@ -186,11 +207,15 @@ export function detectUnicGateway(options = {}) {
   const unicMode = sources.length > 0;
   const source = sources[0] ?? null;
 
-  let catalogInfo = { checked: false, aliasAvailable: false };
+  // Silence ≠ denial (W3-UG2): checkCodexVisionAlias already maps a missing/malformed catalog to
+  // "unverified → lane stays available". A probe that throws before answering is transport
+  // silence too — it carries no positive unavailability evidence, so it must keep the same
+  // aliasAvailable: true (not a false denial, which was the pre-W3-UG2 bug).
+  let catalogInfo = { checked: false, catalogListed: null, aliasAvailable: true };
   try {
     catalogInfo = checkCodexVisionAlias(path.join(homeDir, '.codex', 'model-catalog.json'));
   } catch {
-    catalogInfo = { checked: false, aliasAvailable: false };
+    catalogInfo = { checked: false, catalogListed: null, aliasAvailable: true };
   }
 
   const result = {

package/template_project/.claude/ukit/index/verify-context.mjs

@@ -24,7 +24,7 @@ const rootDir = getRootDir(args);
 const targetFile = readFlagValue(args, '--target');
 const taskType = readFlagValue(args, '--type');
 const autonomyLevel = readFlagValue(args, '--autonomy') ?? 'balanced';
-const intent = collectPositionalArgs(args, ['--root', '--target', '--type']);
+const intent = collectPositionalArgs(args, ['--root', '--target', '--type', '--autonomy']);
 const effectiveIntent = deriveHelperIntent({ intent, targetFile });
 
 if (!intent && !targetFile) {
@@ -354,6 +354,7 @@ function buildRequestKey({
   intent = '',
   targetFile = null,
   taskType = null,
+  autonomyLevel = 'balanced',
 } = {}) {
   return buildCompactMachineKey('verify-v1', {
     indexGeneratedAtMs,
@@ -361,6 +362,9 @@ function buildRequestKey({
     intent: String(intent || '').trim(),
     targetFile: String(targetFile || '').trim(),
     taskType: String(taskType || '').trim(),
+    // Autonomy steers the execution policy — the cached plan must not bleed
+    // a free-run policy into a conservative invocation (W3-VC2).
+    autonomyLevel: String(autonomyLevel || 'balanced').trim(),
   });
 }
 
@@ -687,7 +691,10 @@ function getRootDir(argv) {
 
 function readFlagValue(argv, flag) {
   const exact = argv.indexOf(flag);
-  if (exact >= 0 && argv[exact + 1]) return argv[exact + 1];
+  // A `--flag` token is never a value for the previous flag (W3-VC3).
+  if (exact >= 0 && argv[exact + 1] && !argv[exact + 1].startsWith('--')) {
+    return argv[exact + 1];
+  }
   const withEquals = argv.find((item) => item.startsWith(`${flag}=`));
   return withEquals ? withEquals.slice(flag.length + 1) : null;
 }