@ngockhoale/ukit 3.1.0 → 3.1.2

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to UKit are documented here.
 
+## 3.1.2 - 2026-09-26
+
+- **Decision plane goes live on the UNIC provider** — the decision lane now resolves its own endpoint independent of the engine's LLM gateway, so UKit uses UNIC even when Claude Code/Codex/omp point elsewhere:
+  - **Endpoint chain**: `~/.ukit/storage/gateway.json` `{decision:{baseUrl,apiKey,scheme}}` → env `UKIT_DECISION_BASE_URL`/`UKIT_DECISION_API_KEY` → default `https://openai.unicjsc.com`; credential falls back to the shared UNIC token (ANTHROPIC_*). New resolvers `resolveDecisionBaseUrl`/`resolveDecisionApiKey` in `src/core/gatewayProbe.js`, mirrored in `unic-decision.mjs`.
+  - **Live transport fixes** (verified against the real gateway): SSE `data: [DONE]` trailer — sometimes glued to the JSON body — is stripped via balanced-object extraction; model answers use native arg names (`choice`/`noul`/`score`) now accepted alongside the schema's `value`; a `model_not_found` variant checkpoint retries once on the bare `unic-decision` alias.
+  - **Checkpoints**: shipped defaults collapse to the bare `unic-decision` model (the credential-safe alias); `unic-decision-multilingual`/variants remain configurable via `decisionPlane.checkpoints`.
+  - **Optional backlog drained**: injection-point contracts documented (deliberation `judge`, vmEngine `classifyFn`, completionGate `modelJudgment`), `memoryV2.decision` plane marked reserved, `resume.next-action.v1` + `verify.depth.v1` shadow questions wired, gatewayProbe marked migration-exempt.
+
+## 3.1.1 - 2026-09-26
+
+- **Decision plane — review + workflow families (UNIC_DECISION_MIGRATION S1–S4)** — the reserved `review` and `workflow` registry families are now populated and wired; all keys ship `rolloutStage: 'off'` so deterministic fallbacks stay authoritative (stage promotion is a separate owner decision):
+  - **Registry** (`src/decision/registry.js`): `review.verdict.v1`, `review.finding-bucket.v1`, `review.panel-verdict.v1`, `workflow.sidecar-lane.v1`, `workflow.sidecar-risk.v1`, `workflow.routing-needed.v1`, `workflow.step-budget.v1`, `workflow.compact-now.v1`, `workflow.summarize-vs-keep.v1` — all `choice` kind, `off`, deterministic fallback owners recorded.
+  - **Review adapter**: `src/decision/reviewVerdict.js` + installed twin `template_project/.claude/ukit/index/review-verdict.mjs` — findings (whitelisted `{id, severity, file, line, claim}`) in, stage-gated verdict + per-finding buckets out; reviewers still generate findings on the general model, only the bounded verdict moves to `unic-decision` when `decisionPlane.families.review.stage` is enabled.
+  - **Sidecar adapter**: `template_project/.claude/ukit/index/sidecar-decision.mjs` answers the six `.codex/settings.json` `smallTaskModel.decisionPolicy.decisions` via a bounded `unic-decision` batch (stage-gated `decisionPlane.families.workflow.stage`); adapter failure → deterministic rule answer, never another LLM.
+  - **Engine parity**: `.codex/ukit` is a symlink to `.claude/ukit` (installed layout), `decisionAdapter` hints in `.codex/settings.json`; all three index CLIs' `isMainModule` gates now use `realpathSync` + basename equality — symlinked invocation previously compared unresolved paths and silently exited 0 without running `main()`.
+  - **Docs/tests**: `docs/pstack/UNIC_DECISION_GUIDE.md` (family keys + adapters), `docs/GATEWAY.md` §8, `docs/MEMORY.md`; parity + symlink-invocation coverage in `tests/index/{unicDecision,reviewVerdictCli,sidecarDecision}.test.js`.
+
 ## 3.1.0 - 2026-09-26
 
 - **Flight recorder — Data Foundation wave (cycle C81)** — the observability pipeline grows from record/segment plumbing into a full local diagnostics surface; still opt-in behind `observability.stage` (default `off`, `off→shadow→canary→default` per seam, absolute kill switch):

