chati-dev 4.5.14 → 4.5.16

package/framework/config.yaml

@@ -1,8 +1,8 @@
 # chati.dev Configuration
-version: "4.5.14"
+version: "4.5.16"
 installed_at: "2026-02-07T10:00:00Z"
-updated_at: "2026-08-27T00:00:00Z"
-installer_version: "4.5.14"
+updated_at: "2026-08-28T00:00:00Z"
+installer_version: "4.5.16"
 project_type: greenfield
 language: en
 ides: []

package/framework/context/protocols.md

@@ -21,7 +21,7 @@ Agent retries on failure. Investigate root cause before escalating.
 ## 6. Language Protocol
 - **Interaction**: User's preferred language
 - **Artifacts**: Always English
-- **First step output**: Always English
+- **Every visible interaction**: Use the language selected during installation, starting with the first response. This includes prefaces, progress updates, questions, errors, pauses, and resumptions.
 
 ## 7. Deviation Protocol
 - Deviations handled by orchestrator (not separate agent)

package/framework/context/root.md

@@ -1,7 +1,7 @@
 # Chati.dev System Context
 
 ## Framework
-- **Version**: 4.5.14
+- **Version**: 4.5.16
 - **Agents**: Specialized discovery and planning agents feeding provider-neutral RAIL execution and a sealed release lane
 - **Constitution**: 25 Articles + Preamble
 - **Quality**: 5 pipeline gates + 3-tier verdicts + Fault Vector Protocol (Article XXII)

package/framework/i18n/en.yaml

@@ -100,6 +100,9 @@ installer:
   system_prerequisites_failed: "System prerequisites not met:"
   fix_prerequisites: "Fix the issues above and try again."
   system_check: "System check:"
+  system_checking: "Checking system requirements..."
+  catalog_resolving: "Loading the signed model catalog..."
+  internal_authorizing: "Verifying access to Internal mode..."
   created_provider_claude: "Created .claude/commands/ (thin router)"
   created_provider_gemini: "Created .gemini/commands/ (TOML command)"
   created_provider_codex: "Created .agents/skills/chati/ (Codex skill)"
@@ -114,6 +117,7 @@ installer:
   license_placeholder: "CHATI-XXXX-XXXX-XXXX"
   license_skipped: "Skipped. Run: npx chati-dev activate --key=YOUR-KEY when ready."
   license_activating: "Activating license..."
+  license_verifying: "Verifying saved license..."
   license_activated: "License activated! Plan: {plan}, {days} day(s) remaining."
   license_activation_failed: "Activation failed: {error}"
   license_retry: "Run: npx chati-dev activate --key=YOUR-KEY to try again."

package/framework/i18n/es.yaml

@@ -100,6 +100,9 @@ installer:
   system_prerequisites_failed: "No se cumplen los requisitos previos del sistema:"
   fix_prerequisites: "Corrija los problemas anteriores e intentelo de nuevo."
   system_check: "Verificacion del sistema:"
+  system_checking: "Verificando los requisitos del sistema..."
+  catalog_resolving: "Cargando el catalogo firmado de modelos..."
+  internal_authorizing: "Verificando el acceso al modo Internal..."
   created_provider_claude: "Creado .claude/commands/ (enrutador ligero)"
   created_provider_gemini: "Creado .gemini/commands/ (comando TOML)"
   created_provider_codex: "Creado .agents/skills/chati/ (skill de Codex)"
@@ -114,6 +117,7 @@ installer:
   license_placeholder: "CHATI-XXXX-XXXX-XXXX"
   license_skipped: "Paso omitido. Cuando quiera, ejecute: npx chati-dev activate --key=SU-CLAVE."
   license_activating: "Activando la licencia..."
+  license_verifying: "Verificando la licencia guardada..."
   license_activated: "Licencia activada! Plan: {plan}, {days} dia(s) restante(s)."
   license_activation_failed: "Fallo de activacion: {error}"
   license_retry: "Ejecute: npx chati-dev activate --key=SU-CLAVE para intentarlo de nuevo."

package/framework/i18n/fr.yaml

@@ -100,6 +100,9 @@ installer:
   system_prerequisites_failed: "Les prerequis systeme ne sont pas satisfaits:"
   fix_prerequisites: "Corrigez les problemes ci-dessus et reessayez."
   system_check: "Verification du systeme:"
+  system_checking: "Verification des prerequis du systeme..."
+  catalog_resolving: "Chargement du catalogue de modeles signe..."
+  internal_authorizing: "Verification de l'acces au mode Internal..."
   created_provider_claude: "Cree .claude/commands/ (routeur leger)"
   created_provider_gemini: "Cree .gemini/commands/ (commande TOML)"
   created_provider_codex: "Cree .agents/skills/chati/ (skill Codex)"
@@ -114,6 +117,7 @@ installer:
   license_placeholder: "CHATI-XXXX-XXXX-XXXX"
   license_skipped: "Etape ignoree. Lorsque vous le souhaitez, executez: npx chati-dev activate --key=VOTRE-CLE."
   license_activating: "Activation de la licence..."
+  license_verifying: "Verification de la licence enregistree..."
   license_activated: "Licence activee! Offre: {plan}, {days} jour(s) restant(s)."
   license_activation_failed: "Echec de l'activation: {error}"
   license_retry: "Executez: npx chati-dev activate --key=VOTRE-CLE pour reessayer."

package/framework/i18n/pt.yaml

@@ -100,6 +100,9 @@ installer:
   system_prerequisites_failed: "Os pre-requisitos do sistema nao foram atendidos:"
   fix_prerequisites: "Corrija os problemas acima e tente novamente."
   system_check: "Verificacao do sistema:"
+  system_checking: "Verificando os requisitos do sistema..."
+  catalog_resolving: "Carregando o catalogo assinado de modelos..."
+  internal_authorizing: "Validando o acesso ao modo Internal..."
   created_provider_claude: "Criado .claude/commands/ (roteador leve)"
   created_provider_gemini: "Criado .gemini/commands/ (comando TOML)"
   created_provider_codex: "Criado .agents/skills/chati/ (skill do Codex)"
@@ -114,6 +117,7 @@ installer:
   license_placeholder: "CHATI-XXXX-XXXX-XXXX"
   license_skipped: "Etapa ignorada. Quando quiser, execute: npx chati-dev activate --key=SUA-CHAVE."
   license_activating: "Ativando a licenca..."
+  license_verifying: "Validando a licenca salva..."
   license_activated: "Licenca ativada! Plano: {plan}, {days} dia(s) restante(s)."
   license_activation_failed: "Falha na ativacao: {error}"
   license_retry: "Execute: npx chati-dev activate --key=SUA-CHAVE para tentar novamente."

package/framework/manifest.json

