ultra-builder-pro-cli 0.15.0 → 0.16.0

package/docs/WORKFLOW-LIFECYCLE.md

@@ -12,7 +12,7 @@ host and project owner. It is the operational companion to
 | Active host and owner | Product judgment, research content, implementation, review findings, release authorization | Durable workflow status or fabricated evidence digests |
 | Skill | One reusable procedure and its evidence requirements | Project state, static product doctrine, host-specific tool fiction |
 | MCP | IDs, transitions, task contracts, evidence references, output hashes, gate verdicts, next action | Research prose, code generation, memory, or model calls |
-| `.ultra/state.db` | Baseline, change, task, workflow, session, event, incident, projection, and evidence authority | External memory or code-graph payloads |
+| `.ultra/state.db` | Baseline, change, decision, task, workflow, session, event, incident, projection, and evidence authority | Prompts, transcripts, external memory, or code-graph payloads |
 | Generated JSON and Markdown | Read-only projections and durable artifacts | Independent lifecycle authority |
 | Hook | Compact DB-derived lifecycle observation, minimal event metadata, and projection protection | Generic engineering judgment, prompt/transcript capture, parallel lifecycle logs, or arbitrary edit blocking |
 
@@ -22,6 +22,12 @@ inputs, hashes outputs, and derives status. Prompt input cannot override a task'
 public seam, verification command, context references, workflow summary, gate
 verdict, output digest, or next action.
 
+Load-bearing owner choices are normalized through `decision.*`; Prompt prose is not
+durable authority. The host acquires observable facts autonomously, exposes one
+current question, and stops. A workflow cannot advance while a matching decision
+thread is active, waiting for checkpoint confirmation, or carrying a blocking
+deferral.
+
 Every change-bound research, plan, dev, test, review, and deliver run inherits
 the baseline id from the owning change workflow. A Prompt cannot switch that
 authority, and no new stage may start on an archived or cancelled change. Doctor
@@ -135,15 +141,32 @@ output cannot complete without it. When the final required step completes, the
 run becomes `ready`; `workflow.complete` revalidates the entire stage before
 making it `completed`.
 
+### Decision thread and item
+
+```text
+thread: active -> checkpoint_ready -> confirmed
+           ^              |
+           |--------------+  revision/supersession
+
+item: open -> answered | delegated | deferred | superseded
+```
+
+A thread is bound to baseline, change, or workflow authority. A partial unique index
+allows only one `open` item per thread. Resolved items remain immutable history;
+changed evidence or intent uses `decision.supersede` and reopens the checkpoint.
+`decision.checkpoint` first freezes a normalized decision digest, then binds explicit
+owner approval to current artifact digests or a justified standalone no-artifact
+case. It never stores the conversation transcript.
+
 ## 4. Write and verification lifecycle
 
 | Stage | Authoritative writes | Completion verification | Next route |
 |---|---|---|---|
 | `init` | Baseline classification/scope, init run, research run, initialization event, projection job | DB/schema opens, scaffold/projection succeeds; baseline convergence later completes init | `research`, re-adoption, or `change` for an already-ready baseline |
-| `research` | Ordered step evidence, decisions, typed semantic records with source digests, one immutable report per selected step, output paths and SHA-256 digests | Every report has the required structure; semantic kinds/attributes/source anchors are valid and current; full/adoption synthesis binds the current three specifications and distillate; all digests remain current | `baseline.record`, then approval/convergence; bounded change research returns to its change |
+| `research` | Ordered step evidence, decision threads/checkpoints, typed semantic records with source digests, one immutable report per selected step, output paths and SHA-256 digests | Every load-bearing owner decision is confirmed; every report has the required structure; semantic kinds/attributes/source anchors are valid and current; full/adoption synthesis binds the current three specifications and distillate; all digests remain current | `baseline.record`, then approval/convergence; bounded change research returns to its change |
 | baseline convergence | Spec/source/runtime refs, verification results, known failures, unknowns, gaps, branch/HEAD/worktree, approval | Full/adoption research complete; required discovery/product/architecture refs current; revision/worktree exact; blocking gaps resolved or explicitly accepted where allowed | `change` for every initial or daily outcome |
