@ngockhoale/ukit 3.4.30 → 3.4.31

package/template_project/.claude/ukit/index/route-task.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { classifyTaskSemantics, applyTaskSemantics } from './route-resolver.mjs';
 import fs from 'node:fs/promises';
 // `fsSync` aliases the SAME fs module — used ONLY by the process.on('exit')
 // audit-sidecar fold below (event loop is gone; async cannot run) and by the
@@ -799,6 +800,7 @@ function buildRouteHotCacheState(sharedState = {}) {
   delete routingContext.lastExplicitUserPromptText;
   delete routingContext.commandText;
   delete state.sessionId;
+  delete state.taskInstanceId;
   state.routingContext = routingContext;
   return state;
 }
@@ -895,6 +897,7 @@ function buildReducedRouteState({ input, reason }) {
     source: 'task-route',
     requestKey: null,
     sessionId: input.sessionId ?? null,
+    taskInstanceId: input.taskInstanceId || undefined,
   });
 }
 
@@ -911,7 +914,7 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
   const absoluteRoot = path.resolve(input.rootDir ?? process.cwd());
   const budget = createRouteBudget({ signal, deadlineMs });
   const hotCache = cache ?? createDefaultRouteHotCache({ rootDir: absoluteRoot });
-  const normalizedInput = { ...input, rootDir: absoluteRoot };
+  const normalizedInput = { ...input, rootDir: absoluteRoot, taskInstanceId: input.taskInstanceId || `task-${crypto.randomBytes(16).toString('hex')}` };
   const baseMeta = {
     cacheHit: false,
     reduced: false,
@@ -929,7 +932,7 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
       elapsedMs: Date.now() - budget.startedAt,
       ioReads: budget.ioReads,
     };
-    return { ...state, cacheHit: routeMeta.cacheHit, routeMeta };
+    return { ...state, taskInstanceId: normalizedInput.taskInstanceId || state.taskInstanceId || `task-${crypto.randomBytes(16).toString('hex')}`, cacheHit: routeMeta.cacheHit, routeMeta };
   };
   const reduce = (reason) => finish(
     buildReducedRouteState({ input: normalizedInput, reason }),
@@ -1079,6 +1082,7 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
     requestKey,
     indexGeneratedAtMs,
     sessionId: normalizedInput.sessionId ?? null,
+    taskInstanceId: normalizedInput.taskInstanceId || undefined,
   });
 
   // Phase 3 — store under a POST-route fingerprint so the next identical call (whose own