@@ -1,5 +1,5 @@
 {
-  "createdAt": "2026-08-28T08:29:11.442Z",
+  "createdAt": "2026-08-28T12:19:47.274Z",
   "files": {
     "agents/build/dev.md": {
       "hash": "f0dd9bcdf44c57fdf64beca65d3617f0f24467b2f6edc9c0577d721b4922977a",
@@ -97,7 +97,7 @@
       "type": "md"
     },
     "config.yaml": {
-      "hash": "8c95fbfbb1f751468c309007aaafd784835af8fe7d712313733ca82605f13cf1",
+      "hash": "66f9a59f21944288544a7aeb5bb0316c3c65be1162faa0db896f5346d8f89877",
       "size": 2638,
       "type": "yaml"
     },
@@ -112,8 +112,8 @@
       "type": "md"
     },
     "context/protocols.md": {
-      "hash": "c1fe6ae5c0c17ab664394bc3caa3ecddf4cd1c4a17db34ad5f5086bd65ccd399",
-      "size": 1250,
+      "hash": "a80110e083cd4e301173353fa2748e096bdb7a09ffad9e6302ba5075fbf11cee",
+      "size": 1410,
       "type": "md"
     },
     "context/quality.md": {
@@ -122,7 +122,7 @@
       "type": "md"
     },
     "context/root.md": {
-      "hash": "90f8c75eab767daba5178351e02925c99c201215e9f0ea8ee1bf1991eb1136b0",
+      "hash": "a226a365f64a28bf952c399dcc97962202bd195fa2a75fd4b894293a1503569d",
       "size": 1333,
       "type": "md"
     },
@@ -377,23 +377,23 @@
       "type": "js"
     },
     "i18n/en.yaml": {
-      "hash": "220fc363ed6e523509cd50cab92ad17735cc8de37f60030cb8b26dadca1c88f6",
-      "size": 8082,
+      "hash": "dbaf6e3da9820a933bd6b358e5dcce49057c7b34c7855d6f7f443833202f347a",
+      "size": 8307,
       "type": "yaml"
     },
     "i18n/es.yaml": {
-      "hash": "e088fca0e2525482011e290396b7d242751c97af5b23d49e9e84e6c5b2f854f5",
-      "size": 8685,
+      "hash": "047a14e7fa763179002c265f2df3bf0e9a407d5fc8b8fac0ff05ae92562f11eb",
+      "size": 8941,
       "type": "yaml"
     },
     "i18n/fr.yaml": {
-      "hash": "5245519c4acdd577db0052928e0c6ee7b4677212d8b2808cdf0ea4aa89f67b67",
-      "size": 8826,
+      "hash": "8353e42d8124546109833a123143e905dbb976abe658259d3782aa5d1190d0b4",
+      "size": 9090,
       "type": "yaml"
     },
     "i18n/pt.yaml": {
-      "hash": "0a1e9a905db5a776ee790735fbd442d3b0fce93084f1b8fb3ba9021726b3047b",
-      "size": 8566,
+      "hash": "9286764e634c88b1cf8f49f9239d48ff5a2bbef7fe207d61d69d70c501bdca8b",
+      "size": 8812,
       "type": "yaml"
     },
     "intelligence/confidence.yaml": {
@@ -462,8 +462,8 @@
       "type": "yaml"
     },
     "orchestrator/chati-router.js": {
-      "hash": "a7d321ac7454ff762b251d81060da766668b8a1051b92cef6dea17fb092e606a",
-      "size": 22113,
+      "hash": "402033380d5becfb73d77c4c617740e7f32b2abf1c42bf6b9e751b97bd32c876",
+      "size": 23194,
       "type": "js"
     },
     "orchestrator/chati-update.md": {
@@ -472,8 +472,8 @@
       "type": "md"
     },
     "orchestrator/chati.md": {
-      "hash": "b64b1d2e1880f8de6cc80eca9fe42328f1f00a558e8bf03811b4433e883f1af8",
-      "size": 46098,
+      "hash": "b0e7395fa4ae0119e8df721e0f97c04d740c119be5f260673aea14b5672e96ff",
+      "size": 46948,
       "type": "md"
     },
     "package.json": {
@@ -857,8 +857,8 @@
       "type": "json"
     },
     "schemas/session.schema.json": {
-      "hash": "5d43e2cef2722f0bacd31326eab32040c9327469f1b520ecbe0e517940e0f754",
-      "size": 19183,
+      "hash": "553b5bf78761f8dd50f98b1e638d42c1bde473d1c0e562b087b3f26cc8c3585b",
+      "size": 19979,
       "type": "json"
     },
     "schemas/task.schema.json": {
@@ -1352,5 +1352,5 @@
       "type": "yaml"
     }
   },
-  "version": "4.5.14"
+  "version": "4.5.16"
 }

package/framework/manifest.sig

@@ -1 +1 @@
-pPMQq8Hj2U80c5Q0ToefvDYDDokdYPbLnhbB7eXsH4ne15QSk0fHGJHd0QpJbfXKKBEEZlNhBMzMQcoDBbASDw==
+pn6mHfeHH1rfvjDzyoAh8karYWO61dtxogu3tZgcmrb8Q07rgK3jUK0AS4ThiCqIVDiyGOpp0df6GjiZ1meGAg==

package/framework/orchestrator/chati-router.js

@@ -19,7 +19,12 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 
 const PROJECT_DIR = process.cwd();