-| `change` | Complete Change Contract, profile/risk rationale, research disposition, intent/delta artifacts, linked change run, initial context snapshot | Blocking decisions resolved; selected change research current; current plan task set matches DB; task-bound context is ready; one next action is derived | selected `research`, then `plan`, or `dev` for an already approved current plan |
-| `plan` | Plan-step evidence, complete change-owned task rows, acceptance coverage matrix, change-bound `.ultra/execution-plan.json`, explicit plan approval | Every Change acceptance id is owned by a task; task trace targets resolve; quick has one task; ownership/dependencies valid; no cycles; exported topology and digest exactly match the current change task set | `dev` for the first dependency-ready task |
+| `change` | Baseline-bound alignment checkpoint, complete Change Contract, profile/risk rationale, research disposition, intent/delta artifacts, linked change run, initial context snapshot | The linked alignment thread is confirmed; selected change research is current; current plan task set matches DB; task-bound context is ready; one next action is derived | selected `research`, then `plan`, or `dev` for an already approved current plan |
+| `plan` | Plan decision checkpoint, plan-step evidence, complete change-owned task rows, acceptance coverage matrix, change-bound `.ultra/execution-plan.json`, explicit plan approval | Blocking planning choices are confirmed; every Change acceptance id is owned by a task; task trace targets resolve; quick has one task; ownership/dependencies valid; no cycles; exported topology and digest exactly match the current change task set | `dev` for the first dependency-ready task |
 | `dev` | Task/session transitions, step evidence, immutable implementation context, completion/review references | Task completed; no live session; task contract unchanged; starting context and review artifacts valid; completion commits remain ancestors of current HEAD | Next task, then aggregate `test` |
 | `test` | Immutable checking context and `.ultra/reports/tests/<workflow-id>.json` | Report change/task set, full HEAD, worktree digest, context digest, commands, public seam, blockers, and all acceptance/regression/integration/static/build/performance/security/recovery dimensions agree; every omission has a not-applicable rationale | `review` when passing, otherwise resume `dev`/`test` |
 | `review` | Immutable review context, `task`/`change`/`plan` mode, worker selection provenance, two specialist axes, coordinated summary | Current diff/HEAD and context match; selected/skipped workers match recorded rationale; both axes complete; P0/P1 and axis verdicts deterministically derive final verdict | `deliver` only from approved `change` mode, otherwise resume implementation |
@@ -157,7 +180,38 @@ a retryable incident; it does not silently convert a failed write into success.
 `task.append_event` accepts only non-authoritative observations. Lifecycle events are
 emitted by their owning DB mutation and never act as a substitute state transition.
 
-## 5. Context and prompt follow-through
+## 5. Human-agent alignment lifecycle
+
+The host first reads `decision.list` and resumes matching authority. It starts a new
+thread only for a new decision cluster. For every current decision it must:
+
+1. inspect repository, runtime, tests, specifications, and primary-source evidence;
+2. resolve evidence-answerable facts without asking the owner;
+3. call `decision.open` for the earliest unresolved owner choice with a recommendation,
+   no more than three credible alternatives, evidence refs, and durable effects;
+4. present that one choice and end the turn;
+5. normalize the next owner response with `decision.resolve`, explicit reversible
+   delegation with `decision.delegate`, or a consequence-bearing deferral with
+   `decision.defer`;
+6. prepare one compact checkpoint, obtain one owner approval, update the affected
+   artifact, and confirm the checkpoint with its current digest. Workflow- and
+   change-bound threads must bind an artifact. If a shared specification will keep
+   evolving, bind a stable per-thread decision projection rather than the mutable
+   working draft.
+
+`ultra-think` owns this interaction protocol. `ultra-research`, `ultra-change`, and
+`ultra-plan` invoke it at their decision boundaries. `ultra-dev`, `ultra-test`,
+`ultra-review`, and `ultra-deliver` stop and route back to the same thread when new
+owner authority is required; they never answer on the owner's behalf. `ultra-status`
+shows only the current decision and exact route, while `ultra-doctor` diagnoses stale
+checkpoint artifacts and recovery state.
+
+When only a bound artifact changes, the same resolved thread is prepared and approved
+again against the current digest; this is checkpoint renewal, not a fabricated decision
+revision. When the owner choice itself changes, supersession preserves the old item and
+opens one replacement.
+
+## 6. Context and prompt follow-through
 
 `change.context` compiles an immutable Context Manifest v2 snapshot. It combines:
 
