@ngockhoale/ukit 1.1.7 → 1.2.1

package/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to UKit are documented here.
 
 ## Unreleased
 
+## 1.2.1 - 2026-05-05
+
+### Local AI Task Queue
+
+- Added gitignored `docs/TASKS.md` as a local AI task queue for deferred work that one AI can write and another AI/agent can implement later.
+- Installed `docs/TASKS.md` with skip merge semantics so end-user task notes are never overwritten or uninstall-owned.
+- Added safe default cleanup rules: remove exact duplicates, prune `Done Recently` to 10 compact lines, move stale/vague work to deferred review, and never delete unfinished human-authored tasks unless explicitly asked and clearly obsolete/duplicated.
+- Updated `next-step`, `update-status`, and `docs-quality` guidance plus route signals so queued-task selection goes to `next-step` while task cleanup/editing goes to `docs-quality`.
+- Added `docs/STATUS.md` and `docs/TASKS.md` to generated gitignore handling so living local AI state does not pollute project commits.
+- Added the internal `ukit-small-task-maintainer` subagent, powered by optional `UKIT_SMALL_TASK_MODEL=unic-lite`, for safe UKit decisions such as task cleanup, compact decisions, doc summarization, classification, auto-triage, queue maintenance, and small reversible cleanup while keeping risky/security/release work on the main model.
+
+## 1.1.8 - 2026-05-05
+
+### Living Project Status
+
+- Added `docs/STATUS.md` as a compact living project-state baseline for active work, debug threads, blockers, verification, and next candidates.
+- Added `next-step` and `update-status` skills so Claude/Codex/OpenCode can use project status automatically without adding any user-facing commands beyond `ukit install`.
+- Made next-step routing freshness-aware: stale or missing status must be treated as orientation only and verified against source/index before recommendations.
+- Added concrete-task precedence so prompts like “fix login bug but not sure next step” stay on the debug/implementation/review workflow instead of being hijacked by global roadmap suggestions.
+- Registered status docs/skills in the manifest with skip semantics for the living doc, and kept source route catalogs aligned with installed helper mirrors.
+- Updated install/routing/manifest regression coverage for open-ended status prompts, explicit handoff updates, concrete debug edge cases, and default skill installation.
+
 ## 1.1.7 - 2026-04-25
 
 ### Impact Confidence

package/README.md

@@ -32,6 +32,8 @@ ukit install
 4. Fill in the generated docs baseline:
    - `docs/PROJECT.md`
    - `docs/MEMORY.md`
+   - `docs/STATUS.md`
+   - `docs/TASKS.md`
    - `docs/WORKLOG.md`
 5. Open your AI tool and work in natural language.
 
@@ -64,13 +66,13 @@ If maintainers roll out a newer CLI build, the in-project workflow still stays t
 **Project support files**
 - `.claude/ukit/.ukit/` — installer manifests, metadata, backups
 - `.ukit/` — hidden shared runtime storage for config, cache, and cross-agent memory
-- `docs/` — PROJECT / MEMORY / WORKLOG baseline
+- `docs/` — PROJECT / MEMORY / STATUS / TASKS / WORKLOG baseline
 
-## UKit v1.1.7 Runtime
+## UKit v1.2.1 Runtime
 
 UKit now installs a hidden shared local runtime at `.ukit/` for production-oriented state that should survive across agent sessions:
 
-- `.ukit/storage/config.json` — runtime defaults for compact/router/memory/validation
+- `.ukit/storage/config.json` — runtime defaults for compact/router/memory/validation/subagent hints
 - `.ukit/storage/cache/` — reusable prompt-cache, compact history, compact-pressure state, and output summaries
 - `.ukit/storage/memory/` — cross-agent local memory
 
@@ -83,15 +85,18 @@ When long sessions approach the compact threshold, UKit now uses a conservative
 - compact only safe-zone history/noise
 - preserve active task, rules, decisions, and current code focus
 
-UKit v1.1.7 keeps the same shared runtime contract while adding impact-confidence routing for shared runtime/template changes:
+UKit v1.2.1 keeps the same shared runtime contract while adding a local AI task queue alongside living project status routing:
 
 - install globally with `npm install -g @ngockhoale/ukit`
 - keep using the exact same human workflow inside projects: `ukit install`
 - preserve the same `ukit` binary, hooks, and install-first orchestration while standardizing the runtime root as hidden `.ukit/`
