@ngockhoale/ukit 3.4.47 → 3.4.48

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to UKit are documented here.
 
+## 3.4.48 - 2026-10-19
+
+**Completion evidence closure and reproducible multi-host installation.**
+- Recognize standalone `git diff --check` as native Git verification rather than a dry-run mutation. Failed/masked mutations, piped verification, foreign-task evidence and release remote/tag divergence still block.
+- Preserve task ownership through host-consumed coordination notices and continuations; bound Stop diagnostics without accepting incomplete work. Explicit no-publication lists and quoted/report-only references do not authorize a release.
+- Integrate verified OMP child-session/model-ownership safeguards, delegation runtime, installer defaults migration, runtime package dependencies and reproducible scaffolds.
+- Verified locally on macOS/Node 22. Claude/Codex/OMP asset installation is covered; OMP Full Playbook live correctness and trusted worker/dispatch attribution remain UNVERIFIED. No paid OMP smoke or cross-platform live PASS is claimed.
+
 ## 3.4.47 - 2026-10-18
 
 **Supervisor subagent usage attribution and rendered-instruction parity checks.**

package/manifests/documentation.yaml

@@ -517,6 +517,28 @@ entries:
     validation: [none]
     archive_policy: immutable
     notes: 2026-10-10 orchestration regression test inventory
+  - id: docs-analysis-completion-task-ownership
+    path: docs/analysis/COMPLETION-TASK-OWNERSHIP.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/COMPLETION-TASK-OWNERSHIP.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-19 task boundary reproduction and bounded Stop verification
+  - id: docs-analysis-omp-runtime-closure
+    path: docs/analysis/OMP-RUNTIME-CLOSURE.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/OMP-RUNTIME-CLOSURE.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-19 captured OMP lifecycle closure and offline verification boundaries
   - id: docs-analysis-orchestration-final-verification
     path: docs/analysis/ORCHESTRATION-FINAL-VERIFICATION.md
     class: archive

package/manifests/platform.full.yaml

@@ -1222,6 +1222,7 @@ items:
       - hook-auto-allow-bash
       - hook-block-dangerous
       - hook-handoff-model-guard
+      - hook-delegation-gate-module
       - hook-auto-prune-bash
       - hook-project-important
     # Env block is post-merged by applyGatewayResilienceEnv (TASK-011) to add managed
@@ -1422,6 +1423,20 @@ items:
     packs:
       - core
 
+  # P0 delegation enforcement: in-proc PreToolUse chain step (Edit|Write, MultiEdit, Bash). Claude Code
+  # only (agent_id main/worker identity); reads route state + ledger from ukit-runtime-scripts.
+  - id: hook-delegation-gate-module
+    type: hook
+    sourceTemplate: .claude/hooks/delegation-gate.mjs
+    targetPath: .claude/hooks/delegation-gate.mjs
+    requires:
+      - ukit-runtime-scripts
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: hook-handoff-model-guard
     type: hook
     sourceTemplate: .claude/hooks/handoff-model-guard.sh
@@ -1442,6 +1457,7 @@ items:
       - ukit-runtime-scripts
       - ukit-index-route-resolver-script
       - ukit-index-tier-selection-script
+      - ukit-index-tier-lane-script
     mergeStrategy: overwrite_with_backup
     variables: []
     enabledByDefault: true
@@ -1865,6 +1881,16 @@ items:
     packs:
       - core
 
+  - id: ukit-index-tier-lane-script
+    type: config
+    sourceTemplate: .claude/ukit/index/tier-lane.mjs
+    targetPath: .claude/ukit/index/tier-lane.mjs
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: ukit-index-session-history-extractor-script
     type: config
     sourceTemplate: .claude/ukit/index/session-history-extractor.mjs
@@ -2012,6 +2038,7 @@ items:
       - ukit-index-session-history-extractor-script
       - ukit-index-fix-loop-escalation-script
       - ukit-index-tier-selection-script
+      - ukit-index-tier-lane-script
     mergeStrategy: overwrite_with_backup
     variables: []
     enabledByDefault: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "3.4.47",
+  "version": "3.4.48",
   "description": "Install/update an index-first AI workspace for Claude Code, OpenAI Codex and omp (Oh My Pi).",
   "license": "MIT",
   "type": "module",
@@ -36,6 +36,9 @@
     "!scripts/audit/c100/usage-provenance.mjs",
     "!scripts/audit/decision-coverage.mjs",
     "!scripts/audit/subagent-cost/**",
+    "!scripts/bench/**",
+    "scripts/bench/decision-runtime-metrics.mjs",
+    "!scripts/perf/**",
     "template_project/",
     "template_user/",
     "!template_project/**/.smbdelete*",

package/scripts/dev/worktree-preflight.mjs

@@ -7,6 +7,8 @@
 //   - already bootstrapped            → no-op
 //   - missing prerequisites           → run `ukit install` once, re-check
 //   - not a linked worktree           → refuse (the primary checkout's .claude/ is the maintainer runtime)
+// Install can also create template-owned scaffolds missing from the checkout (docs/AI_HANDOFF/PLAN.md, SPEC.md);
+// those are not gitignored, so they are reported as `visibleWrites` + a warning, never hidden or deleted.
 // `ukit install` writes the install flavour of root CLAUDE.md/AGENTS.md, but those files are
 // gitignored *render outputs* of template_project/instructions (docs:render). The preflight
 // re-renders them when they drift — never a tracked render target, which is only reported.