@@ -185,7 +239,7 @@ different context. File and token budgets warn; they do not block legitimate
 work. Missing authority, required refs, task contracts, outputs, approval, or
 current gate evidence do block.
 
-## 6. Invalidation rules
+## 7. Invalidation rules
 
 - Changing a task contract invalidates contexts and gates that depended on the
   former contract.
@@ -204,22 +258,24 @@ current gate evidence do block.
   their own recorded SHA-256 digests are still authoritative.
 - Generated `tasks.json` and task-context headers are projections. Manual edits
   are overwritten and never repair DB authority.
+- A changed checkpoint artifact digest or superseded decision invalidates the linked
+  decision checkpoint and blocks matching workflow advancement until reconfirmed.
 
-## 7. Entry flows
+## 8. Entry flows
 
 ### New project
 
 ```text
-ultra-init -> full research (17 steps) -> baseline approval
--> initial change + plan -> dev per task -> test -> review -> deliver
+ultra-init -> full research (17 steps with one-decision checkpoints) -> baseline approval
+-> initial change alignment -> plan checkpoint -> dev per task -> test -> review -> deliver
 ```
 
 ### Existing project
 
 ```text
-ultra-init -> brownfield adoption research (17 steps)
+ultra-init -> brownfield adoption research (17 steps with one-decision checkpoints)
 -> characterization and known-red evidence -> gap ledger -> owner approval
--> first selected change -> plan -> dev -> test -> review -> deliver
+-> first selected change alignment -> plan checkpoint -> dev -> test -> review -> deliver
 ```
 
 Adoption records the system that exists. It does not force the owner to recreate
@@ -238,7 +294,7 @@ Migration preserves prior files and rows but never carries old approval forward.
 ### Daily maintenance
 
 ```text
-ultra-status -> ultra-change -> plan if task contracts are absent
+ultra-status -> ultra-change capture/alignment -> plan if task contracts are absent
 -> dev -> test -> review -> deliver -> reconciled baseline
 ```
 
@@ -247,7 +303,27 @@ they do not skip task ownership, executable acceptance, current checking, review
 or baseline reconciliation. Incidents add structured diagnosis and recovery
 evidence rather than bypassing them.
 
-## 8. Recovery and diagnosis
+### Command handoff graph
+
+| Entry | Owns | Normal handoff |
+|---|---|---|
+| `ultra-init` | classification, scope, scaffold, baseline/run creation | `ultra-research`; an already-ready project routes to `ultra-change` |
+| `ultra-research` | evidence acquisition, seventeen-step semantic coverage, research decisions | baseline approval then `ultra-change`; bounded research returns to `ultra-plan` |
+| `ultra-think` | one current owner decision or read-only diagnosis | exact invoking workflow and step after checkpoint confirmation |
+| `ultra-change` | outcome capture, alignment, Change Contract, risk/research routing | selected `ultra-research`, then `ultra-plan`; approved existing plan may route to `ultra-dev` |
+| `ultra-plan` | plan decisions, task contracts, dependencies, approval | first ready task through `ultra-dev` |
+| `ultra-dev` | one task/session vertical slice and focused review | next `ultra-dev` task or aggregate `ultra-test` |
+| `ultra-test` | change-level acceptance and regression gate | `ultra-review` on pass, `ultra-dev` on implementation failure |
+| `ultra-review` | independent specification and engineering verdicts | `ultra-deliver` on approval; otherwise `ultra-dev` or `ultra-test` |
+| `ultra-deliver` | convergence, reconciliation, archive, authorized release evidence | `ultra-status` or the next `ultra-change` |
+| `ultra-status` | read-only authoritative position and one route | whichever exact workflow owns the current step |
+| `ultra-doctor` | read-only diagnosis and authorized mechanical recovery | exact recovered workflow, `ultra-init`, or `ultra-think` |
+
+Every row routes to `ultra-think` when owner authority is missing and to
+`ultra-doctor` when state or installed-runtime authority is unhealthy. Neither route
+creates a parallel workflow or substitutes a Prompt summary for the DB state.
+
+## 9. Recovery and diagnosis
 
 Use `system.doctor` for project authority and `ubp --doctor` for installed host
 assets. Both are read-only unless an explicit project repair command is chosen.

