@ngockhoale/ukit 3.4.30 → 3.4.32

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

@@ -653,12 +653,12 @@ function unique(values) {
 
 // Completion contract for a lane. Informational routes carry no completion debt;
 // every contract lane returns the still-missing evidence classes plus a reason.
-export function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
+export function buildCompletionState({ executionMode = null, verificationRecommendation = null, executionContract = null } = {}) {
   if (!executionMode || executionMode === 'informational') {
     return null;
   }
 
-  const contract = buildExecutionContract(executionMode);
+  const contract = executionContract || buildExecutionContract(executionMode);
   const missingEvidence = [...(contract?.completionEvidence ?? [])];
   const requiresVerification = missingEvidence.includes('verification-evidence');
   if (
@@ -1062,3 +1062,35 @@ export function deriveRouteFields({
     resolved,
   };
 }
+
+// Task semantics are independent of source execution strategy and observed progress.
+export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
+  const text = String(promptText).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/đ/g, 'd').toLowerCase();
+  const clauses = text.split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/);
+  const actionable = clauses.map((clause) => clause.split(/\bwithout\b/)[0]).filter((clause) => !/\b(?:do not|don't|never|khong|dung)\b/.test(clause)
+    && !/^\s*(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(clause));
+  const sourceOrder = actionable.some((clause) => /\b(?:implement|fix|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause)
+    && /\b(?:source|code|logic|scheduler|implementation|ma nguon)\b|\.[cm]?[jt]sx?\b/.test(clause));
+  const operation = actionable.some((clause) => /\b(?:delete|remove|cancel|xoa|huy|ensure|dam bao)\b/.test(clause)
+    && /\bcron\b|scheduled\s+(?:cron\s+)?(?:task|job)|tac vu\s+(?:cron|dinh ky)/.test(clause));
+  const config = actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh)\b/.test(clause));
+  const repository = Boolean(targetFile) || /[\w.-]+\.(?:json|ya?ml|toml|ini)\b/.test(text);
+  const readOnly = /\b(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(text)
+    && !sourceOrder && !operation && !config;
+  const taskKind = operation ? (sourceOrder ? 'MIXED' : 'OPERATIONAL')
+    : config ? 'CONFIGURATION' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
+  const id = text.match(/\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/)?.[0] || null;
+  return { taskKind, ...(config ? { configurationScope: repository ? 'repository' : 'external' } : {}),
+    ...(operation ? { operationGoal: { domain: 'scheduled-job', target: id, desiredState: /\b(?:delete|remove|cancel|xoa|huy|absent|removed|deleted|no longer|khong con)\b/.test(actionable.join(' ')) ? 'absent' : 'present',
+      completionSemantics: /\b(?:ensure|dam bao)\b/.test(text) ? 'ensure-state' : 'execute-and-verify' } } : {}) };
+}
+
+export function applyTaskSemantics(contract, semantic) {
+  const evidence = contract?.completionEvidence || [];
+  const operationOnly = semantic.taskKind === 'OPERATIONAL'
+    || (semantic.taskKind === 'CONFIGURATION' && semantic.configurationScope === 'external');
+  return { ...(contract || {}), ...semantic,
+    completionEvidence: operationOnly ? ['operation-verification']
+      : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
+        : semantic.taskKind === 'READ_ONLY' ? (evidence.length === 1 && evidence[0] === 'verification-evidence' ? evidence : ['impact-evidence']) : evidence };
+}

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
@@ -1638,6 +1663,11 @@ function probabilityBand(value) {
 // executionMode. The review/cross-check/verification-depth baselines are
 // produced by later wave modules; until then their baseline stays null and
 // receipts record bands + agreement 'unknown' — real data, not fabricated.
+// Route-shadow questions that add no observation: asked authoritatively by the
+// fix-loop escalation batch (verification.depth.v1) and without a route-level
+// baseline to compare against here.
+const SHADOW_REDUNDANT_KEYS = new Set(['verification.depth.v1']);
+
 function shadowBaselineFor(decisionKey, routeSummary) {
   if (decisionKey === 'route.intent-kind.v1') return routeSummary?.intent?.kind ?? null;
   if (decisionKey === 'route.rigor.v1') return routeSummary?.execution?.rigor ?? null;
@@ -1794,7 +1824,42 @@ export async function runRouteDecisionShadow({
   // Greeting fast-path: a social turn carries nothing the decision plane could
   // answer — never spawn the adapter shadow for one.
   if (routingContext?.greetingFastPath) return null;
-  const questions = buildShadowDecisionQuestions(config);
+  // Observation-only batch: honour the adapter request caps without a second
+  // call. Selection is semantic, not positional: (1) enums over maxEnumLabels
+  // are never truncated, they are skipped (`enum-cap`); (2) questions the route
+  // cannot compare to a deterministic baseline AND that another stage already
+  // asks authoritatively are redundant here; (3) the remainder is ranked
+  // baseline-comparable first, table order within a rank, and cut at
+  // maxBatchQuestions (`batch-cap`). Every skip is reported with its reason.
+  const shadowCaps = {
+    batch: Number.isInteger(config?.decisionPlane?.maxBatchQuestions) && config.decisionPlane.maxBatchQuestions > 0
+      ? config.decisionPlane.maxBatchQuestions : 8,
+    labels: Number.isInteger(config?.decisionPlane?.maxEnumLabels) && config.decisionPlane.maxEnumLabels > 0
+      ? config.decisionPlane.maxEnumLabels : 11,
+  };
+  const wanted = buildShadowDecisionQuestions(config);
+  const skippedDecisions = [];
+  const candidatesForBatch = [];
+  for (const q of wanted) {
+    if ((q.candidates?.length ?? 0) > shadowCaps.labels) {
+      skippedDecisions.push({ decisionKey: q.decisionKey, reason: 'enum-cap' });
+    } else if (SHADOW_REDUNDANT_KEYS.has(q.decisionKey)) {
+      skippedDecisions.push({ decisionKey: q.decisionKey, reason: 'redundant' });
+    } else {
+      candidatesForBatch.push(q);
+    }
+  }
+  const hasBaseline = (q) => shadowBaselineFor(q.decisionKey, routeSummary) != null;
+  const ranked = [
+    ...candidatesForBatch.filter(hasBaseline),
+    ...candidatesForBatch.filter((q) => !hasBaseline(q)),
+  ];
+  const picked = new Set(ranked.slice(0, shadowCaps.batch));
+  for (const q of candidatesForBatch) {
+    if (!picked.has(q)) skippedDecisions.push({ decisionKey: q.decisionKey, reason: 'batch-cap' });
+  }
+  const questions = candidatesForBatch.filter((q) => picked.has(q));
+  const skippedDecisionKeys = skippedDecisions.map((d) => d.decisionKey);
   if (questions.length === 0) {
     return { stage, outcomeClass: 'skipped', decisionKeys: [], probabilityBands: {},
       checkpoint: null, latencyClass: 'unknown', fallbackCode: 'no-enabled-families',
@@ -1879,6 +1944,10 @@ export async function runRouteDecisionShadow({
     };
   }
 
+  // Partial coverage is never reported as full success.
+  if (skippedDecisions.length > 0 && result.status === 'accepted') {
+    result = { ...result, status: 'partial' };
+  }
   const receipt = buildDecisionShadowReceipt({
     stage,
     result,
@@ -1935,7 +2004,14 @@ export async function runRouteDecisionShadow({
       // Receipt loss is advisory — never fail the route over telemetry.
     }
   }
-  return receipt;
+  return skippedDecisions.length > 0
+    ? {
+        ...receipt,
+        skippedDecisionKeys,
+        skippedDecisions,
+        coverage: { asked: questions.length, total: wanted.length, complete: false },
+      }
+    : receipt;
 }
 
 // BL-018 (SPEC FR-006): the bounded-question `ask` seam — one batch through
@@ -3775,11 +3851,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 +5494,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 +5627,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 +5637,7 @@ function createSharedRouteState({
   return {
     ...(sessionId ? { sessionId } : {}),
     requestKey,
+    taskInstanceId,
     fingerprint: buildRouteStateFingerprint(route),
     ts: Date.now(),
     source,

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

@@ -296,67 +296,12 @@ export function buildStatePacket(decision, context) {
   return packet;
 }
 
-// ---------------------------------------------------------------------------
-// Adapter spawn — one bounded single-question batch to unic-decision.mjs.
-// Never throws: every failure resolves to a typed 'unavailable' result.
-// ---------------------------------------------------------------------------
-
-function runAdapterBatch({ spec, context, rootDir, config, batchId }) {
-  const cliPath = process.env.UKIT_DECISION_CLI_PATH || UNIC_DECISION_CLI_PATH;
-  const timeoutMs = Math.min(
-    (isFiniteNumber(config?.decisionPlane?.timeoutMs)
-      ? config.decisionPlane.timeoutMs
-      : ADAPTER_TIMEOUT_CAP_MS) + 1000,
-    ADAPTER_TIMEOUT_CAP_MS + 1000,
-  );
-  const batch = {
-    batchId,
-    boundary: 'sidecar',
-    deadlineMs: Math.max(500, timeoutMs - 1000),
-    statePacket: buildStatePacket(spec.decision, context),
-    questions: [spec.question],
-  };
-  let result = null;
-  try {
-    const spawned = spawnSync(
-      process.execPath,
-      [cliPath, '--root', rootDir],
-      {
-        cwd: rootDir,
-        input: JSON.stringify(batch),
-        encoding: 'utf8',
-        timeout: timeoutMs,
-      },
-    );
-    if (spawned && !spawned.error && spawned.status === 0 && spawned.stdout) {
-      result = JSON.parse(spawned.stdout);
-    } else {
-      result = { status: 'unavailable', fallbackCode: 'adapter-spawn-failed' };
-    }
-  } catch {
-    result = { status: 'unavailable', fallbackCode: 'adapter-spawn-failed' };
-  }
-  if (!result || typeof result !== 'object') {
-    result = { status: 'unavailable', fallbackCode: 'malformed-response' };
-  }
-  return result;
-}
-
-function validModelAnswer(result, decisionKey) {
-  const answers = Array.isArray(result?.answers) ? result.answers : [];
-  const answer = answers.find(
-    (a) => a?.decisionKey === decisionKey && a.validationStatus === 'valid',
-  );
-  return typeof answer?.value === 'string' ? answer.value : null;
-}
-
 /**
  * Resolve one sidecar decision. Returns a typed result; never throws.
  *   {decision, decisionKey, stage, answer, deterministic, source,
- *    outcomeClass, modelAnswer?, agreement?, fallbackCode}
- * `answer` is the authoritative value: the deterministic rule at 'off' and
- * 'shadow', the model's valid answer at 'canary'/'default', and the
- * deterministic rule again on any adapter failure (outcomeClass 'unavailable').
+ *    outcomeClass, fallbackPolicy}
+ * `answer` is always the deterministic rule at every stage: no model call is
+ * made, so there is no model answer, agreement or adapter fallback to report.
  */
 export async function runSidecarDecision({ decision, context = {}, rootDir, homeDir, config } = {}) {
   // Own-property lookup (W3-SD1): `SIDECAR_DECISIONS[name]` would also resolve
@@ -393,65 +338,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 } };
+}