-- route shared index/helper/hook/template edits as higher-impact work instead of treating them like ordinary simple changes
-- surface mirror-counterpart and impact-test hints so agents verify source/runtime/template changes with better confidence
+- install `docs/STATUS.md` as a compact living state file for active work, debug threads, blockers, verification, and next candidates
+- install gitignored `docs/TASKS.md` as a local AI task queue for deferred/ready work, with safe AI cleanup rules that remove duplicates and prune completed history without deleting unfinished human intent
+- auto-route open-ended “what next?” / “continue” prompts to the `next-step` skill with a visible freshness cue when status may be stale
+- auto-route explicit handoff/wrap-up requests to the `update-status` skill while skipping trivial/no-state-change tasks
+- keep concrete debug/implementation/review prompts primary, so project status never replaces source/index-first task work
 
-UKit v1.1.7 also keeps the fast path improvements from the recent runtime releases:
+UKit v1.2.1 also keeps the fast path improvements from the recent runtime releases:
 
 - Vietnamese prompts now normalize more effectively for English-heavy code symbols and paths
 - localized simple direct-target lanes skip extra previous-context / recent-output work when it would not change the next action
@@ -126,6 +131,8 @@ UKit is built so the team can stop memorizing UKit subcommands and focus on prod
 - let Claude Code / Codex / OpenCode auto-detect and use the right project-local skill from the prompt and the files/tools involved
 - let the AI prefer targeted verification first, then widen only when shared/risky scope justifies it
 - let the AI selectively auto-delegate internal subagents only when that actually reduces context/noise or unlocks parallel progress; small localized work should stay direct
+- keep long sessions compact across agents: Claude keeps PreCompact/reinject, OpenCode keeps native auto/prune compaction, and Codex Desktop uses internal `UKIT_CODEX_COMPACT_TARGET` soft handoffs (default 150 lines; 120-150 preferred, hard max 170), without asking end users to manage context manually
+- let UKit internally use the `ukit-small-task-maintainer` subagent with `UKIT_SMALL_TASK_MODEL=unic-lite` for safe task cleanup, fast-vs-slow/safe-vs-risky lane hints, skill-routing/step-budget hints, agent context-budget decisions, compact decisions, doc summarization, classification, and queue maintenance while risky/security/release/quality-risk work stays on the main model
 - rerun `ukit install` when you need to refresh the workspace
 
 End users should **not** need to know or memorize skill names.

package/manifests/platform.full.yaml

@@ -77,6 +77,18 @@ items:
     packs:
       - core
 
+  - id: ukit-env-example
+    type: config
+    sourceTemplate: .claude/ukit/.env.example
+    targetPath: .claude/ukit/.env.example
+    requires:
+      - runtime-config
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: root-claude-md
     type: config
     sourceTemplate: CLAUDE.md
@@ -143,6 +155,35 @@ items:
     packs:
       - core
 
+  - id: docs-status
+    type: config
+    sourceTemplate: docs/STATUS.md
+    targetPath: docs/STATUS.md
+    requires:
+      - docs-project
+      - docs-memory
+      - docs-worklog
+      - docs-code-map
+    mergeStrategy: skip
+    variables:
+      - project.name
+    enabledByDefault: true
+    packs:
+      - core
+
+  - id: docs-tasks
+    type: config
+    sourceTemplate: docs/TASKS.md
+    targetPath: docs/TASKS.md
+    requires:
+      - docs-status
+    mergeStrategy: skip
+    variables:
+      - project.name
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: docs-bugfix
     type: config
     sourceTemplate: docs/BUGFIX.md
@@ -460,6 +501,34 @@ items:
     packs:
       - core
 
+  - id: next-step-skill
+    type: skill
+    sourceTemplate: .claude/skills/next-step/SKILL.md
+    targetPath: .claude/skills/next-step/SKILL.md
+    requires:
+      - docs-quality-skill
+      - docs-status
+      - docs-tasks
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
+  - id: update-status-skill
+    type: skill
+    sourceTemplate: .claude/skills/update-status/SKILL.md
+    targetPath: .claude/skills/update-status/SKILL.md
+    requires:
+      - docs-quality-skill
+      - docs-status
+      - docs-tasks
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: docs-manager-skill
     type: skill
     sourceTemplate: .claude/skills/docs-manager