@@ -57,6 +59,15 @@ function isTracked(root, rel) {
 
 const RENDER_CLI = 'scripts/docs/render-instructions.mjs';
 
+// Visible (non-ignored) paths in `git status`. `ukit install` creates template-owned scaffolds that
+// are missing from the checkout (docs/AI_HANDOFF/PLAN.md, SPEC.md — mergeStrategy skip, handoff-clear
+// restores them to template, never deletes them). They are not gitignored, so a HEAD that lost them
+// turns the bootstrap into a visible write. Report it truthfully instead of hiding or deleting it.
+function visibleStatus(root) {
+  const res = spawnSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd: root, encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
+  return res.status === 0 ? new Set(res.stdout.split('\n').filter(Boolean)) : null;
+}
+
 // → rel paths whose rendered bytes differ from disk (`DRIFT <target>` lines of --check).
 export function renderDrift(root) {
   const res = spawnSync(process.execPath, [path.join(root, RENDER_CLI), '--check'], { cwd: root, encoding: 'utf8', timeout: RENDER_TIMEOUT_MS });
@@ -71,7 +82,7 @@ export function missingPrerequisites(root) {
 
 export function preflight({ root, check = false } = {}) {
   const projectRoot = fs.realpathSync(root);
-  const result = { root: projectRoot, ok: false, bootstrapped: false, missing: [], rendered: [], warnings: [], home: null, error: null };
+  const result = { root: projectRoot, ok: false, bootstrapped: false, missing: [], rendered: [], visibleWrites: [], warnings: [], home: null, error: null };
 
   if (!fs.existsSync(path.join(projectRoot, 'bin/ukit'))) {
     return { ...result, exitCode: 2, error: `not a UKit checkout (no bin/ukit): ${projectRoot}` };
@@ -91,6 +102,7 @@ export function preflight({ root, check = false } = {}) {
     // worktree's ignored .cache/ so a preflight never mutates the real home or leaks from it.
     result.home = path.join(projectRoot, '.cache/worktree-preflight-home');
     fs.mkdirSync(result.home, { recursive: true });
+    const visibleBefore = visibleStatus(projectRoot);
     const install = spawnSync(process.execPath, [path.join(projectRoot, 'bin/ukit'), 'install'], {
       cwd: projectRoot,
       encoding: 'utf8',
@@ -98,6 +110,13 @@ export function preflight({ root, check = false } = {}) {
       timeout: 120_000,
     });
     result.bootstrapped = true;
+    const visibleAfter = visibleStatus(projectRoot);
+    if (visibleBefore && visibleAfter) {
+      result.visibleWrites = [...visibleAfter].filter((l) => !visibleBefore.has(l)).map((l) => l.slice(3));
+      if (result.visibleWrites.length > 0) {
+        result.warnings.push(`ukit install created non-ignored file(s) missing from this checkout: ${result.visibleWrites.join(', ')} — template-owned scaffolds; restore/commit them (not deleted)`);
+      }
+    }
     result.missing = missingPrerequisites(projectRoot);
     if (install.status !== 0 || result.missing.length > 0) {
       const tail = `${install.stdout || ''}${install.stderr || ''}`.trim().split('\n').slice(-5).join('\n');

package/src/core/diffPlan.js

@@ -62,6 +62,15 @@ async function checkLinkStatus(targetPath, linkTarget) {
 //   Template-filled:                    keys the user does not have take the template value.
 // Gateway-resilience env keys are post-apply managed (applyGatewayResilienceEnv) and are
 // ignored by the drift comparison.
+//
+// One-time defaults migration (orchestrator tier + effort): UKit used to ship `model: "sonnet"`
+// and `effortLevel: "high"`; it now ships `opus` / `medium` (main orchestrator = Tier 3, effort
+// Medium unless the task is high-risk). A key is migrated ONLY when the file is UKit-tracked, the
+// user's value still equals the old shipped default, and the migration has not run before
+// (install.json `settingsDefaultsMigration`) — so a later deliberate choice is never touched
+// again, and settings.local.json / user settings (never edited by UKit) always win at runtime.
+export const SETTINGS_DEFAULTS_MIGRATION_ID = 'orchestrator-opus-medium-v1';
+const LEGACY_SHIPPED_SETTINGS = { model: 'sonnet', effortLevel: 'high' };
 const UKIT_OWNED_TOP_LEVEL_KEYS = new Set(['hooks']);
 const PERMISSION_LIST_KEYS = new Set(['allow', 'deny', 'ask', 'additionalDirectories']);
 const BLOCKED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
@@ -94,7 +103,22 @@ function unionList(templateList, userList) {
   return out;
 }
 
-function mergeSettingsObjects(existing, rendered) {
+// Keys whose old shipped default is still in place and should take the new template value.
+function legacyDefaultKeys(existing, rendered, migrate) {
+  if (!migrate) return [];
+  return Object.keys(LEGACY_SHIPPED_SETTINGS).filter((key) => (
+    existing[key] === LEGACY_SHIPPED_SETTINGS[key] && key in rendered && rendered[key] !== existing[key]
+  ));
+}
+
+export function settingsDefaultsMigrationKeys(existingContent, renderedContent) {
+  const existing = parseSettingsJson(existingContent);
+  const rendered = parseSettingsJson(renderedContent);
+  return existing && rendered ? legacyDefaultKeys(existing, rendered, true) : [];
+}
+
+function mergeSettingsObjects(existing, rendered, { migrateDefaults = false } = {}) {
+  const migrated = new Set(legacyDefaultKeys(existing, rendered, migrateDefaults));
   const merged = {};
   for (const key of Object.keys(rendered)) {
     if (BLOCKED_KEYS.has(key)) continue;
@@ -124,7 +148,7 @@ function mergeSettingsObjects(existing, rendered) {
       // user value has the wrong shape (e.g. permissions: "x") — template shape wins
       merged[key] = templateValue;
     } else {
-      merged[key] = userValue; // user-owned scalar/section (model, effortLevel, …)
+      merged[key] = migrated.has(key) ? templateValue : userValue; // user-owned scalar/section (model, effortLevel, …)
     }
   }
   return merged;
@@ -133,11 +157,11 @@ function mergeSettingsObjects(existing, rendered) {
 // Merge rendered settings.json with the user's existing file per the ownership model above.
 // Returns the merged JSON as a string, or the rendered content unchanged when either side is
 // unparseable (the caller still takes a timestamped backup before writing).
-export function mergeSettingsJson(existingContent, renderedContent) {
+export function mergeSettingsJson(existingContent, renderedContent, options = {}) {
   const existing = parseSettingsJson(existingContent);
   const rendered = parseSettingsJson(renderedContent);
   if (!existing || !rendered) return renderedContent;
-  return `${JSON.stringify(mergeSettingsObjects(existing, rendered), null, 2)}\n`;
+  return `${JSON.stringify(mergeSettingsObjects(existing, rendered, options), null, 2)}\n`;
 }
 
 function withoutGatewayEnv(settings) {
@@ -147,11 +171,11 @@ function withoutGatewayEnv(settings) {
   return { ...settings, env };
 }
 
-function settingsJsonIgnoresGatewayEnvDiff(existingContent, renderedContent) {
+function settingsJsonIgnoresGatewayEnvDiff(existingContent, renderedContent, options = {}) {
   const existing = parseSettingsJson(existingContent);
   const rendered = parseSettingsJson(renderedContent);
   if (!existing || !rendered) return false;
-  const merged = mergeSettingsObjects(existing, rendered);
+  const merged = mergeSettingsObjects(existing, rendered, options);
   return JSON.stringify(canonicalize(withoutGatewayEnv(merged)))
     === JSON.stringify(canonicalize(withoutGatewayEnv(existing)));
 }
@@ -208,7 +232,7 @@ function ukitInstalledText(mergedText, renderedText) {
   }
 }
 
-function resolveFileAction(entry, existingContent, ompOwnership = null) {
+function resolveFileAction(entry, existingContent, ompOwnership = null, settingsMigration = null) {
   const exists = existingContent !== null;
   const binaryEntry = Buffer.isBuffer(entry.renderedContent);
 
@@ -273,9 +297,11 @@ function resolveFileAction(entry, existingContent, ompOwnership = null) {
     // User-owned permission keys (permissions.defaultMode) are excluded from the drift
     // check AND merged back into the content that gets written, so install/update can
     // never flip the user's chosen permission mode.
-    const merged = mergeSettingsJson(existingContent, entry.renderedContent);
-    action = settingsJsonIgnoresGatewayEnvDiff(existingContent, entry.renderedContent) ? 'unchanged' : 'update';
-    return { ...entry, renderedContent: merged, exists, action, existingContent };
+    const mergeOptions = { migrateDefaults: settingsMigration?.pending === true };
+    const merged = mergeSettingsJson(existingContent, entry.renderedContent, mergeOptions);
+    action = settingsJsonIgnoresGatewayEnvDiff(existingContent, entry.renderedContent, mergeOptions) ? 'unchanged' : 'update';
+    const migratedKeys = mergeOptions.migrateDefaults ? settingsDefaultsMigrationKeys(existingContent, entry.renderedContent) : [];
+    return { ...entry, renderedContent: merged, exists, action, existingContent, ...(migratedKeys.length ? { settingsDefaultsMigrated: migratedKeys } : {}) };
   } else if (entry.id === 'runtime-config' && typeof existingContent === 'string' && typeof entry.renderedContent === 'string') {
     // U2: .ukit/storage/config.json is user-owned state seeded from the template — merge
     // by ownership instead of overwriting (see runtimeConfigMerge.js).
@@ -332,7 +358,7 @@ async function resolveSkipEntryAction(entry, ompOwnership = null) {
   return resolveFileAction(entry, read.content, ompOwnership);
 }
 
-export async function diffInstallPlan(plan, { ompOwnership = null } = {}) {
+export async function diffInstallPlan(plan, { ompOwnership = null, settingsMigration = null } = {}) {
   // Check all entries in parallel
   const results = await Promise.all(
     plan.entries.map(async (entry) => {
@@ -352,7 +378,7 @@ export async function diffInstallPlan(plan, { ompOwnership = null } = {}) {
       if (read.status === 'unreadable') {
         return conflictResult(entry, read.error);
       }
-      return resolveFileAction(entry, read.status === 'ok' ? read.content : null, ompOwnership);
+      return resolveFileAction(entry, read.status === 'ok' ? read.content : null, ompOwnership, settingsMigration);
     }),
   );
 

package/src/core/executionContracts.js

@@ -95,37 +95,39 @@ export const MODEL_TIER_BY_CONTRACT = {
 // no registry, no leases, no outbound capability calls.
 export const ROUTE_EFFORTS = new Set(['low', 'medium', 'high']);
 
-// Tier ladder for the one-band high-risk escalation; effort rides the resolved tier.
-const MODEL_TIER_ORDER = ['lite', 'code', 'smart'];
+// Tier, effort and risk are independent decisions. Effort is Medium for every tier (Low for chores);
+// High needs complexity evidence (`complexityEvidence` below), never risk or tier alone.
 const MODEL_TIER_EFFORT = {
   lite: 'low',
   code: 'medium',
-  smart: 'high',
+  smart: 'medium',
 };
 
 /**
- * Resolves {tier, effort, advisoryOnly} for a route. A 'high-risk' floor escalates
- * the tier one band (lite→code→smart, capped at smart) and forces effort 'high'.
- * Unknown mode → {tier:null, effort:null, advisoryOnly:true}. Missing/unknown
- * riskFloor → 'none'. Missing hostCapabilities → advisoryOnly:true (the route text
- * is all the host gets when it cannot bind model and effort).
+ * Resolves {tier, effort, advisoryOnly} for a route. A 'high-risk' floor lifts a Tier 1 chore to the
+ * Tier 2 executor (lite→code) and goes no further: smart is the orchestrator / acceptance tier and is
+ * reached only through its own contract (review-release) or failure evidence, never through risk, so
+ * risk cannot turn the orchestrator into the implementation worker. Risk raises verification rigor
+ * (the route's riskFloor / rigor), not the tier ceiling or the effort. Effort is 'high' only with
+ * `complexityEvidence`. Unknown mode → {tier:null, effort:null, advisoryOnly:true}. Missing/unknown
+ * riskFloor → 'none'. Missing hostCapabilities → advisoryOnly:true (the route text is all the host
+ * gets when it cannot bind model and effort).
  */
 export function resolveModelTier({
   executionMode = null,
   riskFloor = null,
   hostCapabilities = null,
+  complexityEvidence = false,
 } = {}) {
   const baseTier = MODEL_TIER_BY_CONTRACT[executionMode] ?? null;
   if (!baseTier) {
     return { tier: null, effort: null, advisoryOnly: true };
   }
   const highRisk = riskFloor?.floor === 'high-risk';
-  const tier = highRisk
-    ? MODEL_TIER_ORDER[Math.min(MODEL_TIER_ORDER.indexOf(baseTier) + 1, MODEL_TIER_ORDER.length - 1)]
-    : baseTier;
+  const tier = highRisk && baseTier === 'lite' ? 'code' : baseTier;
   return {
     tier,
-    effort: highRisk ? 'high' : MODEL_TIER_EFFORT[tier],
+    effort: complexityEvidence === true ? 'high' : MODEL_TIER_EFFORT[tier],
     advisoryOnly: !(hostCapabilities?.canBindModel === true && hostCapabilities?.canBindEffort === true),
   };
 }
@@ -204,12 +206,55 @@ function neutralizeNonOrders(text) {
     .replace(/"[^"\n]*\s[^"\n]*"|`[^`\n]*\s[^`\n]*`|\u201c[^\u201d\n]*\u201d/g, ' ')
     .replace(/\b(?:neu\s+(?:phai|can|thieu|khong du|bang chung chua du)|if\s+(?:needed|necessary|required|evidence is insufficient))\b[^.;\n]*/g, ' ')
     .replace(/[^.;\n]*\b(?:nao|gi|sao|the nao|bao nhieu)\b[^.;\n]*\?/g, ' ')
-    .replace(/\bchinh\s+xac\b|\b(?:phuong an|cach|de xuat|ban)\s+(?:sua|fix)\b/g, ' ')
+    .replace(/\bchinh\s+(?:xac|sach)\b|\b(?:phuong an|cach|de xuat|ban)\s+(?:sua|fix)\b|\b(?:diem|cho|muc|phan)\s+(?:phai|can|nen)\s+(?:sua|fix)\b/g, ' ')
     .replace(/\bwrite\s*\/\s*verification\b|\bverification\s*\/\s*write\b|\bwrite\s+(?:or|and)\s+verification\b/g, ' ')
     .replace(/\b(?:state|status)\s+changes?\b/g, ' ')
     .replace(/\b(?:proposed|suggested|recommended|minimal|each|the|an?|any|that|this|no|which|exact|smallest|possible)\s+fix(?:es)?\b/g, ' ');
 }
 
+// Explicit scope declaration (intent ownership): when the request itself declares it is read-only
+// ("READ-ONLY audit", "chi doc", "make no source changes") and carries no explicit order to change
+// anything, verbs and operation names inside it are descriptions (a "git stash" that already ran, "a
+// worklog edit", "confirmed fixes"), not orders - so they must not demand write or operation proof.
+// An explicit order (imperative-initial or modal request) keeps the request MIXED/IMPLEMENTATION:
+// the declaration never overrides a real instruction, and fenced/quoted/blockquoted text is never one.
+// A bare verb with no object is the tail of a negated list ("no commit, release, publish"), not an order.
+const READ_ONLY_DECLARATION = /\bread[\s-]*only\s+(?:audit|investigation|review|analysis|inspection|task|request|session|pass|check|diagnos\w+|verification|forensics?)\b|(?:^|\n)[\s*#>_-]*read[\s-]*only\s*[.:!—-]|\b(?:audit|investigation|review|analysis)[\s-]*only\b|[(,]\s*read[\s-]*only\s*[).]|\bchi\s+(?:doc|audit|kiem tra|phan tich|dieu tra)\b|\b(?:make|with)\s+no\s+(?:source\s+|code\s+|file\s+)?(?:changes|edits|modifications)\b/;
+const ORDER_VERBS = 'implement|fix|apply|refactor|modify|edit|write|update|add|create|build|install|deploy|redeploy|restart|push|commit|rename|remove|delete|replace|change|sua|viet|chinh|them|tao|xoa|enable|disable|set|toggle|configure|migrate|upgrade|publish|release|trien khai|khoi dong lai|(?:run|execute)\\s+(?:git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)|(?:npm|yarn)\\s+publish)|git\\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)';
+const IMPERATIVE_ORDER = new RegExp(`^(?:[-*+\\u2022>\\d.)\\s]*)(?:(?:please|hay|vui long|now|also|first|then)\\s+)*(?:${ORDER_VERBS})\\b\\s+\\S`);
+const MODAL_ORDER = new RegExp(`\\b(?:please|hay|vui long|need to|needs to|must|should|want(?:\\s+you)? to|toi muon|can phai|yeu cau)\\s+(?:[\\w-]+\\s+){0,2}(?:${ORDER_VERBS})\\b`);
+function hasExplicitOrder(clauses) {
+  return clauses.some((clause) => IMPERATIVE_ORDER.test(clause) || MODAL_ORDER.test(clause));
+}
+function declaredReadOnly(promptText, releasePolicy) {
+  if (releasePolicy) return false;
+  const plain = String(promptText).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  if (!READ_ONLY_DECLARATION.test(plain)) return false;
+  const text = neutralizeNonOrders(plain);
+  const clauses = text.split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/)
+    .map((clause) => clause.split(/\bwithout\b/)[0])
+    .filter((clause) => !/\b(?:do not|don't|never|khong|dung)\b/.test(clause));
+  return /\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|investigation|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text)
+    && !hasExplicitOrder(clauses);
+}
+
+// Verification-only request. Root cause of a false `write-evidence` block on a "verify / re-run /
+// confirm" prompt: the vocabulary scans counted nouns and compounds ("coordinator fix", "re-run",
+// "template/install", "source change") as mutation orders. Order is structural: a request whose
+// command-position verbs are verification verbs, with no explicit order (hasExplicitOrder) and no
+// change-leading clause, orders no change - it owes verification evidence, not a write.
+const VERIFY_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:verify|re-?run|confirm|validate|double-?check)\b/;
+const CHANGE_LEAD = /^(?:[-*+•>\d.)\s]*)(?:(?:please|hay|vui long|now|also|first|then)\s+)*(?:make|rebuild|redo|rewrite|restore|revert|correct|clean|patch|resolve|ensure|run(?!(?=[^.]*\b(?:tests?|suite|gate|checks?|lint|typecheck|pilot|smoke|e2e|verif\w*|vitest|jest|audit)\b)))\b/;
+export function isVerificationOnlyRequest(promptText) {
+  const plain = String(promptText ?? '').normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase()
+    .replace(/```[\s\S]*?```/g, ' ').replace(/^[ \t]*>.*$/gm, ' ');
+  const clauses = neutralizeNonOrders(plain).split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/)
+    .map((clause) => clause.split(/\bwithout\b/)[0]);
+  return clauses.some((clause) => VERIFY_LEAD.test(clause)) && !hasExplicitOrder(clauses)
+    && !clauses.some((clause) => CHANGE_LEAD.test(clause));
+}
+
 export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
   // A named preflight and both explicit branches are required; a failed arbitrary test is not a release policy.
   const releaseText = String(promptText).normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[đĐ]/g, 'd').toLowerCase();
@@ -221,6 +266,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   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));
+  if (declaredReadOnly(promptText, releasePolicy)) return { taskKind: 'READ_ONLY' };
   const sourceOrder = actionable.some((clause) => /\b(?:implement|fix(?:es)?|apply|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 codeChangeVerb = actionable.some((clause) => /\b(?:implement|fix(?:es)?|apply|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause));
@@ -238,10 +284,15 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   // runtime are separate domains with separate proof; a prompt naming both stays a coding
   // task rather than being half-verified. A code-change verb anywhere keeps write evidence.
   const gitOperation = actionable.some((clause) => /\bgit\s+(?:push|clean|commit|reset|rebase|merge|tag|stash|checkout|restore|cherry-pick)\b|\bpush\s+(?:to\s+)?origin\b/.test(clause));
-  const runtimeOperation = actionable.some((clause) => /\b(?:restart|redeploy|deploy|khoi dong lai|trien khai)\b/.test(clause)
+  // 'trien khai' is Vietnamese for both "deploy" and "implement": it orders a runtime operation only
+  // when it names a runtime target; bare it describes work ("Tier 3 truc tiep trien khai thay Tier 2").
+  // "restart"/"deploy" after a noun modifier ("process restart", "after redeploy") is a scenario, not an order.
+  const runtimeOperation = actionable.some((clause) => /(?<!\b(?:process|crash|hard|soft|graceful|after|upon|during|across|following)\s)\b(?:restart|redeploy|deploy|khoi dong lai|trien khai\s+(?:len\s+)?(?:service|server|production|prod|staging|dich vu|may chu|moi truong))\b/.test(clause)
     && !/\.[cm]?[jt]sx?\b/.test(clause) && !/\bgit\b/.test(clause));
   const nativeDomain = cronOperation ? 'scheduled-job' : gitOperation !== runtimeOperation ? (gitOperation ? 'git-integrity' : 'service-runtime') : null;
   const operation = Boolean(nativeDomain);
+  // A verification-only request orders no change; a concrete operation order (cancel/restart/push) stays operational.
+  if (!releasePolicy && !operation && isVerificationOnlyRequest(promptText)) return { taskKind: 'READ_ONLY', verificationOnly: true };
   // A config MENTION is not a config change: the same clause needs a mutation verb, and a
   // request that also changes source/code is a coding task (config is part of its tests/fixtures).
   const config = !sourceOrder && actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh)\b/.test(clause)
@@ -252,7 +303,7 @@ export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {})
   const mutationWord = /\b(?:implement|fix|refactor|modify|edit|write|update|add|create|build|make|install|deploy|remove|delete|rename|replace|change|sua|viet|chinh|them|tao|xoa|doi|cai|cap nhat)\b/.test(text);
   const statusReport = !mutationWord && !operation && !config
     && /\b(?:check|status|report|show|summari[sz]e|result|results|kiem tra|bao cao|trang thai|ket qua|da len chua)\b/.test(text);
-  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|debug|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text) || statusReport)
+  const readOnly = (/\b(?:audit|inspect|review|analyze|analyse|explain|read|investigate|debug|forensic|root cause|kiem tra|phan tich|dieu tra|doc log|tim hieu)\b/.test(text.replace(/\bread[\s-]*only\b/g, ' ')) || statusReport)
     && !sourceOrder && !codeChangeVerb && !operation && !config;
   const taskKind = operation ? (sourceOrder || (nativeDomain !== 'scheduled-job' && codeChangeVerb) ? 'MIXED' : 'OPERATIONAL')
     : config ? 'CONFIGURATION' : documentation ? 'DOCUMENTATION_OUTPUT' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
@@ -271,5 +322,5 @@ export function applyTaskSemantics(contract, semantic) {
     completionEvidence: semantic.taskKind === 'DOCUMENTATION_OUTPUT' ? ['report-artifact'] : operationOnly ? ['operation-verification']
       : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
         : semantic.taskKind === 'READ_ONLY' && semantic.statusReport ? []
-        : semantic.taskKind === 'READ_ONLY' ? (evidence.length === 1 && evidence[0] === 'verification-evidence' ? evidence : ['impact-evidence']) : evidence };
+        : semantic.taskKind === 'READ_ONLY' ? (semantic.verificationOnly || (evidence.length === 1 && evidence[0] === 'verification-evidence') ? ['verification-evidence'] : ['impact-evidence']) : evidence };
 }

package/src/core/metadata.js

@@ -69,6 +69,7 @@ export async function writeInstallMetadata({
   managedRelativePaths = null,
   retainedManagedRelativePaths = [],
   ompConfigOwnership = null,
+  settingsDefaultsMigration = null,
   lockStaleMs,
   lockMaxWaitMs,
 }) {
@@ -138,6 +139,9 @@ export async function writeInstallMetadata({
     // before) — lets uninstall revert only UKit's changes. Kept across runs.
     const ownership = ompConfigOwnership ?? (previousData?.tool === 'ukit' ? previousData.ompConfigOwnership : null);
     if (ownership) metadata.ompConfigOwnership = ownership;
+    // One-time .claude/settings.json defaults migration marker (see diffPlan.js). Kept across runs.
+    const migrationMarker = settingsDefaultsMigration ?? (previousData?.tool === 'ukit' ? previousData.settingsDefaultsMigration : null);
+    if (migrationMarker) metadata.settingsDefaultsMigration = migrationMarker;
 
     await ensureDir(path.dirname(installMetaPath));
     await writeJson(installMetaPath, metadata);

package/src/core/runInstallPipeline.js

@@ -7,7 +7,7 @@ import { detectProjectContext } from '../context/detectProjectContext.js';
 import { detectProviders } from '../context/detectProviders.js';
 import { buildTemplateVariables } from '../render/buildVariables.js';
 import { buildInstallPlan } from './buildPlan.js';
-import { diffInstallPlan } from './diffPlan.js';
+import { diffInstallPlan, SETTINGS_DEFAULTS_MIGRATION_ID } from './diffPlan.js';
 import { applyDiffResults, pruneOldBackups } from './applyPlan.js';
 import { summarizeDiff, toDiffRows } from './report.js';
 import { writeInstallMetadata, writeCliLocator, readInstallMetadata } from './metadata.js';
@@ -439,7 +439,10 @@ export async function runInstallPipeline({
     .some((e) => (typeof e === 'string' ? e : e?.p) === '.omp/config.yml');
   const ompOwnership = installMetaData?.ompConfigOwnership
     ?? (trackedOmpConfig ? { originalText: null, installedText: 'compaction:\n  thresholdTokens: 350000\n' } : null);
-  const diffResults = await diffInstallPlan(plan, { ompOwnership });
+  const trackedSettings = (Array.isArray(installMetaData?.files) ? installMetaData.files : [])
+    .some((e) => (typeof e === 'string' ? e : e?.p) === '.claude/settings.json');
+  const settingsMigration = { pending: trackedSettings && !installMetaData?.settingsDefaultsMigration };
+  const diffResults = await diffInstallPlan(plan, { ompOwnership, settingsMigration });
   const plannedSummary = summarizeDiff(diffResults);
 
   if (!dryRun) {
@@ -464,6 +467,19 @@ export async function runInstallPipeline({
       }
     }
 
+    // One-time settings.json defaults migration: report it explicitly (never silent) and mark it
+    // done once the settings entry was processed, so later user edits are never migrated again.
+    let settingsDefaultsMigration = null;
+    for (const entry of diffResults) {
+      if (!/(^|[\\/])\.claude[\\/]settings\.json$/.test(String(entry.targetPath))) continue;
+      if (!['create', 'update', 'unchanged'].includes(entry.action)) continue;
+      if (entry.action !== 'unchanged' && !writes.some((w) => w.targetPath === entry.targetPath)) continue;
+      settingsDefaultsMigration = SETTINGS_DEFAULTS_MIGRATION_ID;
+      if (entry.settingsDefaultsMigrated?.length) {
+        console.log(`[UKit] .claude/settings.json: migrated old default ${entry.settingsDefaultsMigrated.join(' + ')} to model "opus" (main orchestrator) / effortLevel "medium"; previous file backed up. To pin your own, set it in .claude/settings.local.json (UKit never edits it).`);
+      }
+    }
+
     // SPEC §7 step 9: surface the .omp/config.yml unattended migration result.
     for (const entry of diffResults) {
       const report = entry?.migrationReport;
@@ -546,6 +562,7 @@ export async function runInstallPipeline({
       managedRelativePaths: [...trackedManagedRelativePaths],
       retainedManagedRelativePaths,
       ompConfigOwnership,
+      settingsDefaultsMigration,
     });
 
     // 3.3.0: hooks spawn the CLI (episodes, self-improve) from a GUI-launched

package/src/core/runtimeConfig.js

@@ -442,7 +442,7 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
     },
     orchestration: {
       enabled: true,
-      orchestratorModel: 'claude-sonnet-5',
+      orchestratorModel: 'claude-opus-5',
       permissionMode: 'unattended',
       // FR-003: eval-subprocess gate for rendered omp approval (tools.approval.eval).
       // Fail-closed: only an explicit user `true` renders `eval: allow`; absent,

package/src/index/playbookRegistry.js

@@ -114,6 +114,20 @@ function hasSqlIntent(text) {
 // The SQL ask touches shape/data rather than a read-only query — routes the
 // migration row instead of a feature build.
 const SQL_SCHEMA_RE = /(?<![A-Za-z0-9_])(?:ddl|alter|drop|(?:create|alter|drop|truncate)\s+table|(?:add|drop|rename|change|modify|update|thêm|xóa|xoá|sửa|sua|đổi|doi)\s+(?:a\s+|the\s+|new\s+|một\s+)*(?:column|cột|cot)(?!\s+of\b)|kiểu\s+dữ\s+liệu|kieu\s+du\s+lieu|data\s?type|not\s+null|constraint|migration|migrate)(?![A-Za-z0-9_])/i;
+// Explicit delegation order: the user themself asks for a worker/subagent to implement
+// ("Delegate the implementation to a worker agent", "have a subagent implement it"). That is an
+// opt-in to the orchestrated path (Tier 3 orchestrates, Tier 2 implements, integration verified by
+// the orchestrator), so it lifts the small-feature fast path into feature-implementation. Live omp
+// run: this exact order stayed on small-feature (explicit-local-target fast path, subagents
+// suppressed) and the Tier 3 main implemented nothing of the delegation. Bare mentions of the
+// words ("worker thread", "the delegate pattern") do not match; negated orders ("don't delegate")
+// veto.
+const DELEGATION_ORDER_RE = /\bdelegat(?:e|ing)\b[^.\n]{0,80}?\bto\s+(?:an?\s+|the\s+|your\s+)?(?:[\w-]+\s+){0,2}?(?:worker|sub-?agents?|agents?|implementer)\b|\b(?:use|spawn|dispatch|launch|assign|have|let)\s+(?:an?\s+|the\s+|your\s+)?(?:[\w-]+\s+)?(?:worker|sub-?agents?|implementer)(?:\s+agent)?\s+(?:to|for)\b|(?<![A-Za-z0-9_])giao\s+(?:việc\s+)?cho\s+(?:worker|sub-?agent|agent)/i;
+const DELEGATION_NEGATED_RE = /\b(?:don['’]?t|do\s+not|never|without|avoid|no\s+need\s+to)\s+(?:[\w-]+\s+){0,2}?(?:delegat\w*|(?:use|spawn|dispatch)\s+(?:an?\s+|any\s+)?(?:worker|sub-?agents?))|\bno\s+(?:worker|sub-?agents?|delegation)\b|\b(?:inline|yourself)\s+(?:only|not)\b/i;
+export function hasDelegationOrder(text) {
+  const t = String(text ?? '');
+  return DELEGATION_ORDER_RE.test(t) && !DELEGATION_NEGATED_RE.test(t);
+}
 // Reuse-first ask: "use the existing/core function", "dùng hàm có sẵn",
 // "tái sử dụng" — search for the function before writing a new one.
 const REUSE_FIRST_RE = /(?:\buse\s+(?:the\s+)?(?:existing|core|shared|same|current)\b)|(?:\buse\s+[\w.]+\s+from\s+(?:the\s+)?(?:core|shared|utils?|common|lib)\b)|\b(?:existing|core|shared)\s+(?:function|helper|util(?:ity|ities)?|service|component)\b|\breuse\b|(?<![A-Za-z0-9_])(?:tái\s+sử\s+dụng|tai\s+su\s+dung)|(?<![A-Za-z0-9_])(?:dùng|dung|dựa|dua)\s+(?:vào\s+|vao\s+)?(?:hàm|ham)(?:\s+(?:có\s+sẵn|co\s+san|sẵn\s+có|san\s+co|đã\s+có|da\s+co|cũ|cu))?(?![A-Za-z0-9_])/i;
@@ -174,7 +188,7 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     // contract signals) escalates to feature-implementation. Reference-driven,
     // clone, reuse-first and SQL-schema asks take the same escape: they name a
     // source of truth or a data contract the small path must not gloss over.
-    discriminator: (s) => !s.escalated && !s.contractSignal && !s.multiSurface && !s.sqlSchemaChange && !s.referenceTarget && !s.cloneIntent && !s.reuseFirst && s.changeVerbOrCreate,
+    discriminator: (s) => !s.escalated && !s.contractSignal && !s.multiSurface && !s.sqlSchemaChange && !s.referenceTarget && !s.cloneIntent && !s.reuseFirst && !s.delegationOrdered && s.changeVerbOrCreate,
     fastPath: 'small-feature',
   },
   {
@@ -195,7 +209,7 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     // migration row instead of capturing the build lane.
     discriminator: (s) => (
       (s.contractSignal || s.multiSurface || (s.escalated && !s.sqlSchemaChange) || s.wiredShipAsk)
-      || ((s.referenceTarget || s.cloneIntent || s.reuseFirst) && s.defectIdx === -1)
+      || ((s.referenceTarget || s.cloneIntent || s.reuseFirst || s.delegationOrdered) && s.defectIdx === -1)
     ) && !s.disposable && !s.releaseAsk,
   },
   {
@@ -291,7 +305,9 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     lanes: ['local-fix', 'review-release'],
     triggers: [/\bverify\b|\bcheck\b|\bconfirm\b|\bprove\b|\bvalidate\b|\bassert\b/i],
     // the ask IS a check — a check verb leads, or no defect verb exists at all.
-    discriminator: (s) => s.checkFirst || s.defectIdx === -1,
+    // A build/create verb that leads the ask makes the check its closing step ("implement X … then run the
+    // tests and confirm"), not the ask itself — the build row owns it instead of tying into ambiguity.
+    discriminator: (s) => (s.checkFirst || s.defectIdx === -1) && !s.buildLeadsCheck,
   },
   {
     workGroup: 'skill-evaluation',
@@ -409,6 +425,7 @@ async function buildRouteSignals({
   const explanationAsk = explainIdx !== -1 && (firstVerbIdx === -1 || explainIdx < firstVerbIdx);
   const changeRequested = !consultLead && firstVerbIdx !== -1 && (explainIdx === -1 || firstVerbIdx < explainIdx);
   const checkFirst = checkIdx !== -1 && (defectIdx === -1 || checkIdx < defectIdx);
+  const buildLeadsCheck = changeRequested && checkIdx !== -1 && firstVerbIdx !== -1 && firstVerbIdx < checkIdx;
   // C85-019: a QUESTION about a defect is not a defect order. The bug-fix floor
   // demands repro+root-cause receipts — demanding them on a "did it get fixed
   // yet?" turn forces edits nobody asked for (user-reported lock). Question
@@ -440,12 +457,14 @@ async function buildRouteSignals({
     changeRequested,
     questionAsk,
     checkFirst,
+    buildLeadsCheck,
     changeVerbOrCreate: changeIdx !== -1 || createIdx !== -1,
     referenceTarget,
     cloneIntent,
     sqlIntent,
     sqlSchemaChange: sqlIntent && SQL_SCHEMA_RE.test(signalText),
     reuseFirst,
+    delegationOrdered: hasDelegationOrder(signalText) && changeRequested,
     contractSignal: CONTRACT_SIGNAL_RE.test(signalText) || /\boauth\b/i.test(signalText),
     multiSurface: MULTI_SURFACE_RE.test(signalText),
     escalated: Array.isArray(escalationTriggers) && escalationTriggers.length > 0,

package/src/index/taskRouting.js

@@ -895,7 +895,7 @@ function deriveExecutionScores({
   const buildSignal = /\b(build|create|add|implement|feature)\b/.test(raw);
   const debugSignal = intentMode === 'debug-specific' || /\b(root cause|debug|triage|flaky|investigate|why)\b/.test(raw);
   const reviewSignal = intentMode === 'review-specific' || /\b(review|audit|verify|release readiness)\b/.test(raw);
-  const failureSignal = /\b(failing|failed|broken|error|crash|timeout|undefined|exception|eacces|trace)\b/.test(raw);
+  const failureSignal = /\b(failing|failed|broken|error|crash|timeout|undefined|exception|eacces|trace)\b/.test(raw.replace(/\b(?:throw|raise|emit|reject|return|log|show|surface)(?:s|es|ing)?\s+(?:an?\s+|the\s+)?(?:[a-z-]+\s+){0,2}[a-z]*(?:error|exception)s?\b/g, ' '));
   const impactSignal = /\b(map impact|impact|blast radius|all affected|across (?:runtime|templates|helpers|adapters|mirrors)|affected adapters|affected mirrors|inspect impact)\b/.test(raw);
   const boundedEditSignal = /\b(one[- ]line|small|tiny|single|local|guard|log line|loading message|label)\b/.test(raw);
   const implementSignal = /\b(implement|apply|update|modify|add|create|ship|deliver|fix)\b/.test(raw)
@@ -1813,7 +1813,7 @@ function deriveIntentMode({ promptText = '', commandText = '', targetFile = null
   }
 
   if (concreteTask) {
-    if (/\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|timeout)\b/.test(lower)) {
+    if (/\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|timeout)\b/.test(lower.replace(/\b(?:throw|raise|emit|reject|return|log|show|surface)(?:s|es|ing)?\s+(?:an?\s+|the\s+)?(?:[a-z-]+\s+){0,2}[a-z]*(?:error|exception)s?\b/g, ' '))) {
       return 'debug-specific';
     }
     if (/\b(review|audit|diff|pr feedback|code review|kiem tra|soat)\b/.test(raw)) {