-const ROUTER_ARGS = process.argv.slice(2);
+const RAW_ROUTER_ARGS = process.argv.slice(2);
+const harnessFlagIndex = RAW_ROUTER_ARGS.indexOf('--harness');
+const ACTIVE_HARNESS = harnessFlagIndex >= 0 ? RAW_ROUTER_ARGS[harnessFlagIndex + 1] : null;
+const ROUTER_ARGS = harnessFlagIndex >= 0
+  ? RAW_ROUTER_ARGS.filter((_, index) => index !== harnessFlagIndex && index !== harnessFlagIndex + 1)
+  : RAW_ROUTER_ARGS;
 
 async function readEnabledHarnesses(projectDir) {
   const installationPath = join(projectDir, '.chati', 'v2', 'installation.json');
@@ -312,6 +317,7 @@ const VALID_ORCHESTRATE_SUBS = new Set([
   'spawn-team', 'team-status', 'team-dissolve',
   'wait-for-capture', 'wave-status', 'assess-coverage',
   'wait-for-license', 'doctor', 'run-script-task',
+  'activate-harness',
 ]);
 
 const VALID_RAIL_SUBS = new Set(['rail-next']);
@@ -486,13 +492,34 @@ async function main() {
     pipeline: null,
     team: null,
     error: null,
+    active_harness: ACTIVE_HARNESS,
   };
 
+  const canonicalSessionPath = join(PROJECT_DIR, '.chati', 'session.yaml');
+  if (ACTIVE_HARNESS && existsSync(canonicalSessionPath)) {
+    const cliMod = await findCliModule(PROJECT_DIR);
+    if (!cliMod) {
+      result.ok = false;
+      result.action = 'error';
+      result.error = 'cli_module_not_found';
+      console.log(JSON.stringify(result));
+      return;
+    }
+    const activation = await captureOrchestrate(cliMod, 'activate-harness', ['--harness', ACTIVE_HARNESS], PROJECT_DIR);
+    if (!activation.activated) {
+      result.ok = false;
+      result.action = 'error';
+      result.error = activation.error || 'harness_activation_failed';
+      console.log(JSON.stringify(result));
+      return;
+    }
+  }
+
   // -----------------------------------------------------------------------
   // 1. Session state
   // -----------------------------------------------------------------------
   try {
-    const sessionPath = join(PROJECT_DIR, '.chati', 'session.yaml');
+    const sessionPath = canonicalSessionPath;
     if (existsSync(sessionPath)) {
       const raw = readFileSync(sessionPath, 'utf-8');
       const extract = (key) => {

package/framework/orchestrator/chati.md

@@ -103,6 +103,7 @@ Parse the JSON output. The `action` field tells you what to do:
 | `setup` | Action: Setup |
 | `activate_interactive` | Action: Interactive Agent |
 | `spawn_routed_interactive` | Action: Routed Interactive Agent |
+| `resume_pending_interaction` | Action: Resume Pending Interaction |
 | `spawn_autonomous` | Action: Autonomous Agent |
 | `spawn_parallel` | Action: Parallel Spawn |
 | `spawn_team` | Action: Spawn Team (Article XXI) |
@@ -204,6 +205,19 @@ internal router.
 4. The opened CLI remains the conversation orchestrator. The routed process
    does not become a framework-wide primary CLI.
 
+## Action: Resume Pending Interaction
+
+The routed process already asked a question and the canonical session stored
+it. Do not execute `spawn_command` yet and do not dispatch the agent again.
+
+1. Present only the exact `question` returned by the router, using
+   `session.language`.
+2. When the user answers, execute the returned `spawn_command` once with
+   `--additional-context "{user_response}"` appended.
+3. Parse the new result using Action: Routed Interactive Agent.
+4. Read `relay_cycles` from the router response. After three unresolved relay cycles, use the configured reasoning
+   escalation. Do not invent an answer or silently switch providers.
+
 ---
 
 ## Completion Options (Protocol 3 - Guided Options)
@@ -977,7 +991,7 @@ When the independent RAIL reviewer classifies a fault:
 - Read language from JSON `session.language` field
 - ALL interactions, guidance, questions, options in that language
 - ALL artifacts, handoffs, templates in English (enforced by Constitution Article VII)
-- First step output of any agent: always English
+- Every visible interaction from the first response onward follows `session.language`, including prefaces, progress messages, questions, errors, pauses, and resumptions.
 
 ---
 

package/framework/schemas/session.schema.json

@@ -85,6 +85,26 @@
       "type": "string",
       "description": "Currently active agent name"
     },
+    "active_harness": {
+      "type": ["string", "null"],
+      "enum": ["claude", "codex", "grok", null],
+      "default": null,
+      "description": "CLI or UI currently orchestrating the conversation. Independent from task provider routing."
+    },
+    "session_status": {
+      "enum": ["inactive", "active", "paused", "completed"],
+      "default": "inactive"
+    },
+    "current_execution_binding": {
+      "type": ["object", "null"],
+      "default": null,
+      "description": "Exact provider, model and reasoning binding for the active routed task."
+    },
+    "pending_interaction": {
+      "type": ["object", "null"],
+      "default": null,
+      "description": "Durable interactive relay, including the exact unanswered question and its execution binding."
+    },
     "language": {
       "enum": ["en", "pt", "es", "fr"],
       "default": "en",
@@ -122,7 +142,7 @@
           "type": "object",
           "required": ["status", "score", "criteria_count"],
           "properties": {
-            "status": { "enum": ["pending", "in_progress", "completed", "skipped", "needs_revalidation"] },
+            "status": { "enum": ["pending", "in_progress", "waiting_for_user", "completed", "skipped", "needs_revalidation"] },
             "score": { "type": "number", "minimum": 0, "maximum": 100 },
             "criteria_count": { "type": "integer", "minimum": 0 },
             "completed_at": { "type": ["string", "null"], "format": "date-time" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "4.5.14",
+  "version": "4.5.16",
   "description": "AI-Powered Multi-Agent Orchestration System - Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {

package/src/installer/core.js

@@ -182,7 +182,13 @@ export async function installFramework(config) {
   // Write config.yaml
   writeFileSync(
     join(frameworkDir, 'config.yaml'),
-    generateConfigYaml({ version, projectType, language, selectedIDEs, allProviders: enabledProviders, runtimeVersion: config.runtimeVersion }),
+    generateConfigYaml({
+      version, projectType, language, selectedIDEs,
+      allProviders: enabledProviders,
+      runtimeVersion: config.runtimeVersion,
+      installationMode: config.installationMode,
+      clickupPreflight: config.clickupPreflight,
+    }),
     'utf-8'
   );
 
@@ -481,7 +487,7 @@ async function configureIDE(targetDir, ideKey, selectedMCPs, options = {}) {
 
 Run via Bash:
 \`\`\`
-node .chati.dev/orchestrator/chati-router.js
+node .chati.dev/orchestrator/chati-router.js --harness claude
 \`\`\`
 
 Parse the JSON output. This single command already handled: license validation, integrity check, session state, pipeline routing, and team registration (if needed). You do NOT need to run any of these separately.
@@ -497,7 +503,7 @@ Parse the JSON output. This single command already handled: license validation,
 
 ### If \`ok\` is true:
 
-1. Use \`session.language\` for ALL responses (pt = Português, en = English, es = Español, fr = Français).
+1. Use \`session.language\` for every visible response, preface, progress message, question and error, starting with the first response (pt = Português, en = English, es = Español, fr = Français).
 2. Read the full orchestrator at \`${orchestratorPath || '.chati.dev/orchestrator/chati.md'}\`.
 3. The \`action\` field tells you what to do. Go to the matching "Action:" section in the orchestrator.
 4. **If \`action\` is \`spawn_team\`**: the team is ALREADY registered (Step 1 already ran as code). The \`team\` object contains \`team_id\`, \`task_list_path\`, \`mailbox_path\`, \`members\`. Go directly to "Action: Spawn Team" Step 2 and use these values in the agent prompts. DO NOT run \`orchestrate spawn-team\` again — it already ran.

package/src/installer/templates.js

@@ -55,6 +55,10 @@ export function generateSessionYaml(config) {
     scaffold_applied: [],
     active_model: null,
     active_provider: null,
+    active_harness: null,
+    session_status: 'inactive',
+    current_execution_binding: null,
+    pending_interaction: null,
     context_tokens_used: 0,
     context_window_tokens: null,
     context_last_bracket: null,
@@ -119,6 +123,13 @@ export function generateConfigYaml(config) {
       codex: { enabled: providers.includes('codex') || selectedIDEs.includes('codex-cli') },
       grok: { enabled: providers.includes('grok') || selectedIDEs.includes('grok-cli') },
     },
+    integrations: {
+      clickup: {
+        required: config.installationMode === 'internal',
+        connected_harnesses: config.clickupPreflight?.connected_providers || [],
+        durable_projection_queue: '.chati/v2/tracking/pending-projections',
+      },
+    },
   };
 
   // Feature flags (Intelligence Upgrade + Article XXI Agent Teams)
@@ -228,7 +239,7 @@ description: >
 Use the shell in the current project directory and run:
 
 \`\`\`bash
-node .chati.dev/orchestrator/chati-router.js
+node .chati.dev/orchestrator/chati-router.js --harness codex
 \`\`\`
 
 Do not infer provider authentication, session state, model availability, or the
@@ -239,7 +250,8 @@ routed spawn command returns a provider authentication error.
 Parse the JSON output before responding:
 
 - If \`ok\` is \`false\`, report the exact \`error\` and relevant detail, then stop.
-- If \`ok\` is \`true\`, use \`session.language\` for every response.
+- If \`ok\` is \`true\`, use \`session.language\` for every visible response,
+  preface, progress message, question and error, starting with the first response.
 - Follow the returned \`action\` in the adapted orchestrator.
 - When the action includes \`pipeline.spawn_command\`, execute that exact command.
   Never replace it with an inferred provider check or a manually constructed command.
@@ -256,8 +268,9 @@ Parse the JSON output before responding:
 
 ## CRITICAL: Language Override
 
-Read \`.chati/session.yaml\` field \`language\` BEFORE anything else.
-ALL responses MUST be in this language. This overrides any global setting.
+Use the canonical \`session.language\` returned by the router. ALL visible
+responses MUST use this language from the first response onward. This
+overrides any global setting.
 
 | Value | Language |
 |-------|----------|
@@ -296,7 +309,7 @@ export function generateGeminiRouter(options = {}) {
 prompt = """
 CRITICAL — Language Override:
 Read .chati/session.yaml field "language" BEFORE anything else.
-ALL responses MUST be in this language (en, pt, es, fr).
+Every visible response, including the first response, MUST be in this language (en, pt, es, fr).
 If session.yaml does not exist or has no language field, default to English.
 
 The orchestrator and all agent files are pre-configured for Gemini CLI.
@@ -323,13 +336,23 @@ export function generateGrokRouter(options = {}) {
   const orchPath = options.orchestratorPath || '.chati.dev/orchestrator/chati.md';
   return `# Chati.dev Orchestrator
 
-Read \`.chati/session.yaml\` and use its \`language\` for every response.
-If the field is absent, default to English.
+## STEP 0: Run the deterministic router first
+
+Before reading mutable session files or responding, run:
+
+\`\`\`bash
+node .chati.dev/orchestrator/chati-router.js --harness grok
+\`\`\`
+
+Parse the JSON output. It is the source of truth for session state, task
+routing and provider authentication. Use the returned \`session.language\` for
+every visible response, preface, progress message, question and error,
+starting with the first response. If absent, default to English.
 
 The orchestrator and agent files are pre-configured for Grok CLI. Read and
 execute the full orchestrator at \`${orchPath}\`.
 
-Load this context:
+Only after the router succeeds, load this context:
 - \`.chati/session.yaml\`
 - \`AGENTS.md\`
 - \`.grok/session-lock.md\`

package/src/intelligence/timeline.js

@@ -33,6 +33,8 @@ export const EventType = {
   PROVIDER_SELECTED: 'provider_selected',
   SESSION_STARTED: 'session_started',
   SESSION_ENDED: 'session_ended',
+  HARNESS_ACTIVATED: 'harness_activated',
+  AGENT_WAITING_FOR_INPUT: 'agent_waiting_for_input',
   CORRECTION_TRIGGERED: 'correction_triggered',
   CORRECTION_ESCALATED: 'correction_escalated',
 };
@@ -84,7 +86,7 @@ export function recordEvent(projectDir, type, agent, data = {}) {
   // Prevents duplicate AGENT_ACTIVATED entries when handleAdvance chains into
   // handleNext while the caller also invokes next separately.
   const last = timeline[timeline.length - 1];
-  if (last && last.type === type && last.agent === agent) {
+  if (type === EventType.AGENT_ACTIVATED && last && last.type === type && last.agent === agent) {
     return last;
   }
 

package/src/orchestrator/cli.js

@@ -799,6 +799,35 @@ function removeSessionLock(projectDir, resumeMsg) {
 async function handleNext(projectDir) {
   const result = await _handleNextInner(projectDir);
 
+  // The canonical session owns the active task. Native harness lock files are
+  // projections only, so a CLI switch cannot create a second execution.
+  // Persist only actions that actually dispatch an agent. Surface holds and
+  // RAIL handoffs are control-plane responses, not running pipeline agents.
+  const dispatchActions = new Set([
+    'spawn_routed_interactive',
+    'spawn_autonomous',
+    'spawn_parallel',
+    'spawn_team',
+  ]);
+  if (result?.agent && dispatchActions.has(result.action)) {
+    const binding = result.model_info ? {
+      provider: result.model_info.provider || null,
+      provider_id: result.model_info.provider_id || null,
+      model: result.model_info.model || null,
+      reasoning_configuration: result.model_info.reasoning_configuration || null,
+      catalog_snapshot_ref: result.model_info.catalog_snapshot_ref || null,
+    } : null;
+    const persisted = updateSession(projectDir, {
+      current_agent: result.agent,
+      ...(binding ? { current_execution_binding: binding } : {}),
+      agents: { [result.agent]: { status: 'in_progress' } },
+    });
+    if (!persisted.saved) {
+      return errorResult(`Could not persist canonical agent state: ${persisted.error}`, 'SESSION_WRITE_FAILED');
+    }
+    recordEvent(projectDir, EventType.AGENT_ACTIVATED, result.agent, { action: result.action, phase: result.phase });
+  }
+
   // Fase 8: attach state-at-a-glance card to every non-error response.
   // The card renders as a JSON string field; the terminal / orchestrator
   // prompt can console.log it verbatim. Silent on setup/error responses
@@ -815,7 +844,7 @@ async function handleNext(projectDir) {
   // Centralized session lock update: applies to ALL return paths.
   // Activates lock when an agent is returned, deactivates on completion.
   if (result && result.agent && result.action !== 'error' && result.action !== 'setup') {
-    const activating = ['activate_interactive', 'spawn_routed_interactive', 'spawn_autonomous', 'spawn_team', 'spawn_parallel'];
+    const activating = ['activate_interactive', 'spawn_routed_interactive', 'spawn_autonomous', 'spawn_team', 'spawn_parallel', 'resume_pending_interaction'];
     if (activating.includes(result.action)) {
       try {
         const runtimePipeline = getRuntimeAgentPipeline(projectDir, result.session);
@@ -852,6 +881,40 @@ async function _handleNextInner(projectDir) {
 
   const installationV2 = loadRuntimeInstallationV2(projectDir);
   const runtimePipeline = getRuntimeAgentPipeline(projectDir, session);
+
+  const pending = session.pending_interaction;
+  if (pending?.status === 'waiting_for_user' && pending.agent && pending.question) {
+    const binding = pending.execution_binding || session.current_execution_binding || resolveAgentModel(pending.agent, projectDir);
+    const agentDef = getAgentDefinition(pending.agent);
+    return {
+      action: 'resume_pending_interaction',
+      agent: pending.agent,
+      agent_file: getAgentFile(pending.agent, projectDir) || null,
+      phase: agentDef?.phase || session.mode,
+      question: pending.question,
+      relay_cycles: pending.relay_cycles || 1,
+      spawn_command: buildSpawnCommand(
+        pending.agent,
+        projectDir,
+        session.last_handoff || 'none',
+        binding.provider,
+        600000,
+        binding.model,
+        Boolean(installationV2),
+        binding,
+      ),
+      model_info: binding,
+      redispatched: false,
+      pipeline_progress: getPipelineProgress(sessionToPipelineState(session, projectDir)),
+      session: {
+        language: session.language,
+        project_type: session.project_type || session.project?.type,
+        execution_mode: session.execution_mode,
+        active_harness: session.active_harness,
+      },
+      status_summary: `Waiting for the user's answer to ${pending.agent}.`,
+    };
+  }
   if (installationV2 && session.rail_handoff_id) {
     const completedPlanning = runtimePipeline.length;
     return {
@@ -2405,8 +2468,8 @@ async function handleStatus(projectDir) {
   // bracket prism-engine last computed. If the session predates v1.2
   // (no context_* fields yet), the block falls back to estimateContextBracket
   // so the existing response shape stays stable for consumers.
-  const activeModel     = session.active_model || null;
-  const activeProvider  = session.active_provider || (session.providers_enabled || [])[0] || null;
+  const activeModel     = session.current_execution_binding?.model || session.active_model || null;
+  const activeProvider  = session.current_execution_binding?.provider || session.active_provider || null;
   const windowTokens    = session.context_window_tokens != null
     ? session.context_window_tokens
     : resolveContextLimit(activeModel, activeProvider);
@@ -2440,9 +2503,32 @@ async function handleStatus(projectDir) {
     },
     user_level: session.user_level || 'auto',
     execution_mode: session.execution_mode || 'interactive',
+    active_harness: session.active_harness || null,
+    current_execution_binding: session.current_execution_binding || null,
+    pending_interaction: session.pending_interaction || null,
   };
 }
 
+async function handleActivateHarness(projectDir, args) {
+  const harness = args.harness;
+  if (!['claude', 'codex', 'grok'].includes(harness)) {
+    return errorResult('Harness must be claude, codex, or grok.', 'INVALID_HARNESS');
+  }
+  const { loaded, session } = loadSession(projectDir);
+  if (!loaded || !session) return errorResult('No session found', 'NO_SESSION');
+  const previous = session.active_harness || null;
+  const wasActive = session.session_status === 'active';
+  const saved = updateSession(projectDir, { active_harness: harness, session_status: 'active' });
+  if (!saved.saved) return errorResult(saved.error, 'SESSION_WRITE_FAILED');
+  if (previous !== harness) {
+    recordEvent(projectDir, EventType.HARNESS_ACTIVATED, 'orchestrator', { harness, previous_harness: previous });
+  }
+  if (previous !== harness || !wasActive) {
+    recordEvent(projectDir, EventType.SESSION_STARTED, session.current_agent || 'orchestrator', { harness, resumed: Boolean(previous) });
+  }
+  return { activated: true, harness, previous_harness: previous, language: session.language || 'en' };
+}
+
 async function handleDeviation(projectDir, args) {
   const type = args.type;
   const target = args.target || null;
@@ -2525,8 +2611,8 @@ async function handleExit(projectDir, args) {
   }
 
   // Save current state
-  recordEvent(projectDir, EventType.SESSION_ENDED, session.current_agent || 'orchestrator', { mode: session.mode });
-  await updateSession(projectDir, {});
+  recordEvent(projectDir, EventType.SESSION_ENDED, session.current_agent || 'orchestrator', { mode: session.mode, harness: session.active_harness || null });
+  await updateSession(projectDir, { session_status: 'paused' });
 
   // Release session ownership
   const userId = args['user-id'] || process.env.USER || 'default';
@@ -2536,9 +2622,14 @@ async function handleExit(projectDir, args) {
 
   // Remove lock from CLAUDE.local.md
   const lang = session.language || 'en';
-  const resumeMsg = RESUME_MESSAGES[lang] || RESUME_MESSAGES.en;
+  const genericResumeMsg = RESUME_MESSAGES[lang] || RESUME_MESSAGES.en;
+  const resumeMsg = session.active_harness === 'codex'
+    ? genericResumeMsg.replaceAll('/chati', '$chati')
+    : genericResumeMsg;
   try {
-    removeSessionLock(projectDir, resumeMsg);
+    // Each lock target translates the generic command to its native syntax.
+    // The returned message below remains native to the harness that exited.
+    removeSessionLock(projectDir, genericResumeMsg);
   } catch { /* expected: lock file may not exist */ }
 
   return {
@@ -3561,6 +3652,9 @@ export async function runOrchestrate(subCommand, argv, projectDir) {
       case 'exit':
         output(await handleExit(projectDir, args));
         break;
+      case 'activate-harness':
+        output(await handleActivateHarness(projectDir, args));
+        break;
       case 'providers':
         output(await handleProviders(projectDir));
         break;

package/src/orchestrator/doctor.js

@@ -29,6 +29,7 @@
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { readLicenseStatus } from '../license/wait.js';
+import * as yaml from 'js-yaml';
 
 export const SEVERITY = Object.freeze({
   BLOCK: 'BLOCK',
@@ -202,10 +203,13 @@ export function checkModel({ projectDir }) {
     };
   }
   try {
-    const raw = readFileSync(sessionPath, 'utf-8');
-    const match = raw.match(/^\s*active_model:\s*(.+)$/m);
-    const value = match ? match[1].trim().replace(/^["']|["']$/g, '') : '';
-    if (!value || value === 'null' || value === '~' || value === '') {
+    const session = yaml.load(readFileSync(sessionPath, 'utf-8')) || {};
+    const value = session.active_model;
+    const routedModel = session.current_execution_binding?.model;
+    if (!value && routedModel) {
+      return { id: 'model', severity: SEVERITY.WARN, status: 'pass', message: `Routed execution model: ${routedModel}` };
+    }
+    if (!value) {
       return {
         id:       'model',
         severity: SEVERITY.WARN,
@@ -222,6 +226,70 @@ export function checkModel({ projectDir }) {
   }
 }
 
+/** Compare canonical session state with native harness projections. */
+export function checkRuntimeState({ projectDir }) {
+  const sessionPath = join(projectDir, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) {
+    return { id: 'runtime-state', severity: SEVERITY.WARN, status: 'pass', message: 'Session not initialized.' };
+  }
+  try {
+    const session = yaml.load(readFileSync(sessionPath, 'utf-8')) || {};
+    const lockPaths = [
+      join(projectDir, 'CLAUDE.local.md'),
+      join(projectDir, 'AGENTS.override.md'),
+      join(projectDir, '.grok', 'session-lock.md'),
+      join(projectDir, '.gemini', 'session-lock.md'),
+    ];
+    const projectedAgents = [];
+    for (const lockPath of lockPaths) {
+      if (!existsSync(lockPath)) continue;
+      const raw = readFileSync(lockPath, 'utf-8');
+      if (!/(?:Session Lock:\s*ACTIVE|\*\*Status:\s*ACTIVE\*\*)/i.test(raw)) continue;
+      const match = raw.match(/\*\*Agent\*\*:\s*([^\n]+)/i);
+      if (match) projectedAgents.push(match[1].trim());
+    }
+    const mismatches = [...new Set(projectedAgents)].filter(agent => agent !== session.current_agent);
+    if (mismatches.length > 0) {
+      return {
+        id: 'runtime-state', severity: SEVERITY.WARN, status: 'fail',
+        message: `Canonical current_agent (${session.current_agent || 'none'}) disagrees with native lock projection(s): ${mismatches.join(', ')}`,
+        fix: 'Run the deterministic router once from the active CLI to refresh native projections.',
+      };
+    }
+    return { id: 'runtime-state', severity: SEVERITY.WARN, status: 'pass', message: 'Canonical session and native lock projections agree.' };
+  } catch (err) {
+    return { id: 'runtime-state', severity: SEVERITY.WARN, status: 'fail', message: `Cannot inspect runtime state: ${err.message}` };
+  }
+}
+
+/** Surface durable ClickUp projection intents awaiting synchronization. */
+export function checkClickUpTracking({ projectDir }) {
+  const pendingDir = join(projectDir, '.chati', 'v2', 'tracking', 'pending-projections');
+  try {
+    const durableIntents = existsSync(pendingDir)
+      ? readdirSync(pendingDir).filter(name => name.endsWith('.json')).length
+      : 0;
+    const outboxPath = join(projectDir, '.chati', 'v2', 'tracking', 'clickup-outbox.json');
+    let outboxPending = 0;
+    if (existsSync(outboxPath)) {
+      const outbox = JSON.parse(readFileSync(outboxPath, 'utf8'));
+      outboxPending = (outbox.projections || []).filter(projection =>
+        ['pending', 'retryable_failure', 'sent_unconfirmed'].includes(projection.delivery_state)
+      ).length;
+    }
+    if (durableIntents === 0 && outboxPending === 0) {
+      return { id: 'clickup-tracking', severity: SEVERITY.WARN, status: 'pass', message: 'No pending ClickUp projections.' };
+    }
+    return {
+      id: 'clickup-tracking', severity: SEVERITY.WARN, status: 'fail',
+      message: `${durableIntents} pending reconstruction intent(s) and ${outboxPending} pending ClickUp delivery projection(s) await synchronization.`,
+      fix: 'Restore ClickUp connectivity. The durable queue can then be replayed without losing local progress.',
+    };
+  } catch (err) {
+    return { id: 'clickup-tracking', severity: SEVERITY.WARN, status: 'fail', message: `Cannot inspect ClickUp projection queue: ${err.message}` };
+  }
+}
+
 /**
  * Node version gate. Framework assumes Node 22+ for modern ESM, fetch,
  * globbing. Earlier versions break test runs and hook spawns.
@@ -342,6 +410,8 @@ export function runDoctor(opts) {
     checkSession({ projectDir: opts.projectDir }),
     checkHooks({ projectDir: opts.projectDir }),
     checkModel({ projectDir: opts.projectDir }),
+    checkRuntimeState({ projectDir: opts.projectDir }),
+    checkClickUpTracking({ projectDir: opts.projectDir }),
     checkNode(),
     checkConstitution({ projectDir: opts.projectDir }),
     checkFailures({ projectDir: opts.projectDir }),

package/src/orchestrator/session-manager.js

@@ -106,6 +106,12 @@ const DEFAULT_SESSION = {
   // context_last_bracket: last computed bracket — telemetry + /chati status.
   active_model: null,
   active_provider: null,
+  // The harness is the CLI/UI currently orchestrating the session. It is not
+  // the provider selected for the routed task.
+  active_harness: null,
+  session_status: 'inactive',
+  current_execution_binding: null,
+  pending_interaction: null,
   context_tokens_used: 0,
   context_window_tokens: null,
   context_last_bracket: null,
@@ -237,8 +243,24 @@ export function migrateSession(session) {
     });
   }
 
+  // Seed additive runtime fields even when the schema version is current.
+  // Patch releases can therefore repair installed v1.2 sessions safely.
+  let seededRuntimeFields = false;
+  const runtimeDefaults = {
+    active_harness: null,
+    session_status: 'inactive',
+    current_execution_binding: null,
+    pending_interaction: null,
+  };
+  for (const [key, value] of Object.entries(runtimeDefaults)) {
+    if (!(key in session)) {
+      session[key] = value;
+      seededRuntimeFields = true;
+    }
+  }
+
   if (session.schema_version === CURRENT_SCHEMA_VERSION) {
-    return { migrated: normalizedLegacySelections, fromVersion: session.schema_version, toVersion: CURRENT_SCHEMA_VERSION };
+    return { migrated: normalizedLegacySelections || seededRuntimeFields, fromVersion: session.schema_version, toVersion: CURRENT_SCHEMA_VERSION };
   }
 
   // v0 (no schema_version) → v1.0 → v1.1 → v1.2
@@ -492,6 +514,67 @@ export function recordModelSelection(projectDir, selection) {
   });
 }
 
+/** Persist an interactive question so another harness resumes it verbatim. */
+export function recordPendingInteraction(projectDir, interaction) {
+  const sessionProjectDir = findSessionProjectDir(projectDir);
+  if (!sessionProjectDir) return { saved: false, error: 'Session file not found in working directory or its parents' };
+  if (!interaction?.agent || !interaction?.question) {
+    return { saved: false, error: 'Pending interaction requires agent and question' };
+  }
+  return mutateSession(sessionProjectDir, (session) => {
+    const previous = session.pending_interaction;
+    const taskId = interaction.taskId || `${interaction.agent}-task`;
+    const binding = {
+      provider: interaction.provider || null,
+      provider_id: interaction.providerId || null,
+      model: interaction.model || null,
+      reasoning_configuration: interaction.reasoningConfiguration || null,
+      catalog_snapshot_ref: interaction.catalogSnapshotRef || null,
+    };
+    const sameRelay = previous?.agent === interaction.agent && previous?.task_id === taskId;
+    const now = interaction.timestamp || new Date().toISOString();
+    session.current_agent = interaction.agent;
+    session.current_execution_binding = binding;
+    session.agents = session.agents || {};
+    session.agents[interaction.agent] = {
+      ...(session.agents[interaction.agent] || {}),
+      status: 'waiting_for_user',
+    };
+    session.pending_interaction = {
+      status: 'waiting_for_user',
+      agent: interaction.agent,
+      task_id: taskId,
+      language: session.language || 'en',
+      question: interaction.question,
+      relay_cycles: sameRelay ? (previous.relay_cycles || 1) + 1 : 1,
+      execution_binding: binding,
+      created_at: sameRelay ? previous.created_at : now,
+      updated_at: now,
+    };
+    return session;
+  });
+}
+
+/** Clear a pending interaction only when the caller owns that relay. */
+export function clearPendingInteraction(projectDir, match = {}) {
+  const sessionProjectDir = findSessionProjectDir(projectDir);
+  if (!sessionProjectDir) return { saved: false, cleared: false, error: 'Session file not found in working directory or its parents' };
+  let cleared = false;
+  const result = mutateSession(sessionProjectDir, (session) => {
+    const pending = session.pending_interaction;
+    if (!pending) return session;
+    if (match.agent && pending.agent !== match.agent) return session;
+    if (match.taskId && pending.task_id !== match.taskId) return session;
+    session.pending_interaction = null;
+    if (session.agents?.[pending.agent]?.status === 'waiting_for_user') {
+      session.agents[pending.agent].status = 'in_progress';
+    }
+    cleared = true;
+    return session;
+  });
+  return { ...result, cleared };
+}
+
 /**
  * Record a mode transition in session history.
  * @param {string} projectDir

package/src/terminal/prompt-builder.js

@@ -392,6 +392,7 @@ function buildSessionSection(config, resolvedModelInfo = {}) {
     `- **Type**: ${project.type || 'greenfield'}`,
     `- **Mode**: ${project.state || 'discover'}`,
     `- **Language**: ${state.language || 'en'} (interaction) / English (artifacts)`,
+    `- **Language Contract**: Every visible interaction, including your first response, preface, progress update, question, error, pause and resumption, MUST use ${state.language || 'en'}.`,
     `- **User Level**: ${state.user_level || 'auto'}`,
     `- **Execution Mode**: ${state.execution_mode || 'autonomous'}`,
     `- **Your Agent**: ${config.agent}`,

package/src/terminal/run-agent.js

@@ -23,6 +23,8 @@ import { getRateLimiter } from './rate-limiter.js';
 import { initCollector, track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
 import { sendEvents } from '../telemetry/sender.js';
 import { getTelemetryConfig, isEnabled as isTelemetryEnabled } from '../telemetry/config.js';
+import { recordPendingInteraction, clearPendingInteraction } from '../orchestrator/session-manager.js';
+import { recordEvent, EventType } from '../intelligence/timeline.js';
 
 // ---------------------------------------------------------------------------
 // CLI argument parsing (no external deps)
@@ -111,6 +113,11 @@ async function main() {
   }
   const readiness = checkProviderReadiness(spawnProvider, { workingDir: projectDir });
   if (!readiness.ready) {
+    const relayState = clearPendingForFailedRelay(projectDir, args);
+    if (!relayState.saved) {
+      outputResult({ status: 'error', code: 'SESSION_WRITE_FAILED', error: relayState.error, cause: readiness.code });
+      process.exit(1);
+    }
     outputResult({ status: 'error', error: readiness.detail, code: readiness.code, provider: spawnProvider });
     process.exit(1);
   }
@@ -154,6 +161,11 @@ async function main() {
       },
     });
   } catch (err) {
+    const relayState = clearPendingForFailedRelay(projectDir, args);
+    if (!relayState.saved) {
+      outputResult({ status: 'error', code: 'SESSION_WRITE_FAILED', error: relayState.error, cause: err.message });
+      process.exit(1);
+    }
     outputError(`Failed to spawn terminal: ${err.message}`);
     process.exit(1);
   }
@@ -213,8 +225,14 @@ async function main() {
 
   // Parse the handoff from stdout
   const parsed = parseAgentOutput(stdout);
+  const recovered = recoverInteractiveHandoff(args.agent, stdout, handle.exitCode);
 
   if (handle.exitCode !== 0 && /not logged in|not authenticated/i.test(providerOutput)) {
+    const relayState = clearPendingForFailedRelay(projectDir, args);
+    if (!relayState.saved) {
+      outputResult({ status: 'error', code: 'SESSION_WRITE_FAILED', error: relayState.error, cause: 'PROVIDER_AUTH_STATE_MISMATCH' });
+      process.exit(1);
+    }
     outputResult({
       status: 'error',
       code: 'PROVIDER_AUTH_STATE_MISMATCH',
@@ -227,6 +245,11 @@ async function main() {
   }
 
   if (parsed.found && parsed.valid) {
+    const persistence = persistInteractiveState(projectDir, args, parsed.handoff, promptResult.model, spawnProvider);
+    if (!persistence.saved) {
+      outputResult({ status: 'error', code: 'SESSION_WRITE_FAILED', error: persistence.error, agent: args.agent });
+      process.exit(1);
+    }
     outputResult({
       status: parsed.handoff.status,
       agent: args.agent,
@@ -238,17 +261,22 @@ async function main() {
       elapsed,
       costEstimate,
     });
-  } else if (recoverInteractiveHandoff(args.agent, stdout, handle.exitCode)) {
+  } else if (recovered) {
     // Interactive discovery models sometimes answer with the user-facing
     // question but omit the machine block. Preserve the exact question while
     // restoring the deterministic relay contract for the parent orchestrator.
+    const persistence = persistInteractiveState(projectDir, args, recovered, promptResult.model, spawnProvider);
+    if (!persistence.saved) {
+      outputResult({ status: 'error', code: 'SESSION_WRITE_FAILED', error: persistence.error, agent: args.agent });
+      process.exit(1);
+    }
     outputResult({
       status: 'needs_input',
       agent: args.agent,
       model: promptResult.model,
       provider: spawnProvider,
       exitCode: handle.exitCode,
-      handoff: recoverInteractiveHandoff(args.agent, stdout, handle.exitCode),
+      handoff: recovered,
       contractRecovery: 'interactive_output_wrapped',
       elapsed,
       costEstimate,
@@ -256,6 +284,11 @@ async function main() {
   } else {
     // A non-interactive agent that omits the handoff violated the execution
     // contract and cannot be treated as successful or partially complete.
+    const relayState = clearPendingForFailedRelay(projectDir, args);
+    if (!relayState.saved) {
+      outputResult({ status: 'error', code: 'SESSION_WRITE_FAILED', error: relayState.error, cause: parsed.found ? 'INVALID_HANDOFF' : 'MISSING_HANDOFF' });
+      process.exit(1);
+    }
     outputResult({
       status: 'error',
       code: parsed.found ? 'INVALID_HANDOFF' : 'MISSING_HANDOFF',
@@ -275,6 +308,31 @@ async function main() {
   process.exit(handle.exitCode === 0 ? 0 : 1);
 }
 
+function persistInteractiveState(projectDir, args, handoff, model, provider) {
+  if (handoff?.status === 'needs_input' && handoff.needs_input_question) {
+    const result = recordPendingInteraction(projectDir, {
+      agent: args.agent,
+      taskId: args['task-id'],
+      question: handoff.needs_input_question,
+      provider,
+      providerId: args['provider-id'] || null,
+      model,
+      reasoningConfiguration: args['reasoning-configuration'] || null,
+      catalogSnapshotRef: args['catalog-snapshot-ref'] || null,
+    });
+    recordEvent(projectDir, EventType.AGENT_WAITING_FOR_INPUT, args.agent, {
+      task_id: args['task-id'],
+    });
+    return result;
+  }
+  return clearPendingInteraction(projectDir, { agent: args.agent, taskId: args['task-id'] });
+}
+
+export function clearPendingForFailedRelay(projectDir, args) {
+  if (!args?.['additional-context']) return { saved: true, cleared: false };
+  return clearPendingInteraction(projectDir, { agent: args.agent, taskId: args['task-id'] });
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/utils/schema-validator.js

@@ -171,6 +171,10 @@ export const SESSION_SCHEMA = {
     language: { type: 'string', required: true, default: 'en' },
     pipeline_phase: { type: 'string', enum: ['discover', 'plan', 'rail', 'release', 'build', 'validate', 'deploy', 'completed'] },
     current_agent: { type: 'string' },
+    active_harness: { type: 'string', enum: ['claude', 'codex', 'grok'] },
+    session_status: { type: 'string', enum: ['inactive', 'active', 'paused', 'completed'] },
+    current_execution_binding: { type: 'object' },
+    pending_interaction: { type: 'object' },
     governance_mode: { type: 'string', enum: ['planning', 'build', 'deploy'] },
     execution_mode: { type: 'string', enum: ['interactive', 'autonomous'] },
     context_bracket: { type: 'string', enum: ['FRESH', 'MODERATE', 'DEPLETED', 'CRITICAL'] },
@@ -191,6 +195,7 @@ export const CONFIG_SCHEMA = {
     language: { type: 'string', default: 'en' },
     ides: { type: 'array' },
     providers: { type: 'object' },
+    integrations: { type: 'object' },
     agent_overrides: { type: 'object' },
   },
 };

package/src/wizard/feedback.js

@@ -13,6 +13,17 @@ export function createSpinner(text) {
   });
 }
 
+/** Run one automatic operation with a spinner that always stops. */
+export async function withSpinner(text, operation, { spinnerFactory = createSpinner } = {}) {
+  const spinner = spinnerFactory(text);
+  spinner.start();
+  try {
+    return await operation();
+  } finally {
+    spinner.stop();
+  }
+}
+
 /**
  * Show installation progress step
  */

package/src/wizard/i18n.js

@@ -106,6 +106,9 @@ const FALLBACK_EN = {
     system_prerequisites_failed: 'System prerequisites not met:',
     fix_prerequisites: 'Fix the issues above and try again.',
     system_check: 'System check:',
+    system_checking: 'Checking system requirements...',
+    catalog_resolving: 'Loading the signed model catalog...',
+    internal_authorizing: 'Verifying access to Internal mode...',
     created_provider_claude: 'Created .claude/commands/ (thin router)',
     created_provider_gemini: 'Created .gemini/commands/ (TOML command)',
     created_provider_codex: 'Created .agents/skills/chati/ (Codex skill)',
@@ -120,6 +123,7 @@ const FALLBACK_EN = {
     license_placeholder: 'CHATI-XXXX-XXXX-XXXX',
     license_skipped: 'Skipped. Run: npx chati-dev activate --key=YOUR-KEY when ready.',
     license_activating: 'Activating license...',
+    license_verifying: 'Verifying saved license...',
     license_activated: 'License activated! Plan: {plan}, {days} day(s) remaining.',
     license_activation_failed: 'Activation failed: {error}',
     license_retry: 'Run: npx chati-dev activate --key=YOUR-KEY to try again.',

package/src/wizard/index.js

@@ -4,7 +4,7 @@ import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { logBanner } from '../utils/logger.js';
 import { WIZARD_BACK, stepLanguage, stepProjectType, stepProviderSelection, stepInstallationMode, stepConfirmation, stepTermsOfUse } from './questions.js';
-import { createSpinner, showStep, showValidation, showQuickStart } from './feedback.js';
+import { createSpinner, withSpinner, showStep, showValidation, showQuickStart } from './feedback.js';
 import { installFramework } from '../installer/core.js';
 import { INSTALLATION_ARTIFACT_PATH, dryRunV2, installV2, reconfigureV2 } from '../installer-v2/index.js';
 import { buildWizardV2InstallationInput } from '../installer-v2/wizard-installation.js';
@@ -48,7 +48,7 @@ export async function runWizard(targetDir, options = {}) {
 
   // Preflight: validate system prerequisites (Node >= 20, npm, Git, Playwright)
   const { runPreflightCheck } = await import('../installer/preflight.js');
-  const preflight = await runPreflightCheck();
+  const preflight = await withSpinner(t('installer.system_checking'), () => runPreflightCheck());
   const preflightFmt = preflight.checks.map(c => {
     const icon = c.status === 'pass' ? '✓' : c.status === 'warn' ? '⚠' : '✗';
     return `  ${icon} ${c.message}`;
@@ -128,9 +128,13 @@ export async function runWizard(targetDir, options = {}) {
         continue;
       }
       selectedProviders = value;
-      catalogResolution ??= options.signedCapabilityCatalogEnvelope
-        ? { source: 'provided-signed', catalog: verifySignedCapabilityCatalog(options.signedCapabilityCatalogEnvelope, { publicKeyPem: options.catalogPublicKeyPem }) }
-        : await resolveCapabilityCatalog({ projectDir: targetDir, catalogUrl: options.catalogUrl, fetchImpl: options.catalogFetch });
+      if (!catalogResolution) {
+        catalogResolution = await withSpinner(t('installer.catalog_resolving'), async () => (
+          options.signedCapabilityCatalogEnvelope
+            ? { source: 'provided-signed', catalog: verifySignedCapabilityCatalog(options.signedCapabilityCatalogEnvelope, { publicKeyPem: options.catalogPublicKeyPem }) }
+            : resolveCapabilityCatalog({ projectDir: targetDir, catalogUrl: options.catalogUrl, fetchImpl: options.catalogFetch })
+        ));
+      }
       // Provider selection defines the permitted routing pool. Model discovery
       // and task-specific choice stay inside the control plane.
       modelSelections = options.modelSelections;
@@ -149,7 +153,10 @@ export async function runWizard(targetDir, options = {}) {
       installationMode = value;
       if (installationMode === 'internal') {
         try {
-          await requireLicenseEntitlement('internal', { validate: options.licenseValidator });
+          await withSpinner(
+            t('installer.internal_authorizing'),
+            () => requireLicenseEntitlement('internal', { validate: options.licenseValidator }),
+          );
         } catch (error) {
           if (options.installationMode !== undefined) throw error;
           p.log.error(error.message);
@@ -328,7 +335,10 @@ async function runLicenseActivationStep() {
   const existingKey = getLicenseKey();
   if (existingKey) {
     try {
-      const status = await ensureCurrentMachineLicense({ key: existingKey });
+      const status = await withSpinner(
+        t('installer.license_verifying'),
+        () => ensureCurrentMachineLicense({ key: existingKey }),
+      );
       if (status.status === 'VALID') return;
       p.log.warn(t('installer.license_saved_invalid', { reason: status.reason || status.status }));
     } catch (error) {