@ngockhoale/ukit 3.4.29 → 3.4.31

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 } };
+}