@@ -1126,7 +1130,12 @@ async function main() {
   const sessionId = normalizeSessionId(readFlagValue(args, '--session-id'));
   const previousStateOwnershipBlocked = hasRouteStateOwner(persistedPreviousState)
     && !isRouteStateCompatible(persistedPreviousState, sessionId);
-  const previousState = previousStateOwnershipBlocked ? {} : persistedPreviousState;
+  const sessionSidecar = previousStateOwnershipBlocked && sessionId
+    ? await readJson(path.join(rootDir, '.ukit', 'storage', 'cache', 'route-state', `${sessionId.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 96) || 'default'}.json`), {})
+    : {};
+  const previousState = previousStateOwnershipBlocked
+    ? (isRouteStateCompatible(sessionSidecar, sessionId) && sessionSidecar.sessionId === sessionId ? sessionSidecar : {})
+    : persistedPreviousState;
   const escalationConfig = await readMergedConfig(rootDir);
   const targetFile = readFlagValue(args, '--target');
   const taskType = readFlagValue(args, '--type');
@@ -1144,7 +1153,7 @@ async function main() {
   const commandNamespace = adapter === 'codex'
     ? '.codex'
     : (adapter === 'antigravity' ? '.antigravity' : '.claude');
-  const promptText = args
+  let promptText = args
     .filter((arg, index) => !isFlagOrValue(args, index))
     .join(' ')
     .trim();
@@ -1155,6 +1164,15 @@ async function main() {
     return;
   }
 
+  const continuingTask = Boolean(previousState.taskInstanceId && lastPrompt
+    && /^(?:continue|resume|keep going|proceed|tiep tuc)(?:\s+(?:the task|this task|previous task))?[.!]?$/i.test(
+      promptText.normalize('NFD').replace(/[̀-ͯ]/g, '').trim()));
+  const taskInstanceId = readFlagValue(args, '--task-instance-id')
+    || (((['skill-router', 'skill-router-provisional'].includes(previousState.source)
+      && previousState.routingContext?.lastExplicitUserPromptText === promptText) || continuingTask)
+      && previousState.taskInstanceId
+      ? previousState.taskInstanceId : `task-${crypto.randomBytes(16).toString('hex')}`);
+  if (continuingTask) promptText = lastPrompt;
   const preparedRoute = await prepareTaskRoute({
     rootDir,
     promptText,
@@ -1249,7 +1267,12 @@ async function main() {
         historySignals,
       };
     }
-    printRouteState(reusableState);
+    const sharedState = { ...reusableState, taskInstanceId, source: 'task-route', ts: Date.now() };
+    if (canPersistRouteState) {
+      try { await persistSharedRouteState(sharedStatePath, sharedState); }
+      catch (error) { console.error(`route-task: state persist degraded — ${error?.message ?? error}`); }
+    }
+    printRouteState(sharedState);
     return;
   }
 
@@ -1331,6 +1354,7 @@ async function main() {
     }
     const sharedState = {
       ...cachedRouteState,
+      taskInstanceId,
       ...(sessionId ? { sessionId } : {}),
       source: 'task-route',
       ts: Date.now(),
@@ -1391,6 +1415,7 @@ async function main() {
     requestKey,
     indexGeneratedAtMs,
     sessionId,
+    taskInstanceId,
   });
   if (canPersistRouteState) {
     // Advisory persistence — an EACCES/ENOSPC under the lock must never lose
@@ -3775,11 +3800,12 @@ function buildRouteSummary({
     executionScores,
     executionCandidates,
   });
-  const executionContract = buildExecutionContract(executionMode);
+  const executionContract = applyTaskSemantics(buildExecutionContract(executionMode), classifyTaskSemantics({ promptText: routingContext.lastExplicitUserPromptText || routingContext.promptText, targetFile: routingContext.targetFile }));
   const continuousExecution = buildContinuousExecutionPolicy(autonomyLevel);
   const tierLane = buildTierLane({ modelTier: executionContract?.modelTier ?? null });
   const completionState = buildCompletionState({
     executionMode,
+    executionContract,
     verificationRecommendation,
   });
   const continuationState = buildContinuationState({
@@ -5417,7 +5443,7 @@ function isFlagOrValue(argv, index) {
   const arg = argv[index];
   if (!arg.startsWith('--')) {
     const prev = argv[index - 1];
-    return Boolean(prev && ['--root', '--target', '--type', '--tool-command', '--last-prompt', '--session-id', '--adapter', '--transcript'].includes(prev));
+    return Boolean(prev && ['--root', '--target', '--type', '--tool-command', '--last-prompt', '--session-id', '--task-instance-id', '--adapter', '--transcript'].includes(prev));
   }
   return true;
 }
@@ -5550,6 +5576,7 @@ function createSharedRouteState({
   source = 'task-route',
   requestKey = null,
   sessionId = null,
+  taskInstanceId = `task-${crypto.randomBytes(16).toString('hex')}`,
 }) {
   const helpers = compactHelpers({
     verificationRecommendation: route.verificationRecommendation ?? null,
@@ -5559,6 +5586,7 @@ function createSharedRouteState({
   return {
     ...(sessionId ? { sessionId } : {}),
     requestKey,
+    taskInstanceId,
     fingerprint: buildRouteStateFingerprint(route),
     ts: Date.now(),
     source,

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

@@ -393,65 +393,9 @@ export async function runSidecarDecision({ decision, context = {}, rootDir, home
     fallbackPolicy: spec.fallbackPolicy,
   };
 
-  if (stage === 'off') {
-    return { ...base, answer: deterministic, source: 'deterministic', outcomeClass: 'deterministic' };
-  }
-
-  const result = runAdapterBatch({
-    spec, context: ctx, rootDir: rootDir ?? process.cwd(), config: mergedConfig,
-    batchId: `sidecar-${decision}-${Date.now().toString(36)}`,
-  });
-  const modelAnswer = validModelAnswer(result, spec.decisionKey);
-  const outcomeClass = result?.status ?? 'unavailable';
-  const agreement = modelAnswer === null
-    ? 'unknown'
-    : modelAnswer.toLowerCase() === String(deterministic).toLowerCase()
-      ? 'agree'
-      : 'disagree';
-
-  if (outcomeClass === 'unavailable' || outcomeClass === 'unsupported' || outcomeClass === 'invalid') {
-    return {
-      ...base,
-      answer: deterministic,
-      source: 'deterministic-fallback',
-      outcomeClass: 'unavailable',
-      modelAnswer,
-      agreement,
-      fallbackCode: result?.fallbackCode ?? outcomeClass,
-    };
-  }
-  if (stage === 'shadow') {
-    return {
-      ...base,
-      answer: deterministic,
-      source: 'deterministic',
-      outcomeClass,
-      modelAnswer,
-      agreement,
-      fallbackCode: result?.fallbackCode ?? null,
-    };
-  }
-  // canary/default: valid model answer wins; invalid → deterministic fallback.
-  if (modelAnswer !== null) {
-    return {
-      ...base,
-      answer: modelAnswer,
-      source: 'unic-decision',
-      outcomeClass,
-      modelAnswer,
-      agreement,
-      fallbackCode: result?.fallbackCode ?? null,
-    };
-  }
-  return {
-    ...base,
-    answer: deterministic,
-    source: 'deterministic-fallback',
-    outcomeClass,
-    modelAnswer,
-    agreement,
-    fallbackCode: result?.fallbackCode ?? 'missing-answer',
-  };
+  // All six sidecar decisions have complete deterministic rules. A model vote
+  // cannot waive their constraints; skip inference rather than ask and clamp.
+  return { ...base, answer: deterministic, source: 'deterministic', outcomeClass: 'deterministic' };
 }
 
 // ---------------------------------------------------------------------------

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

@@ -83,23 +83,20 @@ export function encodeQuestion(question) {
       description: 'true iff the proposition holds; interpreted as P(true).',
     };
   } else {
-    // score — ordinal integer; the legend MUST be defined in the description.
-    const legend = Array.isArray(candidates) ? candidates : [];
-    value = { type: 'integer' };
-    if (legend.length > 0) {
-      value.minimum = 1;
-      value.maximum = legend.length;
-      value.description = `Ordered scale: ${legend
-        .map((label, i) => `${i + 1}=${label}`)
-        .join(', ')}.`;
+    if (!Array.isArray(candidates) || candidates.length === 0
+        || candidates.some(label => typeof label !== 'string' || !label.trim())
+        || new Set(candidates).size !== candidates.length) {
+      throw new TypeError('score requires unique non-empty ordinal labels.');
     }
+    value = { type: 'string', enum: [...candidates] };
   }
 
   return {
     type: 'function',
     function: {
       name: decisionKey,
-      description: String(instruction ?? ''),
+      description: String(instruction ?? '') + (kind === 'score'
+        ? `\nOrdered ordinal rubric: ${candidates.map((label, i) => `${i + 1}=${JSON.stringify(label)}`).join(', ')}. Choose exactly one label; do not return an expected numeric score.` : ''),
       parameters: {
         type: 'object',
         properties: { value },
@@ -196,11 +193,12 @@ function validateValue(question, args) {
     if (isFiniteNumber(value) && value >= 0 && value <= 1) return { value };
     return 'missing-value';
   }
-  // score — finite integer within the declared legend range.
-  if (!isFiniteNumber(value) || !Number.isInteger(value)) return 'missing-value';
+  // Decode an explicit choice losslessly; never reinterpret native expectations.
   const legend = Array.isArray(question.candidates) ? question.candidates : [];
-  if (legend.length > 0 && (value < 1 || value > legend.length)) return 'out-of-enum';
-  return { value };
+  if (!legend.length || new Set(legend).size !== legend.length) return 'out-of-enum';
+  if (typeof value !== 'string') return 'missing-value';
+  const ordinal = legend.indexOf(value);
+  return ordinal < 0 ? 'out-of-enum' : { value: ordinal + 1 };
 }
 
 export function parseBatchResponse(response, questions) {
@@ -834,6 +832,21 @@ export async function requestBatch(batch, {
     return outcome('invalid', { fallbackCode: 'empty-batch' });
   }
 
+  const maxBatch = dp.maxBatchQuestions ?? 8;
+  const maxEnum = dp.maxEnumLabels ?? 11;
+  if (![maxBatch, maxEnum].every(n => Number.isInteger(n) && n > 0)) {
+    return outcome('unsupported', { fallbackCode: 'invalid-decision-limits' });
+  }
+  if (questions.length > maxBatch) {
+    return outcome('unsupported', { fallbackCode: 'max-batch-questions' });
+  }
+  if (questions.some(q => Array.isArray(q.candidates) && q.candidates.length > maxEnum)) {
+    return outcome('unsupported', { fallbackCode: 'max-enum-labels' });
+  }
+  if (new Set(questions.map(q => q.decisionKey)).size !== questions.length) {
+    return outcome('invalid', { fallbackCode: 'duplicate-question' });
+  }
+
   // Language classification covers state + question text; the English
   // checkpoint is reachable only when the whole request proves English.
   // Malformed batch input (cyclic state, non-serializable values, internal

package/template_project/.claude/ukit/runtime/cron-operation-adapter.mjs

@@ -0,0 +1,43 @@
+// Capability adapters normalize native results; completion consumes their common receipt shape.
+const ID = /^[a-f0-9-]{8,36}$/i;
+function responseText(response) {
+  if (typeof response === 'string') return response.trim();
+  if (response?.content !== undefined && (!Array.isArray(response.content)
+    || !response.content.every((c) => c?.type === 'text' && typeof c.text === 'string'))) return '';
+  if (typeof response?.output === 'string') return response.output.trim();
+  if (typeof response?.stdout === 'string') return response.stdout.trim();
+  if (Array.isArray(response?.content) && response.content.every((c) => c?.type === 'text' && typeof c.text === 'string')) {
+    return response.content.map((c) => c.text).join('\n').trim();
+  }
+  return '';
+}
+const capabilities = {
+  CronDelete: { domain: 'scheduled-job', role: 'mutation', normalize(input, response) {
+    const target = typeof input?.id === 'string' && ID.test(input.id) ? input.id.toLowerCase() : null;
+    return { target, accepted: Boolean(target && responseText(response) === `Cancelled ${input.id}`) };
+  } },
+  CronList: { domain: 'scheduled-job', role: 'state', normalize(_input, response) {
+    const body = response?.details && Object.hasOwn(response.details, 'jobs') ? response.details : response;
+    const structured = body != null && typeof body === 'object' && Object.hasOwn(body, 'jobs');
+    const jobs = Array.isArray(body?.jobs) ? body.jobs : null;
+    const ids = jobs && jobs.length <= 256 && jobs.every((job) => typeof job?.id === 'string' && ID.test(job.id))
+      ? jobs.map((job) => job.id.toLowerCase()) : null;
+    const partial = [body, response].some((value) => value?.partial === true || value?.hasMore === true
+      || Boolean(value?.nextCursor) || value?.complete === false);
+    const supportedContent = response?.content === undefined || (Array.isArray(response.content)
+      && response.content.every((c) => c?.type === 'text' && typeof c.text === 'string'));
+    const valid = !partial && supportedContent
+      && (structured ? ids !== null : /^No scheduled jobs\.?$/.test(responseText(response)));
+    return { target: null, state: 'absent', presentTargets: valid ? ids || [] : null, complete: valid, accepted: valid };
+  } },
+};
+export function cronOperationReceipt(toolName, input, response, transportSuccess, { sessionId, harness } = {}) {
+  const capability = capabilities[toolName];
+  if (!capability) return null;
+  const normalized = capability.normalize(input, response);
+  const { accepted, ...state } = normalized;
+  const scope = typeof sessionId === 'string' && sessionId.trim() ? `session:${sessionId.trim()}` : null;
+  return { kind: 'operation', success: transportSuccess === true && accepted && Boolean(scope),
+    transportSuccess: transportSuccess === true, harness,
+    operation: { domain: capability.domain, role: capability.role, scope, ...state } };
+}