package/mcp-server/lib/change-workflow.cjs

@@ -13,6 +13,7 @@ const providerRefs = require('./provider-refs.cjs');
 const baselines = require('./baseline-workflow.cjs');
 const archiveJournal = require('./archive-journal.cjs');
 const workflows = require('./workflow-state.cjs');
+const decisions = require('./decision-dialogue.cjs');
 const reconciliationSchema = require('../../spec/schemas/baseline-reconciliation.v1.schema.json');
 
 const reconciliationAjv = new Ajv({ allErrors: true, strict: false });
@@ -437,6 +438,7 @@ function writeIntent(file, change) {
     `- Base commit: \`${change.base_commit || 'unavailable'}\``,
     `- Documentation impact: \`${impact.status}\``,
     `- Research disposition: \`${change.research_disposition.status}\``,
+    `- Alignment checkpoint: \`${change.alignment_thread_id || 'not-required'}\``,
     '',
     '## Intent',
     '',
@@ -685,11 +687,46 @@ function createChange(db, input, { rootDir = process.cwd() } = {}) {
       'VALIDATION_ERROR', 'baseline_bypass is not valid while the project baseline is healthy',
     );
   }
+  const alignmentGate = decisions.decisionGate(
+    db, { baseline_id: baselineHealth.baseline?.id || null }, { rootDir },
+  );
+  if (!alignmentGate.ready) {
+    throw new ChangeWorkflowError(
+      'CHANGE_ALIGNMENT_REQUIRED',
+      `resolve and confirm the active baseline alignment before creating a change: ${alignmentGate.blockers.join(', ')}`,
+      { blockers: alignmentGate.blockers, thread_id: alignmentGate.thread?.id || null },
+    );
+  }
   const docsImpact = normalizeDocsImpact(input.docs_impact);
   const providers = normalizeProviderRefs(input.provider_refs);
   const contract = normalizeChangeContract(input.contract);
   const classification = normalizeClassification(input.classification, input.kind);
   const researchDisposition = normalizeResearchDisposition(input.research_disposition, input.kind);