package/manifests/platform.full.yaml

@@ -1750,6 +1750,30 @@ items:
     packs:
       - core
 
+  - id: ukit-index-review-verdict-script
+    type: config
+    sourceTemplate: .claude/ukit/index/review-verdict.mjs
+    targetPath: .claude/ukit/index/review-verdict.mjs
+    requires:
+      - ukit-index-unic-decision-script
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
+  - id: ukit-index-sidecar-decision-script
+    type: config
+    sourceTemplate: .claude/ukit/index/sidecar-decision.mjs
+    targetPath: .claude/ukit/index/sidecar-decision.mjs
+    requires:
+      - ukit-index-unic-decision-script
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: ukit-index-extract-image-script
     type: config
     sourceTemplate: .claude/ukit/index/extract-image.mjs

package/package.json

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

package/src/core/agentRuntime/completionGate.js

@@ -152,7 +152,10 @@ export function evaluateCompletionEvidence({
     verdict = 'FAILED';
   }
 
-  // modelJudgment may only request more evidence, never promote.
+  // modelJudgment may only request more evidence, never promote (enforced
+  // below: a judgment can downgrade PASS → MORE_EVIDENCE, nothing else). When
+  // model-backed, the judgment MUST originate from the decision plane
+  // (unic-decision, a bounded verdict question) — never a general LLM call.
   const judgment = modelJudgment != null
     ? (typeof modelJudgment === 'string' ? modelJudgment : String(modelJudgment))
     : null;

package/src/core/agentRuntime/vmEngine.js

@@ -85,6 +85,11 @@ async function writeFileAtomic(target, data) {
 }
 
 /**
+ * Migration contract (decision plane): `classifyFn` is invoked only when the
+ * IR itself cannot route an event (see deliver()). It may only consult the
+ * decision plane (unic-decision / createDecisionClient registry keys) for a
+ * bounded route/escalate answer — never a general LLM call.
+ *
  * @param {{dir:string, now?:()=>Date, classifyFn?:Function, startFn?:Function, hooks?:object}} opts
  */
 export function createVmEngine({ dir, now, classifyFn, startFn, hooks } = {}) {
@@ -512,7 +517,9 @@ export function createVmEngine({ dir, now, classifyFn, startFn, hooks } = {}) {
       return { consumed: false, code: 'out_of_order' };
     }
 
-    // classify only when the IR itself cannot route the event (G4-FR05)
+    // classify only when the IR itself cannot route the event (G4-FR05);
+    // classifyFn may consult the decision plane for bounded route/escalate
+    // answers only — never a general LLM call (see createVmEngine opts).
     let outcome = event.safePayload?.outcome;
     let targetMatched = matched;
     if (!targetMatched) {

package/src/core/experiments/deliberation.js

@@ -244,6 +244,12 @@ function deepFreezeCopy(value) {
  * verdict is post-checked: hard-constraint waivers/violations and
  * majority-only (citation-free) verdicts are rejected.
  *
+ * Migration contract (decision plane): an injected `judge` implementation
+ * that performs bounded verdict work MUST route it through the decision
+ * plane (`createDecisionClient` + `src/decision/registry.js` keys) — never a
+ * general LLM call. The default `smartJudge` is deterministic: pure scoring,
+ * hard-constraint filtering, and a stable sort — no I/O, no model calls.
+ *
  * @param {{candidates: object[], rubric: object, judge: Function,
  *   config?: object}} input
  * @returns {{status: 'ok'|'disabled'|'rejected', selected?: object|null,

package/src/core/gatewayProbe.js

@@ -23,6 +23,52 @@ import path from 'node:path';
 
 const GATEWAY_DOC = 'docs/GATEWAY.md';
 const SETTINGS_RELATIVE_PROBE_PATH = path.join('.claude', 'settings.json');
+// --- Decision-plane gateway resolution (UNIC_DECISION_MIGRATION backlog) -----
+// The decision plane is a SEPARATE lane from the host's LLM endpoint: it must
+// reach the UNIC OpenAI-compatible provider no matter what Claude Code/omp is
+// configured to. Chain: ~/.ukit/storage/gateway.json {decision:{baseUrl,
+// apiKey, scheme}} → env UKIT_DECISION_BASE_URL / UKIT_DECISION_API_KEY →
+// DEFAULT_DECISION_BASE_URL + the shared UNIC token (ANTHROPIC_*) so a host
+// already pointed at UNIC works with zero extra config. Missing key → the
+// caller surfaces 'unavailable' and deterministic policy stays authoritative.
+export const DEFAULT_DECISION_BASE_URL = 'https://openai.unicjsc.com';
+const USER_GATEWAY_REL = path.join('.ukit', 'storage', 'gateway.json');
+
+function readUserGatewayDecision(homeDir) {
+  if (!homeDir) return null;
+  const json = safeReadJson(path.join(homeDir, USER_GATEWAY_REL));
+  const decision = json?.decision;
+  return decision && typeof decision === 'object' ? decision : null;
+}
+
+// Endpoint for the decision lane. Never throws; file and env malformed values
+// are ignored, the default is the final fallback (not ANTHROPIC_BASE_URL —
+// that env may point at a non-decision gateway).
+export function resolveDecisionBaseUrl({ homeDir = os.homedir(), env = process.env } = {}) {
+  const file = readUserGatewayDecision(homeDir);
+  const fromFile = pickString(file?.baseUrl);
+  if (fromFile) return { baseUrl: fromFile, source: 'ukit-gateway-json' };
+  const fromEnv = pickString(env?.UKIT_DECISION_BASE_URL);
+  if (fromEnv) return { baseUrl: fromEnv, source: 'env' };
+  return { baseUrl: DEFAULT_DECISION_BASE_URL, source: 'default' };
+}
+
+// API key for the decision lane. `scheme`: 'auth-token' → Authorization: Bearer
+// (UNIC OpenAI-compatible default) | 'api-key' → x-api-key. Falls back to the
+// host's UNIC token so existing installs need no duplicate credential.
+export function resolveDecisionApiKey({ projectRoot, homeDir = os.homedir(), env = process.env } = {}) {
+  const file = readUserGatewayDecision(homeDir);
+  const fileKey = pickString(file?.apiKey);
+  if (fileKey) {
+    const scheme = file?.scheme === 'api-key' ? 'api-key' : 'auth-token';
+    return { value: fileKey, scheme, source: 'ukit-gateway-json' };
+  }
+  const envKey = pickString(env?.UKIT_DECISION_API_KEY);
+  if (envKey) return { value: envKey, scheme: 'auth-token', source: 'env' };
+  const shared = resolveGatewayApiKey({ projectRoot, homeDir, env });
+  if (shared?.value) return { ...shared, source: 'shared-unic-token' };
+  return { value: null, scheme: null, source: null };
+}
 
 function safeReadFile(filePath) {
   try {
@@ -491,6 +537,13 @@ async function runNonStreamingProbe({ url, headers, body: requestBody, fetchImpl
 }
 
 /**
+ * Migration-contract exemption (decision plane): the two `fetchImpl` calls below
+ * are the ONLY generic-LLM HTTP calls under src/. They are diagnostic-only —
+ * connectivity probes that send a trivial "pong?" message and measure the
+ * transport (SSE events, buffering, Anthropic Message shape) — and are
+ * intentionally NOT routed through the decision plane: no bounded verdict
+ * vocabulary exists for a connectivity probe. Keep-as-probe; do not migrate.
+ *
  * Runs both probes against `baseUrl`. Returns a structured result; never propagates exceptions
  * — every failure is reflected in the returned object so the CLI can print it.
  *

package/src/core/memory/memoryFlags.js

@@ -4,6 +4,12 @@
 // resolveConfigStage machinery: off → shadow → canary → default. Flags only
 // ever REDUCE capability — malformed/missing resolves 'off', killSwitch is
 // absolute, and 'canary' without an opted-in projectId resolves 'off'.
+// The `decision` plane is reserved for the memoryV2 candidate-classification
+// lane (registry key `learn.candidate-class.v1`, family 'learn'). Note the
+// decision-plane stage namespace is separate: promotion gates that key via
+// `decisionPlane.families.learn.stage`, NOT `memoryV2.decision.stage` — this
+// flag only guards the memoryV2 lane itself. Zero consumers today — do not
+// remove; user configs may pin its stage key.
 //
 // Shadow receipts are the only telemetry: bounded JSONL of counts/codes/
 // latency bands — never record text, prompt bodies, or secrets.

package/src/core/runtimeConfig.js

@@ -304,9 +304,9 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
       stage: 'off',
       logicalModel: 'unic-decision',
       checkpoints: {
-        default: 'unic-decision/laya-multilingual',
-        english: 'unic-decision/laya',
-        unknownLanguage: 'unic-decision/auto',
+        default: 'unic-decision',
+        english: 'unic-decision',
+        unknownLanguage: 'unic-decision',
       },
       timeoutMs: 5000,
       maxStateTokens: { multilingual: 1024, english: 512 },

package/src/decision/client.js

@@ -27,8 +27,8 @@
 
 import { createHash } from 'node:crypto';
 import {
-  resolveGatewayBaseUrl,
-  resolveGatewayApiKey,
+  resolveDecisionBaseUrl,
+  resolveDecisionApiKey,
 } from '../core/gatewayProbe.js';
 import {
   encodeBatch,
@@ -42,11 +42,20 @@ import {
 } from './statePacket.js';
 
 const DEFAULT_CHECKPOINTS = {
-  default: 'unic-decision/laya-multilingual',
-  english: 'unic-decision/laya',
-  unknownLanguage: 'unic-decision/auto',
+  // Bare 'unic-decision' is the credential-safe alias — the only checkpoint a
+  // freshly-bound UNIC decision key serves. Variants (e.g.
+  // unic-decision-multilingual once the provider binds it) override via
+  // decisionPlane.checkpoints.
+  default: 'unic-decision',
+  english: 'unic-decision',
+  unknownLanguage: 'unic-decision',
 };
 
+// Credential-safe alias: every UNIC decision credential binds the bare name
+// first — variants (unic-decision-multilingual, …) may lag. On model_not_found
+// the client falls back here once per batch.
+const FALLBACK_CHECKPOINT = 'unic-decision';
+
 const DEFAULT_TIMEOUT_MS = 5000;
 const DEFAULT_MAX_RETRIES = 1;
 const DEFAULT_BREAKER = { failureThreshold: 3, cooldownMs: 30_000 };
@@ -102,9 +111,44 @@ function isTransientStatus(status) {
   return status === 429 || (status >= 500 && status <= 599);
 }
 
+// The UNIC decision endpoint streams the completion even without stream:true —
+// the body is one JSON object followed by an SSE "data: [DONE]" trailer.
+// Parse the first JSON object, ignore the trailer.
+function parseMaybeSse(text) {
+  const trimmed = String(text ?? '').trim();
+  if (!trimmed.startsWith('{')) {
+    // Pure SSE frames: join data payloads.
+    const payload = trimmed
+      .split('\n')
+      .filter((line) => line.startsWith('data:') && !line.includes('[DONE]'))
+      .map((line) => line.slice(5).trim())
+      .join('');
+    return JSON.parse(payload || trimmed);
+  }
+  // JSON object possibly followed by a glued SSE trailer (`}data: [DONE]`,
+  // observed live) — extract the balanced object, strings/comments aware.
+  let depth = 0;
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const ch = trimmed[i];
+    if (ch === '"' || ch === "'") {
+      for (let j = i + 1; j < trimmed.length; j += 1) {
+        if (trimmed[j] === '\\') j += 1;
+        else if (trimmed[j] === ch) { i = j; break; }
+      }
+      continue;
+    }
+    if (ch === '{') depth += 1;
+    else if (ch === '}') {
+      depth -= 1;
+      if (depth === 0) return JSON.parse(trimmed.slice(0, i + 1));
+    }
+  }
+  return JSON.parse(trimmed);
+}
+
 async function readResponseBody(res) {
+  if (res && typeof res.text === 'function') return parseMaybeSse(await res.text());
   if (res && typeof res.json === 'function') return res.json();
-  if (res && typeof res.text === 'function') return JSON.parse(await res.text());
   return res;
 }
 
@@ -167,9 +211,13 @@ export function createDecisionClient({
   }
 
   async function resolveEndpoint() {
-    const base = await resolveGatewayBaseUrl({ projectRoot, homeDir, env });
+    // Decision lane resolves its own endpoint (user-level gateway.json →
+    // env → openai.unicjsc.com default), independent of the host's LLM
+    // endpoint — the UNIC provider is used even when the engine points
+    // elsewhere.
+    const base = await resolveDecisionBaseUrl({ projectRoot, homeDir, env });
     if (!base?.baseUrl) return null;
-    const key = await resolveGatewayApiKey({ projectRoot, homeDir, env });
+    const key = await resolveDecisionApiKey({ projectRoot, homeDir, env });
     return {
       url: `${String(base.baseUrl).replace(/\/+$/, '')}/v1/chat/completions`,
       headers: buildAuthHeaders(key),
@@ -305,6 +353,27 @@ export function createDecisionClient({
 
         const status = res?.status ?? (res?.ok === false ? 500 : 200);
         if (res?.ok === false || status < 200 || status >= 300) {
+          // A variant checkpoint without bound credentials (e.g.
+          // unic-decision-multilingual before provider binding) returns a 4xx
+          // model_not_found body — retry once on the bare `unic-decision`
+          // model, the credential-safe alias the owner provisions first.
+          if (checkpoint !== FALLBACK_CHECKPOINT) {
+            let notFound = status === 404;
+            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;
+            } catch { /* keep status-based guess */ }
+            if (notFound) {
+              checkpoint = FALLBACK_CHECKPOINT;
+              try {
+                body = JSON.stringify(
+                  encodeBatch({ model: checkpoint, statePacket: serialized, questions }),
+                );
+              } catch { /* keep prior body */ }
+              continue;
+            }
+          }
           if (isTransientStatus(status) && attempt + 1 < maxAttempts) continue;
           if (status === 401 || status === 403) {
             lastError = 'unavailable';

package/src/decision/protocol.js

@@ -169,7 +169,10 @@ function normalizeProbabilities(raw) {
 }
 
 function validateValue(question, args) {
-  const value = args?.value;
+  // The model answers with its native field names — `choice`/`noul`/`score` —
+  // not the schema's `value`; accept both so a live gateway isn't parsed as
+  // malformed.
+  const value = args?.value ?? args?.choice ?? args?.noul ?? args?.score;
   if (question.kind === 'choice') {
     if (typeof value !== 'string') return 'missing-value';
     if (!Array.isArray(question.candidates) || !question.candidates.includes(value)) return 'out-of-enum';

package/src/decision/registry.js

@@ -259,7 +259,7 @@ export const DECISION_REGISTRY = Object.freeze([
     family: 'learn',
     owner: 'learningCandidates',
     kind: 'choice',
-    description: 'Learning candidate classification for a captured signal.',
+    description: 'Learning candidate classification for a captured signal. Reserved for the memoryV2 decision lane; promotion gates via decisionPlane.families.learn.stage.',
     candidatePolicy: 'owner-shortlist',
     hardConstraints: ['promotion-approval'],
     probabilityPolicy: 'raw-label',
@@ -269,6 +269,150 @@ export const DECISION_REGISTRY = Object.freeze([
     cacheSensitivity: 'none',
     leasePolicy: 'none',
   },
+  {
+    decisionKey: 'review.verdict.v1',
+    schemaVersion: 1,
+    family: 'review',
+    owner: 'handoffReview',
+    kind: 'choice',
+    description: 'Bounded review verdict among APPROVED | APPROVED-WITH-MINOR | CHANGES-REQUESTED | CRITICAL.',
+    candidatePolicy: 'fixed-verdict-vocabulary',
+    hardConstraints: ['verdict-vocabulary'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-human-review',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'review.finding-bucket.v1',
+    schemaVersion: 1,
+    family: 'review',
+    owner: 'handoffReview',
+    kind: 'choice',
+    description: 'Triage bucket for one review finding among Act on | Consider | Noted | Dismissed.',
+    candidatePolicy: 'fixed-bucket-vocabulary',
+    hardConstraints: ['bucket-vocabulary'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-human-review',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'review.panel-verdict.v1',
+    schemaVersion: 1,
+    family: 'review',
+    owner: 'handoffReview',
+    kind: 'choice',
+    description: 'Aggregated panel verdict for a review artifact.',
+    candidatePolicy: 'fixed-verdict-vocabulary',
+    hardConstraints: ['verdict-vocabulary'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-human-review',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'workflow.sidecar-lane.v1',
+    schemaVersion: 1,
+    family: 'workflow',
+    owner: 'smallTaskMaintainer',
+    kind: 'choice',
+    description: 'Bounded decision whether a chore belongs to the sidecar lane.',
+    candidatePolicy: 'owner-shortlist',
+    hardConstraints: ['lane-eligibility'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-lane-rules',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'workflow.sidecar-risk.v1',
+    schemaVersion: 1,
+    family: 'workflow',
+    owner: 'smallTaskMaintainer',
+    kind: 'choice',
+    description: 'Bounded risk class for a sidecar candidate (safe/reversible vs escalate).',
+    candidatePolicy: 'owner-shortlist',
+    hardConstraints: ['risk-floor'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-lane-rules',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'workflow.routing-needed.v1',
+    schemaVersion: 1,
+    family: 'workflow',
+    owner: 'smallTaskMaintainer',
+    kind: 'choice',
+    description: 'Whether routing/intent classification is needed for a prompt.',
+    candidatePolicy: 'owner-shortlist',
+    hardConstraints: ['lane-eligibility'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-route',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'workflow.step-budget.v1',
+    schemaVersion: 1,
+    family: 'workflow',
+    owner: 'smallTaskMaintainer',
+    kind: 'choice',
+    description: 'Bounded step-budget class for an in-flight task.',
+    candidatePolicy: 'owner-shortlist',
+    hardConstraints: ['task-boundary'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-budget',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'workflow.compact-now.v1',
+    schemaVersion: 1,
+    family: 'workflow',
+    owner: 'smallTaskMaintainer',
+    kind: 'choice',
+    description: 'Whether to compact context at the current boundary.',
+    candidatePolicy: 'owner-shortlist',
+    hardConstraints: ['task-boundary'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-threshold',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
+  {
+    decisionKey: 'workflow.summarize-vs-keep.v1',
+    schemaVersion: 1,
+    family: 'workflow',
+    owner: 'smallTaskMaintainer',
+    kind: 'choice',
+    description: 'Summarize vs keep for a stored artifact/message.',
+    candidatePolicy: 'owner-shortlist',
+    hardConstraints: ['task-boundary', 'source-freshness'],
+    probabilityPolicy: 'raw-label',
+    fallbackPolicy: 'deterministic-threshold',
+    telemetryClass: 'decision',
+    rolloutStage: 'off',
+    cacheSensitivity: 'none',
+    leasePolicy: 'none',
+  },
 ]);
 
 // Deep-freeze the shipped catalog — entries are shared metadata consumed by