@@ -750,6 +819,19 @@ items:
     packs:
       - core
 
+  - id: agent-ukit-small-task-maintainer
+    type: agent
+    sourceTemplate: .claude/agents/ukit-small-task-maintainer.md
+    targetPath: .claude/agents/ukit-small-task-maintainer.md
+    requires:
+      - ukit-env-example
+    mergeStrategy: overwrite_with_backup
+    variables:
+      - ukit.version
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: provider-compat-config
     type: config
     sourceTemplate: .claude/config/providers.md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "1.1.7",
+  "version": "1.2.1",
   "description": "Install/update an index-first AI workspace for Claude Code, Antigravity, OpenAI Codex, and OpenCode.",
   "license": "MIT",
   "type": "module",

package/src/cli/commands/doctor.js

@@ -62,6 +62,8 @@ export async function runDoctor({ packageRoot, projectRoot, argv = [] }) {
     sessionMemoryDirExists: await pathExists(runtimePaths.sessionsDir),
     docsProjectExists: await pathExists(path.join(projectRoot, 'docs', 'PROJECT.md')),
     docsMemoryExists: await pathExists(path.join(projectRoot, 'docs', 'MEMORY.md')),
+    docsStatusExists: await pathExists(path.join(projectRoot, 'docs', 'STATUS.md')),
+    docsTasksExists: await pathExists(path.join(projectRoot, 'docs', 'TASKS.md')),
     docsWorklogExists: await pathExists(path.join(projectRoot, 'docs', 'WORKLOG.md')),
     allProvidersConfigured: providers.allSupported,
     ...(codexAdapterTracked
@@ -103,6 +105,8 @@ export async function runDoctor({ packageRoot, projectRoot, argv = [] }) {
   console.log(`[UKit]   ${ok(checks.sessionMemoryDirExists)}  .ukit/storage/memory/sessions/`);
   console.log(`[UKit]   ${ok(checks.docsProjectExists)}  docs/PROJECT.md`);
   console.log(`[UKit]   ${ok(checks.docsMemoryExists)}  docs/MEMORY.md`);
+  console.log(`[UKit]   ${ok(checks.docsStatusExists)}  docs/STATUS.md`);
+  console.log(`[UKit]   ${ok(checks.docsTasksExists)}  docs/TASKS.md`);
   console.log(`[UKit]   ${ok(checks.docsWorklogExists)}  docs/WORKLOG.md`);
   if (codexAdapterTracked) {
     console.log(`[UKit]   ${ok(checks.codexReadmeExists)}  .codex/README.md`);

package/src/cli/commands/install.js

@@ -241,12 +241,14 @@ export async function runInstall({ packageRoot, projectRoot, packageVersion, arg
     .join(', ');
   console.log(`[UKit] Providers: ${providerStatus}, all=${result.providerContext.allSupported}`);
 
-  const docsPaths = [
-    path.join(projectRoot, 'docs', 'PROJECT.md'),
-    path.join(projectRoot, 'docs', 'MEMORY.md'),
-    path.join(projectRoot, 'docs', 'WORKLOG.md'),
+  const docsLabels = [
+    'docs/PROJECT.md',
+    'docs/MEMORY.md',
+    'docs/STATUS.md',
+    'docs/TASKS.md',
+    'docs/WORKLOG.md',
   ];
-  const docsLabels = ['docs/PROJECT.md', 'docs/MEMORY.md', 'docs/WORKLOG.md'];
+  const docsPaths = docsLabels.map((label) => path.join(projectRoot, ...label.split('/')));
   const missingDocs = [];
   for (let i = 0; i < docsPaths.length; i++) {
     if (!(await pathExists(docsPaths[i]))) {
@@ -257,7 +259,7 @@ export async function runInstall({ packageRoot, projectRoot, packageVersion, arg
   if (missingDocs.length > 0) {
     console.log(`[UKit] Missing docs — fill these in before first use: ${missingDocs.join(', ')}`);
   } else {
-    console.log('[UKit] Docs baseline ready: docs/PROJECT.md, docs/MEMORY.md, docs/WORKLOG.md');
+    console.log('[UKit] Docs baseline ready: docs/PROJECT.md, docs/MEMORY.md, docs/STATUS.md, docs/TASKS.md, docs/WORKLOG.md');
     console.log('[UKit] Fill them once with real project context for the best results.');
   }
 

package/src/cli/commands/uninstall.js

@@ -47,5 +47,5 @@ export async function runUninstall({ projectRoot, argv = [] }) {
   }
 
   console.log(`[UKit] Uninstall complete. Removed ${result.removed}/${result.attempted} managed paths.`);
-  console.log('[UKit] Note: docs/PROJECT.md, docs/MEMORY.md, docs/WORKLOG.md contain user content and were preserved. Delete manually if needed.');
+  console.log('[UKit] Note: docs/PROJECT.md, docs/MEMORY.md, docs/STATUS.md, docs/TASKS.md, docs/WORKLOG.md contain user content and were preserved. Delete manually if needed.');
 }

package/src/core/ensureGitignore.js

@@ -11,6 +11,8 @@ const UKIT_ENTRIES = [
   'opencode.json',
   'AGENTS.md',
   'CLAUDE.md',
+  'docs/STATUS.md',
+  'docs/TASKS.md',
   '.claude/ukit/.ukit/',
   '.claude/ukit/permission-usage.json',
   '.claude/ukit/permission-audit.log',

package/src/core/runtimeConfig.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import { buildRuntimePaths } from './runtimePaths.js';
 
 const VALID_AGENTS = new Set(['claude-code', 'codex', 'antigravity', 'opencode']);
@@ -38,17 +39,155 @@ function pushPositiveNumberError(errors, value, label) {
   }
 }
 
+function pushNonEmptyStringError(errors, value, label) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    errors.push(`${label} must be a non-empty string.`);
+  }
+}
+
+function parseRuntimeEnv(content = '') {
+  const result = {};
+  for (const rawLine of String(content || '').split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || !line.includes('=')) {
+      continue;
+    }
+    const index = line.indexOf('=');
+    const key = line.slice(0, index).trim();
+    let value = line.slice(index + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"'))
+      || (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+async function loadRuntimeEnv(projectRoot) {
+  const envPath = path.join(projectRoot, '.claude', 'ukit', '.env');
+  try {
+    return parseRuntimeEnv(await fs.readFile(envPath, 'utf8'));
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      throw error;
+    }
+    return {};
+  }
+}
+
+function parsePositiveIntegerEnv(value) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    return null;
+  }
+  const parsed = Number.parseInt(value.trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function buildEnvOverrides(env = process.env) {
+  const overrides = {};
+  const smallTaskModel = env.UKIT_SMALL_TASK_MODEL;
+  if (typeof smallTaskModel === 'string' && smallTaskModel.trim() !== '') {
+    overrides.subagents = {
+      ...(overrides.subagents ?? {}),
+      smallTaskModel: smallTaskModel.trim(),
+    };
+  }
+
+  const rawCodexCompactTarget = parsePositiveIntegerEnv(env.UKIT_CODEX_COMPACT_TARGET);
+  const codexCompactTarget = rawCodexCompactTarget ? Math.min(rawCodexCompactTarget, 170) : null;
+  const codexContextBudget = parsePositiveIntegerEnv(env.UKIT_CODEX_CONTEXT_BUDGET);
+  const codexAutoCompact = typeof env.UKIT_CODEX_AUTO_COMPACT === 'string'
+    ? !['0', 'false', 'no', 'off'].includes(env.UKIT_CODEX_AUTO_COMPACT.trim().toLowerCase())
+    : null;
+
+  if (codexCompactTarget || codexContextBudget || codexAutoCompact !== null) {
+    overrides.compact = {
+      ...(overrides.compact ?? {}),
+      agentContext: {
+        enabled: true,
+        decisionModelEnv: 'UKIT_SMALL_TASK_MODEL',
+        decisionAgent: 'ukit-small-task-maintainer',
+        executionMode: 'sidecar-parallel',
+        mustNotBlockMainTask: true,
+        targets: {
+          claude: { autoCompact: true, mode: 'precompact-reinject', preserveExistingHooks: true },
+          opencode: { autoCompact: true, mode: 'native-auto-prune', preserveExistingCompaction: true },
+          codex: {
+            autoCompact: true,
+            mode: 'soft-handoff',
+            compactTarget: 150,
+            compactTargetUnit: 'lines',
+            compactTargetRecommendedRange: [120, 170],
+            compactTargetMax: 170,
+          },
+        },
+      },
+      codexContext: {
+        ...(overrides.compact?.codexContext ?? {}),
+        ...(codexCompactTarget ? { compactTarget: codexCompactTarget } : {}),
+        ...(codexContextBudget ? { budgetTokens: codexContextBudget } : {}),
+        ...(codexAutoCompact !== null ? { autoCompact: codexAutoCompact } : {}),
+      },
+    };
+  }
+
+  return overrides;
+}
+
 export function buildDefaultRuntimeConfig(overrides = {}) {
   const safeOverrides = isPlainObject(overrides) ? overrides : {};
 
   return mergeObjects({
-    version: '1.1.7',
+    version: '1.2.1',
     agent: 'claude-code',
     compact: {
       enabled: true,
       tokenThreshold: 100_000,
       contextRotDetection: true,
       askBeforeDrop: true,
+      agentContext: {
+        enabled: true,
+        decisionModelEnv: 'UKIT_SMALL_TASK_MODEL',
+        decisionAgent: 'ukit-small-task-maintainer',
+        executionMode: 'sidecar-parallel',
+        mustNotBlockMainTask: true,
+        targets: {
+          claude: { autoCompact: true, mode: 'precompact-reinject', preserveExistingHooks: true },
+          opencode: { autoCompact: true, mode: 'native-auto-prune', preserveExistingCompaction: true },
+          codex: {
+            autoCompact: true,
+            mode: 'soft-handoff',
+            compactTarget: 150,
+            compactTargetUnit: 'lines',
+            compactTargetRecommendedRange: [120, 170],
+            compactTargetMax: 170,
+          },
+        },
+      },
+      codexContext: {
+        enabled: true,
+        autoCompact: true,
+        budgetTokens: 60_000,
+        compactTarget: 150,
+        compactTargetUnit: 'lines',
+        compactTargetRecommendedRange: [120, 170],
+        compactTargetMax: 170,
+        decisionModelEnv: 'UKIT_SMALL_TASK_MODEL',
+        decisionAgent: 'ukit-small-task-maintainer',
+        mode: 'soft-handoff',
+        preserve: [
+          'current-goal',
+          'non-negotiable-rules',
+          'active-files',
+          'decisions',
+          'unresolved-failures',
+          'verification-evidence',
+          'next-actions',
+        ],
+      },
     },
     tokenPipeline: {
       inputCompression: true,
@@ -77,6 +216,53 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
       maxRetries: 1,
       confidenceThreshold: 50,
     },
+    subagents: {
+      enabled: true,
+      smallTaskModel: 'unic-lite',
+      smallTaskAgent: 'ukit-small-task-maintainer',
+      smallTaskUseCases: [
+        'task-cleanup',
+        'compact-decision',
+        'codex-context-budget',
+        'doc-summarization',
+        'classification',
+        'small-decision',
+        'auto-triage',
+        'queue-maintenance',
+        'workspace-maintenance',
+      ],
+      keepMainModelFor: [
+        'security',
+        'risky-code-change',
+        'release',
+        'data-loss',
+        'architecture-decision',
+        'deep-reasoning',
+      ],
+      decisionPolicy: {
+        nonBlocking: true,
+        endUserInvisible: true,
+        handBackOnRisk: true,
+        executionMode: 'sidecar-parallel',
+        mustNotBlockMainTask: true,
+        maxSidecarWaitMs: 0,
+        optimizeOrder: ['quality', 'safety', 'speed', 'token-discipline'],
+        decisions: [
+          'fast-vs-slow-lane',
+          'safe-vs-risky-lane',
+          'skill-routing-needed',
+          'step-budget-enough',
+          'compact-now-or-later',
+          'codex-context-budget',
+          'summarize-docs-or-keep-detail',
+        ],
+        stepBudgets: {
+          trivial: { maxSteps: 1, verification: 'skip-unless-risky' },
+          simple: { maxSteps: 2, verification: 'targeted-if-covered' },
+          nonTrivial: { maxSteps: 4, verification: 'targeted-then-widen-on-risk' },
+        },
+      },
+    },
   }, safeOverrides);
 }
 
@@ -102,6 +288,40 @@ export function validateRuntimeConfig(config) {
     pushPositiveNumberError(errors, config.compact.tokenThreshold, 'compact.tokenThreshold');
     pushBooleanError(errors, config.compact.contextRotDetection, 'compact.contextRotDetection');
     pushBooleanError(errors, config.compact.askBeforeDrop, 'compact.askBeforeDrop');
+    if (!isPlainObject(config.compact.agentContext)) {
+      errors.push('compact.agentContext must be an object.');
+    } else {
+      pushBooleanError(errors, config.compact.agentContext.enabled, 'compact.agentContext.enabled');
+      pushNonEmptyStringError(errors, config.compact.agentContext.decisionModelEnv, 'compact.agentContext.decisionModelEnv');
+      pushNonEmptyStringError(errors, config.compact.agentContext.decisionAgent, 'compact.agentContext.decisionAgent');
+      pushNonEmptyStringError(errors, config.compact.agentContext.executionMode, 'compact.agentContext.executionMode');
+      pushBooleanError(errors, config.compact.agentContext.mustNotBlockMainTask, 'compact.agentContext.mustNotBlockMainTask');
+      if (!isPlainObject(config.compact.agentContext.targets)) {
+        errors.push('compact.agentContext.targets must be an object.');
+      }
+    }
+    if (!isPlainObject(config.compact.codexContext)) {
+      errors.push('compact.codexContext must be an object.');
+    } else {
+      pushBooleanError(errors, config.compact.codexContext.enabled, 'compact.codexContext.enabled');
+      pushBooleanError(errors, config.compact.codexContext.autoCompact, 'compact.codexContext.autoCompact');
+      pushPositiveNumberError(errors, config.compact.codexContext.budgetTokens, 'compact.codexContext.budgetTokens');
+      pushPositiveNumberError(errors, config.compact.codexContext.compactTarget, 'compact.codexContext.compactTarget');
+      pushNonEmptyStringError(errors, config.compact.codexContext.compactTargetUnit, 'compact.codexContext.compactTargetUnit');
+      if (!Array.isArray(config.compact.codexContext.compactTargetRecommendedRange)) {
+        errors.push('compact.codexContext.compactTargetRecommendedRange must be an array.');
+      }
+      pushPositiveNumberError(errors, config.compact.codexContext.compactTargetMax, 'compact.codexContext.compactTargetMax');
+      if (Number(config.compact.codexContext.compactTarget) > Number(config.compact.codexContext.compactTargetMax)) {
+        errors.push('compact.codexContext.compactTarget must be <= compact.codexContext.compactTargetMax.');
+      }
+      pushNonEmptyStringError(errors, config.compact.codexContext.decisionModelEnv, 'compact.codexContext.decisionModelEnv');
+      pushNonEmptyStringError(errors, config.compact.codexContext.decisionAgent, 'compact.codexContext.decisionAgent');
+      pushNonEmptyStringError(errors, config.compact.codexContext.mode, 'compact.codexContext.mode');
+      if (!Array.isArray(config.compact.codexContext.preserve)) {
+        errors.push('compact.codexContext.preserve must be an array.');
+      }
+    }
   }
 
   if (!isPlainObject(config.tokenPipeline)) {
@@ -147,6 +367,23 @@ export function validateRuntimeConfig(config) {
     pushPositiveNumberError(errors, config.validation.confidenceThreshold, 'validation.confidenceThreshold');
   }
 
+  if (!isPlainObject(config.subagents)) {
+    errors.push('subagents must be an object.');
+  } else {
+    pushBooleanError(errors, config.subagents.enabled, 'subagents.enabled');
+    pushNonEmptyStringError(errors, config.subagents.smallTaskModel, 'subagents.smallTaskModel');
+    pushNonEmptyStringError(errors, config.subagents.smallTaskAgent, 'subagents.smallTaskAgent');
+    if (!Array.isArray(config.subagents.smallTaskUseCases)) {
+      errors.push('subagents.smallTaskUseCases must be an array.');
+    }
+    if (!Array.isArray(config.subagents.keepMainModelFor)) {
+      errors.push('subagents.keepMainModelFor must be an array.');
+    }
+    if (!isPlainObject(config.subagents.decisionPolicy)) {
+      errors.push('subagents.decisionPolicy must be an object.');
+    }
+  }
+
   return {
     valid: errors.length === 0,
     errors,
@@ -170,16 +407,31 @@ export async function inspectRuntimeConfig(projectRoot) {
     }
   }
 
-  const config = buildDefaultRuntimeConfig(rawConfig);
+  let runtimeEnv = {};
+  let envError = null;
+  try {
+    runtimeEnv = await loadRuntimeEnv(projectRoot);
+  } catch (error) {
+    envError = error?.message ?? String(error);
+  }
+
+  const config = buildDefaultRuntimeConfig(
+    mergeObjects(rawConfig ?? {}, buildEnvOverrides({ ...runtimeEnv, ...process.env })),
+  );
   const validation = validateRuntimeConfig(config);
-  const errors = parseError ? [`config.json parse error: ${parseError}`, ...validation.errors] : validation.errors;
+  const errors = [
+    ...(parseError ? [`config.json parse error: ${parseError}`] : []),
+    ...(envError ? [`runtime .env error: ${envError}`] : []),
+    ...validation.errors,
+  ];
 
   return {
     exists,
     rawConfig,
+    runtimeEnv,
     config,
     parseError,
-    valid: exists && !parseError && validation.valid,
+    valid: exists && !parseError && !envError && validation.valid,
     errors,
   };
 }

package/src/core/uninstall.js

@@ -200,7 +200,7 @@ export async function uninstallUkit({ projectRoot, dryRun = false }) {
     }
   } else {
     // Old format (no files list): fall back to hardcoded managed paths.
-    // NOTE: docs/PROJECT.md, MEMORY.md, WORKLOG.md are intentionally excluded.
+    // NOTE: docs/PROJECT.md, MEMORY.md, STATUS.md, TASKS.md, WORKLOG.md are intentionally excluded.
     // These are user-created content (mergeStrategy: skip) — deleting them
     // would cause data loss. Users must remove them manually if desired.
     const fallback = buildFallbackPaths(projectRoot);

package/src/index/routeCatalog.js

@@ -223,8 +223,30 @@ export const ROUTE_CATALOG = [
     path: '.claude/skills/docs-quality/SKILL.md',
     order: 12,
     signals: [
-      { type: 'prompt', regex: /\b(docs|documentation|readme|changelog|handoff|worklog|memory|code map)\b/i, score: 4 },
-      { type: 'file', regex: /\bdocs\/|readme\.md$|project\.md$|memory\.md$|worklog\.md$|code_map\.md$/i, score: 4 },
+      { type: 'prompt', regex: /\b(docs|documentation|readme|changelog|handoff|worklog|memory|code map|status\.md|tasks\.md|task queue|clean tasks|cleanup tasks|dọn tasks|dọn task)\b/i, score: 4 },
+      { type: 'file', regex: /\bdocs\/|readme\.md$|project\.md$|memory\.md$|status\.md$|tasks\.md$|worklog\.md$|code_map\.md$/i, score: 4 },
+    ],
+  },
+  {
+    id: 'next-step',
+    path: '.claude/skills/next-step/SKILL.md',
+    order: 12.1,
+    contextMode: 'standalone',
+    signals: [
+      { type: 'prompt', regex: /\b(what(?:'s| is)? next|next steps?|project status|current status|where are we|continue(?: from)?(?: last session)?|roadmap|status\.md|task queue|tasks\.md|next queued task|pick next task|work from tasks)\b/i, score: 7 },
+      { type: 'prompt', regex: /\b(làm gì tiếp|bước tiếp theo|tiếp theo làm gì|làm tiếp|đang ở đâu|trạng thái project|tình trạng project|task tiếp theo|việc tiếp theo trong tasks)\b/i, score: 7 },
+    ],
+  },
+  {
+    id: 'update-status',
+    path: '.claude/skills/update-status/SKILL.md',
+    order: 12.2,
+    contextMode: 'standalone',
+    signals: [
+      { type: 'prompt', regex: /\b(update|refresh|write|sync|record|capture|summari[sz]e).{0,48}\b(status\.md|project status|current state|next candidates?|session state)\b/i, score: 9 },
+      { type: 'prompt', regex: /\b(status\.md|project status).{0,48}\b(update|refresh|write|sync|record|capture|summari[sz]e)\b/i, score: 9 },
+      { type: 'prompt', regex: /\b(wrap up|handoff|end(?:ing)? this session|session summary|before final)\b/i, score: 7 },
+      { type: 'prompt', regex: /\b(cập nhật|ghi lại|tổng kết|chốt session|bàn giao).{0,48}\b(status|trạng thái|việc tiếp theo)\b/i, score: 9 },
     ],
   },
   {