+  let alignmentThread = null;
+  if (input.alignment_thread_id !== undefined) {
+    try {
+      alignmentThread = decisions.assertConfirmedDecisionCheckpoint(
+        db, input.alignment_thread_id, { rootDir, requireArtifact: true },
+      );
+    } catch (error) {
+      throw new ChangeWorkflowError(
+        'CHANGE_ALIGNMENT_REQUIRED',
+        `alignment_thread_id must name a current artifact-bound checkpoint: ${error.message}`,
+      );
+    }
+    if (alignmentThread.change_id) {
+      throw new ChangeWorkflowError(
+        'CHANGE_ALIGNMENT_REQUIRED', `alignment thread already belongs to ${alignmentThread.change_id}`,
+      );
+    }
+    if (!baselineHealth.baseline?.id || alignmentThread.baseline_id !== baselineHealth.baseline.id
+      || alignmentThread.workflow_run_id) {
+      throw new ChangeWorkflowError(
+        'CHANGE_ALIGNMENT_REQUIRED',
+        'change alignment must be bound only to the current baseline before change creation',
+      );
+    }
+  }
   const artifactRoot = path.join('.ultra', 'changes', 'active', input.id);
   const artifactDir = path.resolve(rootDir, artifactRoot);
   if (fs.existsSync(artifactDir)) {
@@ -700,6 +737,7 @@ function createChange(db, input, { rootDir = process.cwd() } = {}) {
     id: input.id, title, kind: input.kind, status: 'active',
     intent, docs_impact: docsImpact, provider_refs: providers, baseline_bypass: baselineBypass,
     contract, classification, research_disposition: researchDisposition,
+    alignment_thread_id: alignmentThread?.id || null,
     base_commit: input.base_commit || gitHead(rootDir), artifact_root: artifactRoot,
     created_at: ts, updated_at: ts,
   };
@@ -709,15 +747,22 @@ function createChange(db, input, { rootDir = process.cwd() } = {}) {
         `INSERT INTO changes
          (id, title, kind, status, intent, docs_impact_json, provider_refs_json,
           baseline_bypass_json, contract_json, classification_json,
-          research_disposition_json, base_commit, artifact_root, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          research_disposition_json, alignment_thread_id, base_commit, artifact_root,
+          created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       ).run(
         row.id, row.title, row.kind, row.status, row.intent, JSON.stringify(row.docs_impact),
         JSON.stringify(row.provider_refs), row.baseline_bypass
           ? JSON.stringify(row.baseline_bypass) : null,
         JSON.stringify(row.contract), JSON.stringify(row.classification),
-        JSON.stringify(row.research_disposition), row.base_commit, row.artifact_root, ts, ts,
+        JSON.stringify(row.research_disposition), row.alignment_thread_id,
+        row.base_commit, row.artifact_root, ts, ts,
       );
+      if (row.alignment_thread_id) {
+        db.prepare(
+          'UPDATE decision_threads SET change_id = ?, updated_at = ? WHERE id = ?',
+        ).run(row.id, ts, row.alignment_thread_id);
+      }
       fs.mkdirSync(artifactDir, { recursive: true });
       const intentPath = path.join(artifactDir, 'intent.md');
       writeIntent(intentPath, row);
@@ -738,7 +783,10 @@ function createChange(db, input, { rootDir = process.cwd() } = {}) {
       }
       ops.appendEventInTx(db, {
         type: 'change_created', change_id: row.id,
-        payload: { kind: row.kind, artifact_root: row.artifact_root },
+        payload: {
+          kind: row.kind, artifact_root: row.artifact_root,
+          alignment_thread_id: row.alignment_thread_id,
+        },
       });
       let workflow = workflows.startWorkflow(db, {
         kind: 'change', baseline_id: baselineHealth.baseline?.id || null,

package/mcp-server/lib/context-spine.cjs

@@ -6,6 +6,7 @@ const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 const baselines = require('./baseline-workflow.cjs');
 const workflows = require('./workflow-state.cjs');
+const decisions = require('./decision-dialogue.cjs');
 const ops = require('./state-ops.cjs');
 
 const ROLES = new Set(['plan', 'implement', 'check', 'review']);
@@ -452,6 +453,38 @@ function workflowNextAction(run) {
   return `Continue ${run.kind} workflow ${run.id} at ${run.current_step}.`;
 }
 
+function summarizeDecision(gate) {
+  if (!gate?.thread) return null;
+  const current = gate.current_decision;
+  return {
+    thread_id: gate.thread.id,
+    status: gate.thread.status,
+    mode: gate.thread.mode,
+    current: current ? {
+      id: current.id,
+      phase: current.phase,
+      question: current.question,
+      why_now: current.why_now,
+      recommendation: current.recommendation,
+      options: current.options,
+      effects: current.effects,
+    } : null,
+  };
+}
+
+function decisionNextAction(gate) {
+  if (gate.blockers?.some((blocker) => blocker.startsWith('DECISION_CHECKPOINT_ARTIFACT_STALE:'))) {
+    return `Reprepare and confirm decision checkpoint ${gate.thread?.id || 'for the active alignment thread'} against the current artifact.`;
+  }
+  if (gate.current_decision) {
+    return `Answer decision ${gate.current_decision.id}: ${gate.current_decision.question}`;
+  }
+  if (gate.thread?.status === 'checkpoint_ready') {
+    return `Confirm decision checkpoint ${gate.thread.id} after reviewing its durable effects.`;
+  }
+  return `Prepare the confirmed decision checkpoint for ${gate.thread?.id || 'the active alignment thread'}.`;
+}
+
 function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
   const baselineHealth = baselines.inspectBaseline(db, { rootDir });
   const change = id
@@ -464,6 +497,23 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
   }
   if (!change) {
     const baseline = baselineHealth.baseline;
+    const decisionGate = decisions.decisionGate(
+      db, { baseline_id: baseline?.id || null }, { rootDir },
+    );
+    if (!decisionGate.ready) {
+      return {
+        change_id: null, task_id: null, role: 'plan', gate: 'alignment', readiness: 'blocked',
+        blockers: [...new Set([...baselineHealth.blockers, ...decisionGate.blockers])],
+        warnings: baselineHealth.warnings,
+        next_action: decisionNextAction(decisionGate), recommended_workflow: 'ultra-think',
+        workflow: null, decision: summarizeDecision(decisionGate),
+        context_manifest_path: null, context_manifest_hash: null, git_head: currentHead(rootDir),
+        baseline: baseline ? {
+          id: baseline.id, mode: baseline.mode, status: baseline.status,
+          repository_revision: baseline.repository_revision,
+        } : null,
+      };
+    }
     if (baselineHealth.status !== 'pass') {
       const activeWorkflow = actionableBaselineWorkflow(db, baseline?.id, rootDir);
       const nextAction = activeWorkflow
@@ -475,7 +525,7 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
         change_id: null, task_id: null, role: 'plan', gate: 'alignment', readiness: 'blocked',
         blockers: baselineHealth.blockers, warnings: baselineHealth.warnings, next_action: nextAction,
         recommended_workflow: activeWorkflow ? `ultra-${activeWorkflow.kind}` : 'ultra-init',
-        workflow: summarizeWorkflow(activeWorkflow), context_manifest_path: null,
+        workflow: summarizeWorkflow(activeWorkflow), decision: null, context_manifest_path: null,
         context_manifest_hash: null, git_head: currentHead(rootDir),
         baseline: baseline ? {
           id: baseline.id, mode: baseline.mode, status: baseline.status,
@@ -487,6 +537,7 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
       change_id: null, task_id: null, role: 'plan', gate: 'alignment', readiness: 'ready',
       next_action: 'Start daily work with ultra-change.', recommended_workflow: 'ultra-change',
       workflow: null,
+      decision: null,
       context_manifest_path: null, context_manifest_hash: null, git_head: currentHead(rootDir),
       blockers: [], warnings: baselineHealth.warnings,
       baseline: {
@@ -527,8 +578,14 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
   );
   const blockers = [];
   const baselineGate = baselineGateForChange(db, change, baselineHealth);
+  const decisionGate = decisions.decisionGate(db, {
+    baseline_id: baselineHealth.baseline?.id || null,
+    change_id: change.id,
+    workflow_run_id: actionableChangeWorkflow(db, change.id, rootDir)?.id || null,
+  }, { rootDir });
   const warnings = [...baselineGate.warnings];
   blockers.push(...baselineGate.blockers);
+  blockers.push(...decisionGate.blockers);
   if (snapshotMissing) blockers.push('CONTEXT_NOT_COMPILED');
   else {
     if (legacyContext) blockers.push('CONTEXT_SNAPSHOT_UPGRADE_REQUIRED');
@@ -554,6 +611,8 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
       change, tasks, task, role: snapshot?.role || 'plan', readiness: 'blocked',
       blockers: baselineGate.blockers,
     });
+  } else if (!decisionGate.ready) {
+    nextAction = decisionNextAction(decisionGate);
   } else if (activeWorkflow?.status === 'blocked') {
     nextAction = workflowNextAction(activeWorkflow);
   } else if (snapshotMissing) {
@@ -583,14 +642,16 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
     task_status: task?.status || null,
     session_id: task?.session_id || null,
     role: snapshot?.role || 'plan',
-    gate: snapshot?.gate || 'alignment',
+    gate: decisionGate.ready ? (snapshot?.gate || 'alignment') : 'alignment',
     readiness,
     blockers,
     warnings: [...new Set(warnings)],
     next_action: nextAction,
     recommended_workflow: baselineGate.blockers.length > 0
       ? (baselineHealth.baseline?.status === 'ready' ? 'ultra-doctor' : 'ultra-init')
-      : activeWorkflow
+      : !decisionGate.ready
+        ? 'ultra-think'
+        : activeWorkflow
         ? `ultra-${activeWorkflow.kind}`
         : recommendedWorkflow(change, task, tasks, readiness),
     context_manifest_path: snapshot?.manifest_path || null,
@@ -602,6 +663,7 @@ function readBreadcrumb(db, { id } = {}, { rootDir = process.cwd() } = {}) {
       repository_revision: baselineHealth.baseline.repository_revision,
     } : null,
     workflow: summarizeWorkflow(activeWorkflow),
+    decision: summarizeDecision(decisionGate),
   };
 }