debaitable 0.0.1

package/dist/main.js

@@ -0,0 +1,2212 @@
+#!/usr/bin/env node
+
+// src/cli/tui-ui/app.ts
+import blessed from "blessed";
+import { chmod, readFile, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/ai/schemas.ts
+import { z } from "zod";
+var LlmRequestSchema = z.object({
+  system: z.string().min(1),
+  prompt: z.string().min(1),
+  schema: z.unknown()
+});
+var LlmResponseSchema = z.object({
+  output: z.unknown(),
+  raw: z.string().min(1),
+  model: z.string().min(1)
+});
+
+// src/core/constants.ts
+var DEFAULT_VISIBILITY = "private";
+var DEFAULT_STATUS = "queued";
+
+// src/core/errors.ts
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+var BadRequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BadRequestError";
+  }
+};
+
+// src/core/roles.ts
+var roleDefinitions = [
+  {
+    key: "strategist",
+    name: "Strategist",
+    focus: "Long-term value and strategic alignment"
+  },
+  {
+    key: "skeptic",
+    name: "Skeptic",
+    focus: "Challenges assumptions and surfaces weaknesses"
+  },
+  {
+    key: "risk_analyst",
+    name: "Risk Analyst",
+    focus: "Failure modes, edge cases, and mitigation"
+  },
+  {
+    key: "execution_planner",
+    name: "Execution Planner",
+    focus: "Steps, dependencies, and timelines"
+  },
+  {
+    key: "cost_roi",
+    name: "Cost / ROI",
+    focus: "Budget constraints and return on investment"
+  }
+];
+
+// src/core/sanitize.ts
+var normalizeText = (value) => value.replace(/\r\n/g, "\n").trim();
+var normalizeList = (values) => values.map(normalizeText).filter((value) => value.length > 0);
+var sanitizeDecisionInput = (input) => ({
+  title: normalizeText(input.title),
+  context: normalizeText(input.context),
+  goals: normalizeList(input.goals),
+  constraints: normalizeList(input.constraints),
+  decisionType: input.decisionType
+});
+
+// src/core/schemas.ts
+import { z as z2 } from "zod";
+var DecisionTypeSchema = z2.enum([
+  "product",
+  "engineering",
+  "hiring",
+  "growth",
+  "general"
+]);
+var DecisionStatusSchema = z2.enum([
+  "queued",
+  "running",
+  "succeeded",
+  "failed"
+]);
+var VisibilitySchema = z2.enum(["private", "unlisted", "public"]);
+var RoleKeySchema = z2.enum([
+  "strategist",
+  "skeptic",
+  "risk_analyst",
+  "execution_planner",
+  "cost_roi"
+]);
+var DecisionInputSchema = z2.object({
+  title: z2.string().min(1),
+  context: z2.string().min(1),
+  goals: z2.array(z2.string().min(1)),
+  constraints: z2.array(z2.string().min(1)),
+  decisionType: DecisionTypeSchema
+});
+var RoleDefinitionSchema = z2.object({
+  key: RoleKeySchema,
+  name: z2.string().min(1),
+  focus: z2.string().min(1)
+});
+var DebateRoundSchema = z2.object({
+  roundIndex: z2.number().int().nonnegative(),
+  roleKey: RoleKeySchema,
+  output: z2.string().min(1)
+});
+var ExecutiveDecisionSchema = z2.object({
+  decision: z2.enum(["go", "iterate", "stop", "yes", "no", "conditional"]),
+  why: z2.array(z2.string().min(1)),
+  topRisks: z2.array(z2.string().min(1)),
+  topActions: z2.array(z2.string().min(1)),
+  stopGoCriteria: z2.string().min(1)
+});
+var DecisionRecordSchema = z2.object({
+  summary: z2.string().min(1),
+  rationale: z2.string().min(1),
+  tradeoffs: z2.array(z2.string().min(1)),
+  risks: z2.array(z2.string().min(1)),
+  actions: z2.array(z2.string().min(1)),
+  confidence: z2.number().min(0).max(1),
+  minorityReport: z2.string().min(1),
+  executiveDecision: ExecutiveDecisionSchema
+});
+var DecisionSchema = z2.object({
+  id: z2.string().min(1),
+  title: z2.string().min(1),
+  context: z2.string().min(1),
+  goals: z2.array(z2.string().min(1)),
+  constraints: z2.array(z2.string().min(1)),
+  decisionType: DecisionTypeSchema,
+  status: DecisionStatusSchema,
+  visibility: VisibilitySchema
+});
+var DecisionRunSchema = z2.object({
+  runId: z2.string().min(1),
+  decisionId: z2.string().min(1),
+  status: DecisionStatusSchema
+});
+
+// src/core/validate.ts
+var parseDecisionRecord = (value) => DecisionRecordSchema.parse(value);
+
+// src/ai/openai-provider.ts
+var DEFAULT_BASE_URL = "https://api.openai.com/v1/responses";
+var isZodSchema = (schema) => Boolean(schema && typeof schema.parse === "function");
+var parseJson = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new BadRequestError("Model output was not valid JSON");
+  }
+};
+var getOutputText = (payload) => {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("OpenAI response payload missing");
+  }
+  const data = payload;
+  if (Array.isArray(data.output_text) && data.output_text.length > 0) {
+    return data.output_text.join("");
+  }
+  if (Array.isArray(data.output)) {
+    const parts = [];
+    for (const item of data.output) {
+      if (item.type !== "message" || !Array.isArray(item.content)) {
+        continue;
+      }
+      for (const content of item.content) {
+        if (content.type === "output_text" && content.text) {
+          parts.push(content.text);
+        }
+      }
+    }
+    if (parts.length > 0) {
+      return parts.join("");
+    }
+  }
+  if (typeof data.text === "string" && data.text.length > 0) {
+    return data.text;
+  }
+  throw new Error("OpenAI response missing output text");
+};
+var createOpenAiProvider = (options = {}) => {
+  const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY is required");
+  }
+  const model = options.model ?? process.env.OPENAI_MODEL ?? "gpt-5";
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  return {
+    async generate(request) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetch(baseUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model,
+            input: [
+              { role: "system", content: request.system },
+              { role: "user", content: request.prompt }
+            ]
+          }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const message = await response.text();
+          throw new Error(`OpenAI request failed: ${response.status} ${message}`);
+        }
+        const payload = await response.json();
+        const text = getOutputText(payload);
+        const json = parseJson(text);
+        const output = isZodSchema(request.schema) ? request.schema.parse(json) : json;
+        return {
+          output,
+          raw: text,
+          model
+        };
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+};
+
+// src/ai/heuristic-provider.ts
+var parseInput = (prompt) => {
+  const marker = "Decision input:\n";
+  const start = prompt.indexOf(marker);
+  if (start < 0) {
+    return null;
+  }
+  const after = prompt.slice(start + marker.length);
+  const end = after.indexOf("\n\n");
+  const jsonText = (end >= 0 ? after.slice(0, end) : after).trim();
+  try {
+    return JSON.parse(jsonText);
+  } catch {
+    return null;
+  }
+};
+var parseRoleKey = (prompt) => {
+  const match = prompt.match(/"roleKey":"([a-z_]+)"/);
+  if (!match) {
+    return "strategist";
+  }
+  return match[1];
+};
+var inferRound = (prompt) => {
+  if (prompt.includes("Task: Provide an independent proposal.")) {
+    return "proposal";
+  }
+  if (prompt.includes("Task: Provide critiques and rebuttals")) {
+    return "critique";
+  }
+  if (prompt.includes("Task: Converge and vote.")) {
+    return "convergence";
+  }
+  return "record";
+};
+var pickVote = (roleKey) => {
+  if (roleKey === "skeptic") {
+    return "conditional";
+  }
+  if (roleKey === "risk_analyst") {
+    return "conditional";
+  }
+  return "support";
+};
+var isBinaryQuestion = (context) => /^(should|is|are|can|could|do|does|did|will|would)\b/i.test(context.trim());
+var toResponse = (output) => ({
+  output,
+  raw: JSON.stringify(output),
+  model: "heuristic-v1"
+});
+var HeuristicDebateProvider = class {
+  async generate(request) {
+    const input = parseInput(request.prompt);
+    const roleKey = parseRoleKey(request.prompt);
+    const round = inferRound(request.prompt);
+    if (!input) {
+      throw new Error("HeuristicDebateProvider: missing decision input in prompt");
+    }
+    if (round === "proposal") {
+      const output2 = {
+        roleKey,
+        summary: `${input.title}: ${roleKey} perspective for ${input.decisionType} analysis.`,
+        recommendation: `Prioritize an evidence-backed approach focused on ${input.goals[0] ?? "the core goal"}.`,
+        rationale: `This balances objective achievement with the key constraint: ${input.constraints[0] ?? "practical limits"}.`,
+        risks: [
+          `Key assumptions may be wrong and weaken ${input.goals[0] ?? "the target outcome"}.`,
+          "Overconfidence can reduce fairness and decision quality."
+        ],
+        assumptions: [
+          "Available evidence is relevant and reasonably reliable.",
+          "Constraints and stakeholder impacts are represented fairly."
+        ],
+        actions: [
+          "Define explicit criteria for a strong vs weak recommendation.",
+          "Test key assumptions against available evidence.",
+          "Document risks and mitigation before finalizing."
+        ]
+      };
+      return toResponse(output2);
+    }
+    if (round === "critique") {
+      const output2 = {
+        roleKey,
+        critiques: [
+          "Current proposals under-specify rollback and failure thresholds.",
+          "Dependencies and ownership boundaries are not explicit enough."
+        ],
+        rebuttals: [
+          "A constrained pilot can validate assumptions before full commitment.",
+          "A staged plan can reduce downside while preserving speed."
+        ],
+        openQuestions: [
+          "What metric threshold triggers expansion versus rollback?",
+          "Which team owns cross-functional coordination and deadline risk?"
+        ]
+      };
+      return toResponse(output2);
+    }
+    if (round === "convergence") {
+      const vote = pickVote(roleKey);
+      const output2 = {
+        roleKey,
+        vote,
+        reasons: [
+          `Recommendation aligns with ${input.goals[0] ?? "the primary objective"}.`,
+          `Plan acknowledges constraint: ${input.constraints[0] ?? "delivery risk"}.`
+        ],
+        conditions: vote === "support" ? [] : [
+          "Set clear stop/continue criteria before rollout.",
+          "Assign accountable owner for risk and dependency tracking."
+        ]
+      };
+      return toResponse(output2);
+    }
+    const output = {
+      summary: `Conclude a defensible recommendation for ${input.title}.`,
+      rationale: "Role debate converges on evidence quality, risk handling, and practical feasibility.",
+      tradeoffs: [
+        "Stronger confidence from stricter evidence thresholds vs faster decision speed with less evidence.",
+        "Broader inclusion of edge cases improves safety but increases analysis complexity."
+      ],
+      risks: [
+        "Biased assumptions can distort conclusions.",
+        "Insufficient evidence quality can produce unreliable recommendations."
+      ],
+      actions: [
+        "Set explicit decision criteria and acceptable uncertainty bounds.",
+        "Validate top assumptions with disconfirming evidence checks.",
+        "Finalize recommendation with documented tradeoffs and risks."
+      ],
+      confidence: 0.68,
+      minorityReport: "Conditional voters requested clearer evidence thresholds and stronger handling of edge cases.",
+      executiveDecision: {
+        decision: isBinaryQuestion(input.context) ? "conditional" : "iterate",
+        why: [
+          "The recommendation aligns with stated goals and constraints.",
+          "Convergence includes conditional support that can be resolved with clearer criteria."
+        ],
+        topRisks: [
+          "Unclear evidence standards can skew the final answer.",
+          "Missing edge-case analysis can create fairness or safety blind spots.",
+          "Weak uncertainty handling can overstate confidence."
+        ],
+        topActions: [
+          "Define clear recommendation criteria before deciding.",
+          "Pressure-test claims against counterarguments and edge cases.",
+          "Record uncertainty bounds and confidence rationale.",
+          "Update recommendation if critical evidence changes.",
+          "Document unresolved questions for follow-up."
+        ],
+        stopGoCriteria: "Choose the positive path only if evidence quality and risk thresholds are met; otherwise choose the safer alternative or refine."
+      }
+    };
+    return toResponse(output);
+  }
+};
+
+// src/jobs/schemas.ts
+import { z as z3 } from "zod";
+var DecisionJobPayloadSchema = z3.object({
+  decisionId: z3.string().min(1),
+  runId: z3.string().min(1)
+});
+
+// src/jobs/memory-queue.ts
+var MemoryDecisionQueue = class {
+  payloads = [];
+  async enqueueDecision(payload) {
+    this.payloads = [...this.payloads, payload];
+  }
+  getPending() {
+    return this.payloads.map((payload) => ({ ...payload }));
+  }
+  clear() {
+    this.payloads = [];
+  }
+};
+
+// src/orchestration/constants.ts
+var PROMPT_VERSION = "2026-02-07";
+var OUTPUT_TEXT_LIMIT = 700;
+
+// src/orchestration/compact.ts
+var compactProposal = (output) => ({
+  rk: output.roleKey,
+  s: output.summary,
+  rec: output.recommendation,
+  rat: output.rationale,
+  r: output.risks,
+  a: output.assumptions,
+  act: output.actions
+});
+var compactCritique = (output) => ({
+  rk: output.roleKey,
+  c: output.critiques,
+  rb: output.rebuttals,
+  q: output.openQuestions
+});
+var compactConvergence = (output) => ({
+  rk: output.roleKey,
+  v: output.vote,
+  rs: output.reasons,
+  c: output.conditions
+});
+var formatCompactProposals = (outputs) => JSON.stringify(outputs.map(compactProposal));
+var formatCompactCritiques = (outputs) => JSON.stringify(outputs.map(compactCritique));
+var formatCompactConvergence = (outputs) => JSON.stringify(outputs.map(compactConvergence));
+
+// src/orchestration/guards.ts
+var assertValidRoles = (roles) => {
+  if (roles.length === 0) {
+    throw new BadRequestError("At least one role is required");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    if (seen.has(role.key)) {
+      throw new BadRequestError(`Duplicate role key: ${role.key}`);
+    }
+    seen.add(role.key);
+  }
+};
+
+// src/orchestration/normalize.ts
+var normalizeText2 = (value, limit = OUTPUT_TEXT_LIMIT) => value.replace(/\s+/g, " ").replace(/\u0000/g, "").trim().slice(0, limit);
+var dedupe = (values) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const key = value.toLowerCase();
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(value);
+    }
+  }
+  return result;
+};
+var normalizeList2 = (values, maxItems, limit = 240) => dedupe(values.map((value) => normalizeText2(value, limit)).filter((value) => value.length > 0)).slice(
+  0,
+  maxItems
+);
+var normalizeProposalOutput = (output) => ({
+  roleKey: output.roleKey,
+  summary: normalizeText2(output.summary, 260),
+  recommendation: normalizeText2(output.recommendation, 260),
+  rationale: normalizeText2(output.rationale, 320),
+  risks: normalizeList2(output.risks, 6),
+  assumptions: normalizeList2(output.assumptions, 6),
+  actions: normalizeList2(output.actions, 8)
+});
+var normalizeCritiqueOutput = (output) => ({
+  roleKey: output.roleKey,
+  critiques: normalizeList2(output.critiques, 8),
+  rebuttals: normalizeList2(output.rebuttals, 8),
+  openQuestions: normalizeList2(output.openQuestions, 8)
+});
+var normalizeConvergenceOutput = (output) => ({
+  roleKey: output.roleKey,
+  vote: output.vote,
+  reasons: normalizeList2(output.reasons, 5),
+  conditions: normalizeList2(output.conditions, 5)
+});
+var normalizeDecisionRecordOutput = (output) => ({
+  summary: normalizeText2(output.summary, 700),
+  rationale: normalizeText2(output.rationale, 850),
+  tradeoffs: normalizeList2(output.tradeoffs, 6),
+  risks: normalizeList2(output.risks, 8),
+  actions: normalizeList2(output.actions, 8),
+  confidence: Math.max(0, Math.min(1, Number(output.confidence.toFixed(2)))),
+  minorityReport: normalizeText2(output.minorityReport, 500),
+  executiveDecision: {
+    decision: output.executiveDecision.decision,
+    why: normalizeList2(output.executiveDecision.why, 3, 220),
+    topRisks: normalizeList2(output.executiveDecision.topRisks, 3, 220),
+    topActions: normalizeList2(output.executiveDecision.topActions, 5, 220),
+    stopGoCriteria: normalizeText2(output.executiveDecision.stopGoCriteria, 300)
+  }
+});
+
+// src/orchestration/quality.ts
+var PLACEHOLDER_EXACT = /* @__PURE__ */ new Set([
+  "final summary",
+  "final rationale",
+  "tradeoff",
+  "risk",
+  "action",
+  "no minority report"
+]);
+var hasPlaceholder = (value) => PLACEHOLDER_EXACT.has(value.trim().toLowerCase());
+var assertListNonEmpty = (label, values, min) => {
+  if (values.length < min) {
+    throw new BadRequestError(`Decision record quality: ${label} requires at least ${min} items`);
+  }
+};
+var assertNoMalformedTokens = (value, field) => {
+  const malformedPatterns = [/\bRun\d+\/\d+\b/, /\btheflag\b/i, /\bRun\d+/];
+  if (malformedPatterns.some((pattern) => pattern.test(value))) {
+    throw new BadRequestError(`Decision record quality: malformed content in ${field}`);
+  }
+};
+var assertValue = (field, value) => {
+  if (!value.trim()) {
+    throw new BadRequestError(`Decision record quality: ${field} cannot be empty`);
+  }
+  if (hasPlaceholder(value)) {
+    throw new BadRequestError(`Decision record quality: ${field} is placeholder text`);
+  }
+  assertNoMalformedTokens(value, field);
+};
+var assertDecisionRecordQuality = (record) => {
+  assertValue("summary", record.summary);
+  assertValue("rationale", record.rationale);
+  assertValue("minorityReport", record.minorityReport);
+  assertValue("executiveDecision.stopGoCriteria", record.executiveDecision.stopGoCriteria);
+  assertListNonEmpty("tradeoffs", record.tradeoffs, 2);
+  assertListNonEmpty("risks", record.risks, 2);
+  assertListNonEmpty("actions", record.actions, 2);
+  assertListNonEmpty("executiveDecision.why", record.executiveDecision.why, 1);
+  assertListNonEmpty("executiveDecision.topRisks", record.executiveDecision.topRisks, 1);
+  assertListNonEmpty("executiveDecision.topActions", record.executiveDecision.topActions, 1);
+  for (const value of record.tradeoffs) {
+    assertValue("tradeoffs", value);
+  }
+  for (const value of record.risks) {
+    assertValue("risks", value);
+  }
+  for (const value of record.actions) {
+    assertValue("actions", value);
+  }
+  for (const value of record.executiveDecision.why) {
+    assertValue("executiveDecision.why", value);
+  }
+  for (const value of record.executiveDecision.topRisks) {
+    assertValue("executiveDecision.topRisks", value);
+  }
+  for (const value of record.executiveDecision.topActions) {
+    assertValue("executiveDecision.topActions", value);
+  }
+};
+
+// src/orchestration/votes.ts
+var tallyVotes = (outputs) => outputs.reduce(
+  (tally, output) => ({
+    ...tally,
+    [output.vote]: tally[output.vote] + 1
+  }),
+  { support: 0, conditional: 0, oppose: 0 }
+);
+var formatVoteTally = (tally) => JSON.stringify(tally, null, 2);
+
+// src/orchestration/prompts.ts
+var formatDecisionInput = (input) => JSON.stringify(
+  {
+    title: input.title,
+    context: input.context,
+    goals: input.goals,
+    constraints: input.constraints,
+    decisionType: input.decisionType
+  },
+  null,
+  2
+);
+var formatProposalList = (outputs) => formatCompactProposals(outputs);
+var formatCritiqueList = (outputs) => formatCompactCritiques(outputs);
+var formatConvergenceList = (outputs) => formatCompactConvergence(outputs);
+var baseInstructions = [
+  `Prompt version: ${PROMPT_VERSION}.`,
+  "Return JSON only.",
+  "Use double quotes for all keys and string values.",
+  "Do not include code fences or commentary.",
+  "Arrays must contain only strings, not objects.",
+  "Keep writing concise and non-repetitive.",
+  "Use plain, direct language with short sentences.",
+  "Avoid unexplained acronyms. If you must use one, define it once.",
+  "Prioritize clear reasoning over buzzwords.",
+  "Keep claims tied to the user's subject. Do not introduce unrelated domains.",
+  "Avoid placeholder text and malformed tokens."
+].join(" ");
+var compactKeyHint = "Compact context keys: rk=roleKey, s=summary, rec=recommendation, rat=rationale, r=risks, a=assumptions, act=actions, c=critiques or conditions, rb=rebuttals, q=openQuestions, v=vote, rs=reasons.";
+var proposalSchemaHint = (roleKey) => [
+  '{"roleKey":"',
+  roleKey,
+  '","summary":"...","recommendation":"...","rationale":"...",',
+  '"risks":["..."],"assumptions":["..."],"actions":["..."]}'
+].join("");
+var critiqueSchemaHint = (roleKey) => [
+  '{"roleKey":"',
+  roleKey,
+  '","critiques":["..."],"rebuttals":["..."],"openQuestions":["..."]}'
+].join("");
+var convergenceSchemaHint = (roleKey) => [
+  '{"roleKey":"',
+  roleKey,
+  '","vote":"support|conditional|oppose","reasons":["..."],',
+  '"conditions":["..."]}'
+].join("");
+var decisionRecordSchemaHint = [
+  '{"summary":"...","rationale":"...","tradeoffs":["..."],',
+  '"risks":["..."],"actions":["..."],"confidence":0.0,',
+  '"minorityReport":"...",',
+  '"executiveDecision":{"decision":"go|iterate|stop|yes|no|conditional","why":["..."],',
+  '"topRisks":["..."],"topActions":["..."],"stopGoCriteria":"..."}}'
+].join("");
+var buildProposalPrompt = (role, input) => ({
+  system: [
+    "You are a decision role in a structured debate.",
+    `Role: ${role.name}.`,
+    `Focus: ${role.focus}.`,
+    baseInstructions
+  ].join(" "),
+  prompt: [
+    "Decision input:",
+    formatDecisionInput(input),
+    "",
+    "Task: Provide an independent proposal.",
+    "Limits: summary <= 260 chars, recommendation <= 260 chars, rationale <= 320 chars, risks/assumptions <= 6 each, actions <= 8.",
+    "Output JSON schema:",
+    proposalSchemaHint(role.key)
+  ].join("\n")
+});
+var buildCritiquePrompt = (role, input, proposals) => ({
+  system: [
+    "You are a decision role in a structured debate.",
+    `Role: ${role.name}.`,
+    `Focus: ${role.focus}.`,
+    baseInstructions
+  ].join(" "),
+  prompt: [
+    "Decision input:",
+    formatDecisionInput(input),
+    "",
+    "Round 1 proposals:",
+    formatProposalList(proposals),
+    compactKeyHint,
+    "",
+    "Task: Provide critiques and rebuttals from your perspective.",
+    "Limits: critiques/rebuttals/openQuestions <= 8 items each, each item <= 240 chars.",
+    "Output JSON schema:",
+    critiqueSchemaHint(role.key)
+  ].join("\n")
+});
+var buildConvergencePrompt = (role, input, proposals, critiques) => ({
+  system: [
+    "You are a decision role in a structured debate.",
+    `Role: ${role.name}.`,
+    `Focus: ${role.focus}.`,
+    baseInstructions
+  ].join(" "),
+  prompt: [
+    "Decision input:",
+    formatDecisionInput(input),
+    "",
+    "Round 1 proposals:",
+    formatProposalList(proposals),
+    compactKeyHint,
+    "",
+    "Round 2 critiques:",
+    formatCritiqueList(critiques),
+    compactKeyHint,
+    "",
+    "Task: Converge and vote.",
+    "Limits: reasons/conditions <= 5 items each, each item <= 240 chars.",
+    "Output JSON schema:",
+    convergenceSchemaHint(role.key)
+  ].join("\n")
+});
+var buildDecisionRecordPrompt = (input, proposals, critiques, convergence) => ({
+  system: [
+    "You are an aggregator that produces a final Decision Record.",
+    baseInstructions
+  ].join(" "),
+  prompt: [
+    "Decision input:",
+    formatDecisionInput(input),
+    "",
+    "Round 1 proposals:",
+    formatProposalList(proposals),
+    compactKeyHint,
+    "",
+    "Round 2 critiques:",
+    formatCritiqueList(critiques),
+    compactKeyHint,
+    "",
+    "Round 3 convergence:",
+    formatConvergenceList(convergence),
+    compactKeyHint,
+    "",
+    "Vote tally:",
+    formatVoteTally(tallyVotes(convergence)),
+    "",
+    "Task: Produce the final Decision Record with rationale, tradeoffs, risks, actions, confidence (0-1), minority report, and executiveDecision.",
+    "Reasoning style: explain the recommendation in a simple chain: evidence -> implications -> decision.",
+    "Relevance rule: stay strictly on the user subject and wording. Do not invent unrelated business mechanics.",
+    "For non-business topics, avoid terms like KPI, SLA, rollout, pilot, canary, funnel, activation unless explicitly present in input.",
+    "Limits: summary <= 420 chars, rationale <= 520 chars, minorityReport <= 360 chars.",
+    "Limits: tradeoffs <= 6, risks <= 8, actions <= 8.",
+    "Executive block limits: why <= 3, topRisks <= 3, topActions <= 5, stopGoCriteria <= 300 chars.",
+    "Use yes/no/conditional for binary or policy questions; use go/iterate/stop for execution/rollout decisions.",
+    "No duplicate list items. Prefer concise bullets over long paragraphs.",
+    "Output JSON schema:",
+    decisionRecordSchemaHint
+  ].join("\n")
+});
+
+// src/orchestration/schemas.ts
+import { z as z4 } from "zod";
+var ProposalOutputSchema = z4.object({
+  roleKey: RoleKeySchema,
+  summary: z4.string().min(1),
+  recommendation: z4.string().min(1),
+  rationale: z4.string().min(1),
+  risks: z4.array(z4.string().min(1)),
+  assumptions: z4.array(z4.string().min(1)),
+  actions: z4.array(z4.string().min(1))
+});
+var CritiqueOutputSchema = z4.object({
+  roleKey: RoleKeySchema,
+  critiques: z4.array(z4.string().min(1)),
+  rebuttals: z4.array(z4.string().min(1)),
+  openQuestions: z4.array(z4.string().min(1))
+});
+var VoteSchema = z4.enum(["support", "conditional", "oppose"]);
+var ConvergenceOutputSchema = z4.object({
+  roleKey: RoleKeySchema,
+  vote: VoteSchema,
+  reasons: z4.array(z4.string().min(1)),
+  conditions: z4.array(z4.string().min(1))
+});
+
+// src/orchestration/serialize.ts
+var serializeProposalOutput = (output) => JSON.stringify({
+  roleKey: output.roleKey,
+  summary: output.summary,
+  recommendation: output.recommendation,
+  rationale: output.rationale,
+  risks: output.risks,
+  assumptions: output.assumptions,
+  actions: output.actions
+});
+var serializeCritiqueOutput = (output) => JSON.stringify({
+  roleKey: output.roleKey,
+  critiques: output.critiques,
+  rebuttals: output.rebuttals,
+  openQuestions: output.openQuestions
+});
+var serializeConvergenceOutput = (output) => JSON.stringify({
+  roleKey: output.roleKey,
+  vote: output.vote,
+  reasons: output.reasons,
+  conditions: output.conditions
+});
+
+// src/orchestration/validate.ts
+var parseProposalOutput = (value) => ProposalOutputSchema.parse(value);
+var parseCritiqueOutput = (value) => CritiqueOutputSchema.parse(value);
+var parseConvergenceOutput = (value) => ConvergenceOutputSchema.parse(value);
+
+// src/orchestration/synthesize.ts
+var dedupe2 = (values) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const next = value.trim();
+    if (!next) {
+      continue;
+    }
+    const key = next.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(next);
+  }
+  return result;
+};
+var take = (values, max) => values.slice(0, max);
+var fallbackSummary = (input) => `Decision on ${input.title} for ${input.decisionType} priorities.`;
+var buildRationale = (convergence, proposals) => {
+  const voteReasons = convergence.flatMap((item) => item.reasons);
+  const proposalRationales = proposals.map((item) => item.rationale);
+  const reasons = take(dedupe2([...voteReasons, ...proposalRationales]), 3);
+  if (reasons.length === 0) {
+    return "Rationale assembled from role recommendations and convergence votes.";
+  }
+  return reasons.join(" ");
+};
+var buildMinorityReport = (convergence, critiques) => {
+  const dissenters = convergence.filter((item) => item.vote !== "support");
+  const dissentReasons = dissenters.flatMap((item) => item.reasons);
+  const conditions = dissenters.flatMap((item) => item.conditions);
+  const openQuestions = critiques.flatMap((item) => item.openQuestions);
+  const lines = take(dedupe2([...dissentReasons, ...conditions, ...openQuestions]), 3);
+  if (lines.length === 0) {
+    return "No substantial minority objections were raised in convergence.";
+  }
+  return lines.join(" ");
+};
+var scoreConfidence = (convergence) => {
+  if (convergence.length === 0) {
+    return 0.4;
+  }
+  const weight = { support: 1, conditional: 0.6, oppose: 0.2 };
+  const total = convergence.reduce((sum, item) => sum + weight[item.vote], 0);
+  const score = total / convergence.length;
+  return Math.max(0, Math.min(1, Number(score.toFixed(2))));
+};
+var isBinaryQuestion2 = (context) => {
+  const normalized = context.trim().toLowerCase();
+  return /^(should|is|are|can|could|do|does|did|will|would)\b/.test(normalized);
+};
+var synthesizeDecisionRecord = (input, proposals, critiques, convergence) => {
+  const tally = tallyVotes(convergence);
+  const recommendationLines = proposals.map((item) => item.recommendation);
+  const summaryCandidates = take(dedupe2(recommendationLines), 2);
+  const summary = summaryCandidates.length > 0 ? summaryCandidates.join(" ") : fallbackSummary(input);
+  const tradeoffs = take(
+    dedupe2([
+      ...critiques.flatMap((item) => item.critiques),
+      `Vote split: support=${tally.support}, conditional=${tally.conditional}, oppose=${tally.oppose}`
+    ]),
+    5
+  );
+  const risks = take(
+    dedupe2([
+      ...proposals.flatMap((item) => item.risks),
+      ...critiques.flatMap((item) => item.openQuestions)
+    ]),
+    5
+  );
+  const actions = take(dedupe2(proposals.flatMap((item) => item.actions)), 6);
+  const binaryQuestion = isBinaryQuestion2(input.context);
+  const executiveDecision = tally.support >= Math.max(tally.conditional, tally.oppose) ? binaryQuestion ? "yes" : "go" : tally.oppose > tally.support ? binaryQuestion ? "no" : "stop" : binaryQuestion ? "conditional" : "iterate";
+  return {
+    summary,
+    rationale: buildRationale(convergence, proposals),
+    tradeoffs: tradeoffs.length > 0 ? tradeoffs : ["Tradeoffs remain between speed of delivery and downside risk."],
+    risks: risks.length > 0 ? risks : ["Risk assumptions require validation with real implementation constraints."],
+    actions: actions.length > 0 ? actions : ["Assign an owner and timeline for the next validation step."],
+    confidence: scoreConfidence(convergence),
+    minorityReport: buildMinorityReport(convergence, critiques),
+    executiveDecision: {
+      decision: executiveDecision,
+      why: take(
+        dedupe2([
+          ...convergence.flatMap((item) => item.reasons),
+          ...proposals.map((item) => item.recommendation)
+        ]),
+        3
+      ),
+      topRisks: take(
+        dedupe2([
+          ...proposals.flatMap((item) => item.risks),
+          ...critiques.flatMap((item) => item.openQuestions)
+        ]),
+        3
+      ),
+      topActions: take(dedupe2(proposals.flatMap((item) => item.actions)), 5),
+      stopGoCriteria: "Choose the positive path only if evidence quality, risk controls, and fairness thresholds are met; otherwise choose the safer alternative or refine the plan."
+    }
+  };
+};
+
+// src/orchestration/run.ts
+var ensureRoleKey = (expected, actual) => {
+  if (expected !== actual) {
+    throw new BadRequestError(
+      `Role key mismatch: expected ${expected}, got ${actual}`
+    );
+  }
+};
+var BUSINESS_JARGON = [
+  "kpi",
+  "sla",
+  "rollout",
+  "pilot",
+  "canary",
+  "funnel",
+  "activation",
+  "sponsor rev",
+  "market share",
+  "go to market"
+];
+var countMatches = (text, terms) => terms.reduce((count, term) => text.includes(term) ? count + 1 : count, 0);
+var isLikelyOffTopic = (input, output) => {
+  if (input.decisionType !== "general") {
+    return false;
+  }
+  const subjectText = `${input.title} ${input.context} ${input.goals.join(" ")} ${input.constraints.join(" ")}`.toLowerCase();
+  const outputText = [
+    output.summary,
+    output.rationale,
+    output.executiveDecision.stopGoCriteria,
+    ...output.executiveDecision.why,
+    ...output.actions
+  ].join(" ").toLowerCase();
+  const outputJargon = countMatches(outputText, BUSINESS_JARGON);
+  const subjectJargon = countMatches(subjectText, BUSINESS_JARGON);
+  return outputJargon >= 2 && subjectJargon === 0;
+};
+var runProposals = async ({ input, roles, provider }) => Promise.all(
+  roles.map(async (role) => {
+    const { system, prompt } = buildProposalPrompt(role, input);
+    const response = await provider.generate({
+      system,
+      prompt,
+      schema: ProposalOutputSchema
+    });
+    const output = normalizeProposalOutput(parseProposalOutput(response.output));
+    ensureRoleKey(role.key, output.roleKey);
+    return { ...response, output };
+  })
+);
+var runCritiques = async ({ input, roles, provider }, proposals) => Promise.all(
+  roles.map(async (role) => {
+    const { system, prompt } = buildCritiquePrompt(role, input, proposals);
+    const response = await provider.generate({
+      system,
+      prompt,
+      schema: CritiqueOutputSchema
+    });
+    const output = normalizeCritiqueOutput(parseCritiqueOutput(response.output));
+    ensureRoleKey(role.key, output.roleKey);
+    return { ...response, output };
+  })
+);
+var runConvergence = async ({ input, roles, provider }, proposals, critiques) => Promise.all(
+  roles.map(async (role) => {
+    const { system, prompt } = buildConvergencePrompt(
+      role,
+      input,
+      proposals,
+      critiques
+    );
+    const response = await provider.generate({
+      system,
+      prompt,
+      schema: ConvergenceOutputSchema
+    });
+    const output = normalizeConvergenceOutput(
+      parseConvergenceOutput(response.output)
+    );
+    ensureRoleKey(role.key, output.roleKey);
+    return { ...response, output };
+  })
+);
+var runDecisionRecord = async (provider, input, proposals, critiques, convergence) => {
+  const fallback = normalizeDecisionRecordOutput(
+    synthesizeDecisionRecord(input, proposals, critiques, convergence)
+  );
+  assertDecisionRecordQuality(fallback);
+  try {
+    const { system, prompt } = buildDecisionRecordPrompt(
+      input,
+      proposals,
+      critiques,
+      convergence
+    );
+    const response = await provider.generate({
+      system,
+      prompt,
+      schema: DecisionRecordSchema
+    });
+    const output = normalizeDecisionRecordOutput(
+      parseDecisionRecord(response.output)
+    );
+    assertDecisionRecordQuality(output);
+    if (isLikelyOffTopic(input, output)) {
+      throw new BadRequestError("Decision record relevance: output drifted from the input subject");
+    }
+    return { ...response, output };
+  } catch {
+    return {
+      output: fallback,
+      raw: JSON.stringify(fallback),
+      model: "deterministic-synth"
+    };
+  }
+};
+var buildDebateRounds = (proposals, critiques, convergence) => {
+  const proposalRounds = proposals.map((proposal) => ({
+    roundIndex: 1,
+    roleKey: proposal.output.roleKey,
+    output: serializeProposalOutput(proposal.output)
+  }));
+  const critiqueRounds = critiques.map((critique) => ({
+    roundIndex: 2,
+    roleKey: critique.output.roleKey,
+    output: serializeCritiqueOutput(critique.output)
+  }));
+  const convergenceRounds = convergence.map((converged) => ({
+    roundIndex: 3,
+    roleKey: converged.output.roleKey,
+    output: serializeConvergenceOutput(converged.output)
+  }));
+  return [...proposalRounds, ...critiqueRounds, ...convergenceRounds];
+};
+var runDebate = async ({
+  input,
+  roles,
+  provider
+}) => {
+  assertValidRoles(roles);
+  const sanitizedInput = sanitizeDecisionInput(input);
+  const proposals = await runProposals({
+    input: sanitizedInput,
+    roles,
+    provider
+  });
+  const proposalOutputs = proposals.map((proposal) => proposal.output);
+  const critiques = await runCritiques(
+    { input: sanitizedInput, roles, provider },
+    proposalOutputs
+  );
+  const critiqueOutputs = critiques.map((critique) => critique.output);
+  const convergence = await runConvergence(
+    { input: sanitizedInput, roles, provider },
+    proposalOutputs,
+    critiqueOutputs
+  );
+  const convergenceOutputs = convergence.map((result) => result.output);
+  const decisionRecord = await runDecisionRecord(
+    provider,
+    sanitizedInput,
+    proposalOutputs,
+    critiqueOutputs,
+    convergenceOutputs
+  );
+  const rounds = buildDebateRounds(proposals, critiques, convergence);
+  return {
+    input: sanitizedInput,
+    proposals,
+    critiques,
+    convergence,
+    decisionRecord,
+    rounds
+  };
+};
+
+// src/jobs/run-decision.ts
+var toDecisionInput = (decision) => ({
+  title: decision.title,
+  context: decision.context,
+  goals: decision.goals,
+  constraints: decision.constraints,
+  decisionType: decision.decisionType
+});
+var runDecisionJob = async (payload, context) => {
+  const decision = await context.store.getDecision(payload.decisionId);
+  if (!decision) {
+    throw new NotFoundError(`Decision not found: ${payload.decisionId}`);
+  }
+  await context.store.saveDecisionRun({
+    runId: payload.runId,
+    decisionId: decision.id,
+    status: "running"
+  });
+  await context.store.updateDecision(decision.id, {
+    status: "running"
+  });
+  try {
+    const run = await runDebate({
+      input: toDecisionInput(decision),
+      roles: context.roles,
+      provider: context.provider
+    });
+    await context.store.saveDebateRounds(decision.id, run.rounds);
+    await context.store.saveDecisionRecord(decision.id, run.decisionRecord.output);
+    await context.store.saveDecisionRun({
+      runId: payload.runId,
+      decisionId: decision.id,
+      status: "succeeded"
+    });
+    await context.store.updateDecision(decision.id, {
+      status: "succeeded"
+    });
+  } catch (error) {
+    await context.store.saveDecisionRun({
+      runId: payload.runId,
+      decisionId: decision.id,
+      status: "failed"
+    });
+    await context.store.updateDecision(decision.id, {
+      status: "failed"
+    });
+    throw error;
+  }
+};
+
+// src/persistence/memory-store.ts
+var cloneDecision = (decision) => ({
+  ...decision,
+  goals: [...decision.goals],
+  constraints: [...decision.constraints]
+});
+var cloneRounds = (rounds) => rounds.map((round) => ({ ...round }));
+var cloneRun = (run) => ({ ...run });
+var MemoryDecisionStore = class {
+  state;
+  constructor() {
+    this.state = {
+      decisions: /* @__PURE__ */ new Map(),
+      records: /* @__PURE__ */ new Map(),
+      rounds: /* @__PURE__ */ new Map(),
+      runs: /* @__PURE__ */ new Map(),
+      runsByDecision: /* @__PURE__ */ new Map(),
+      counter: 0
+    };
+  }
+  async createDecision(input) {
+    const id = this.nextId();
+    const decision = {
+      id,
+      title: input.title,
+      context: input.context,
+      goals: [...input.goals],
+      constraints: [...input.constraints],
+      decisionType: input.decisionType,
+      status: DEFAULT_STATUS,
+      visibility: input.visibility ?? DEFAULT_VISIBILITY
+    };
+    this.state.decisions.set(id, decision);
+    return cloneDecision(decision);
+  }
+  async updateDecision(id, update) {
+    const current = this.state.decisions.get(id);
+    if (!current) {
+      throw new NotFoundError(`Decision not found: ${id}`);
+    }
+    const next = {
+      ...current,
+      status: update.status ?? current.status,
+      visibility: update.visibility ?? current.visibility
+    };
+    this.state.decisions.set(id, next);
+    return cloneDecision(next);
+  }
+  async saveDecisionRecord(id, record) {
+    if (!this.state.decisions.has(id)) {
+      throw new NotFoundError(`Decision not found: ${id}`);
+    }
+    this.state.records.set(id, { ...record });
+  }
+  async saveDebateRounds(id, rounds) {
+    if (!this.state.decisions.has(id)) {
+      throw new NotFoundError(`Decision not found: ${id}`);
+    }
+    this.state.rounds.set(id, cloneRounds(rounds));
+  }
+  async getDecision(id) {
+    const decision = this.state.decisions.get(id);
+    return decision ? cloneDecision(decision) : null;
+  }
+  async getDecisionRecord(id) {
+    const record = this.state.records.get(id);
+    return record ? { ...record } : null;
+  }
+  async getDebateRounds(id) {
+    return cloneRounds(this.state.rounds.get(id) ?? []);
+  }
+  async saveDecisionRun(run) {
+    if (!this.state.decisions.has(run.decisionId)) {
+      throw new NotFoundError(`Decision not found: ${run.decisionId}`);
+    }
+    this.state.runs.set(run.runId, { ...run });
+    const existing = this.state.runsByDecision.get(run.decisionId) ?? [];
+    const next = existing.includes(run.runId) ? existing : [...existing, run.runId];
+    this.state.runsByDecision.set(run.decisionId, next);
+  }
+  async getDecisionRun(runId) {
+    const run = this.state.runs.get(runId);
+    return run ? cloneRun(run) : null;
+  }
+  async listDecisionRuns(decisionId) {
+    const runIds = this.state.runsByDecision.get(decisionId) ?? [];
+    return runIds.map((runId) => this.state.runs.get(runId)).filter((run) => Boolean(run)).map(cloneRun);
+  }
+  nextId() {
+    this.state.counter += 1;
+    return `decision_${this.state.counter}`;
+  }
+};
+
+// src/cli/tui-ui/input-parser.ts
+var defaultGoal = "Produce a clear, defensible answer with transparent tradeoffs.";
+var defaultConstraint = "Use balanced reasoning and explicit assumptions.";
+var parseList = (raw) => raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+var normalizePhrase = (value) => value.replace(/[?!.,;:]+$/g, "").replace(/\s+/g, " ").trim();
+var toWords = (value) => value.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((part) => part.length > 0);
+var inferDecisionType = (value) => {
+  const words = new Set(toWords(value));
+  if (words.has("engineer") || words.has("engineering") || words.has("infra") || words.has("architecture") || words.has("technical")) {
+    return "engineering";
+  }
+  if (words.has("hire") || words.has("hiring") || words.has("recruit") || words.has("candidate") || words.has("team")) {
+    return "hiring";
+  }
+  if (words.has("growth") || words.has("acquisition") || words.has("marketing") || words.has("funnel") || words.has("activation")) {
+    return "growth";
+  }
+  if (words.has("product") || words.has("roadmap") || words.has("feature") || words.has("launch") || words.has("ux")) {
+    return "product";
+  }
+  return "general";
+};
+var buildTitleFromSituation = (value) => {
+  const firstSentence = value.split(/[.!?]/)[0]?.trim() ?? value.trim();
+  if (firstSentence.length <= 90) {
+    return firstSentence;
+  }
+  return `${firstSentence.slice(0, 87).trim()}...`;
+};
+var extractQuotedList = (source, keyword) => {
+  const regex = new RegExp(`${keyword}\\s*:\\s*([^.;\\n]+)`, "i");
+  const match = source.match(regex);
+  if (!match) {
+    return [];
+  }
+  return parseList(match[1]).map(normalizePhrase).filter((part) => part.length > 0);
+};
+var inferConstraints = (value) => {
+  const explicit = extractQuotedList(value, "constraints?");
+  if (explicit.length > 0) {
+    return explicit;
+  }
+  const fragments = [];
+  const patterns = [
+    /within\s+[^,.;]+/gi,
+    /by\s+[^,.;]+/gi,
+    /no\s+[^,.;]+/gi,
+    /without\s+[^,.;]+/gi,
+    /must\s+[^,.;]+/gi,
+    /cannot\s+[^,.;]+/gi,
+    /can\'t\s+[^,.;]+/gi
+  ];
+  for (const pattern of patterns) {
+    const matches = value.match(pattern) ?? [];
+    for (const match of matches) {
+      const next = normalizePhrase(match);
+      if (next.length > 0) {
+        fragments.push(next);
+      }
+    }
+  }
+  if (fragments.length > 0) {
+    const unique = [...new Set(fragments.map((item) => item.toLowerCase()))];
+    const compact = unique.filter(
+      (item) => !unique.some((other) => other !== item && item.includes(other))
+    );
+    return compact.map((item) => item[0].toUpperCase() + item.slice(1)).slice(0, 3);
+  }
+  const bits = value.split(/[.;]/).map((part) => part.trim()).filter((part) => part.length > 0);
+  const keywords = ["within", "by", "deadline", "budget", "no ", "cannot", "can't", "must"];
+  const inferred = bits.filter(
+    (part) => keywords.some((keyword) => part.toLowerCase().includes(keyword))
+  );
+  return inferred.length > 0 ? inferred.map(normalizePhrase).filter((part) => part.length > 0).slice(0, 3) : [defaultConstraint];
+};
+var inferGoals = (value) => {
+  const explicit = extractQuotedList(value, "goals?");
+  if (explicit.length > 0) {
+    return explicit;
+  }
+  const lower = value.toLowerCase();
+  const markers = [" to ", " so that ", " in order to "];
+  for (const marker of markers) {
+    const index = lower.indexOf(marker);
+    if (index >= 0) {
+      const goal = value.slice(index + marker.length).replace(/\b(within|by|with no|without|no|must|cannot|can't)\b[\s\S]*$/i, "");
+      const normalizedGoal = normalizePhrase(goal);
+      if (normalizedGoal.length > 0) {
+        return [normalizedGoal.slice(0, 180)];
+      }
+    }
+  }
+  return [defaultGoal];
+};
+var buildInputFromSituation = (situation) => ({
+  title: buildTitleFromSituation(situation),
+  context: situation.trim(),
+  goals: inferGoals(situation),
+  constraints: inferConstraints(situation),
+  decisionType: inferDecisionType(situation)
+});
+
+// src/cli/tui-ui/runner.ts
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+
+// src/api/handlers.ts
+import { z as z6 } from "zod";
+
+// src/api/schemas.ts
+import { z as z5 } from "zod";
+var CreateDecisionRequestSchema = z5.object({
+  input: DecisionInputSchema,
+  visibility: VisibilitySchema.optional()
+});
+var CreateDecisionResponseSchema = z5.object({
+  decisionId: z5.string().min(1),
+  runId: z5.string().min(1),
+  status: DecisionStatusSchema
+});
+var GetDecisionResponseSchema = z5.object({
+  decision: DecisionSchema,
+  record: DecisionRecordSchema.nullable(),
+  rounds: z5.array(DebateRoundSchema),
+  runs: z5.array(DecisionRunSchema)
+});
+var ErrorResponseSchema = z5.object({
+  error: z5.string().min(1),
+  code: z5.enum(["bad_request", "not_found", "internal_error"])
+});
+
+// src/api/validate.ts
+var parseCreateDecisionRequest = (value) => CreateDecisionRequestSchema.parse(value);
+
+// src/api/service.ts
+var createDecision = async (request, context) => {
+  const parsed = parseCreateDecisionRequest(request);
+  const input = sanitizeDecisionInput(parsed.input);
+  const decision = await context.store.createDecision({
+    ...input,
+    visibility: parsed.visibility ?? DEFAULT_VISIBILITY
+  });
+  const runId = context.generateRunId();
+  await context.store.saveDecisionRun({
+    runId,
+    decisionId: decision.id,
+    status: "queued"
+  });
+  await context.queue.enqueueDecision({
+    decisionId: decision.id,
+    runId
+  });
+  return {
+    decisionId: decision.id,
+    runId,
+    status: decision.status
+  };
+};
+var getDecision = async (decisionId, context) => {
+  const decision = await context.store.getDecision(decisionId);
+  if (!decision) {
+    throw new NotFoundError(`Decision not found: ${decisionId}`);
+  }
+  const record = await context.store.getDecisionRecord(decisionId);
+  const rounds = await context.store.getDebateRounds(decisionId);
+  const runs = await context.store.listDecisionRuns(decisionId);
+  return {
+    decision,
+    record,
+    rounds,
+    runs
+  };
+};
+
+// src/cli/tui-ui/runner.ts
+var parseRoundOutput = (raw) => {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+};
+var saveArtifact = async (input, decisionId, result) => {
+  const artifact = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    decisionId,
+    input,
+    status: result.decision.status,
+    rounds: result.rounds.map((round) => ({
+      roundIndex: round.roundIndex,
+      roleKey: round.roleKey,
+      output: parseRoundOutput(round.output)
+    })),
+    record: result.record,
+    runs: result.runs
+  };
+  const dir = path.resolve(process.cwd(), "artifacts");
+  await mkdir(dir, { recursive: true });
+  const stamp = artifact.generatedAt.replace(/[:.]/g, "-");
+  const filePath = path.join(dir, `${decisionId}-${stamp}.json`);
+  await writeFile(filePath, JSON.stringify(artifact, null, 2), "utf8");
+  return filePath;
+};
+var runDecisionPipeline = async (input, session, onProgress) => {
+  const apiContext = {
+    store: session.store,
+    queue: session.queue,
+    generateRunId: () => {
+      session.runCounter += 1;
+      return `run_${session.runCounter}`;
+    }
+  };
+  onProgress("Creating decision...");
+  const created = await createDecision({ input }, apiContext);
+  const pending = session.queue.getPending();
+  session.queue.clear();
+  onProgress(`Queued ${pending.length} job(s).`);
+  for (const payload of pending) {
+    onProgress(`Running ${payload.runId}...`);
+    await runDecisionJob(payload, {
+      provider: session.provider,
+      store: session.store,
+      roles: session.roles
+    });
+    onProgress(`${payload.runId} completed.`);
+  }
+  const result = await getDecision(created.decisionId, apiContext);
+  const artifactPath = await saveArtifact(input, created.decisionId, result);
+  onProgress(`Artifact saved: ${artifactPath}`);
+  return {
+    decisionId: created.decisionId,
+    result,
+    artifactPath
+  };
+};
+
+// src/cli/tui-ui/state.ts
+var createInitialState = (mode) => ({
+  mode,
+  runState: "idle",
+  showAudit: false,
+  showDetails: false,
+  logs: ["Ready. Type a prompt and press Enter to run"],
+  currentInput: null,
+  currentResult: null,
+  history: [],
+  selectedHistoryIndex: 0,
+  statusMessage: "Ready",
+  commandHint: "Enter run  i focus prompt  e guided edit  a audit  d details  m model  r rerun  [ ] history  tab focus  q quit"
+});
+
+// src/cli/tui-ui/app.ts
+var BRAND_ASCII = [
+  " ____  _____ ____    _    ___ _____  _    ____  _     _____ ",
+  "|  _ \\| ____| __ )  / \\  |_ _|_   _|/ \\  | __ )| |   | ____|",
+  "| | | |  _| |  _ \\ / _ \\  | |  | | / _ \\ |  _ \\| |   |  _|  ",
+  "| |_| | |___| |_) / ___ \\ | |  | |/ ___ \\| |_) | |___| |___ ",
+  "|____/|_____|____/_/   \\_\\___| |_/_/   \\_\\____/|_____|_____|"
+].join("\n");
+var THEME = {
+  bg: "#16142a",
+  panelBg: "#211a3f",
+  panelBorder: "#8a73ff",
+  focusBorder: "#ffffff",
+  brandFg: "#b8a7ff",
+  primaryText: "#efeaff",
+  secondaryText: "#cfc5f4",
+  selectedBg: "#ffffff",
+  selectedFg: "#18142a"
+};
+var trimForLine = (value, max = 80) => value.length <= max ? value : `${value.slice(0, max - 3)}...`;
+var CONTEXT_TIP = "Include context, goals, constraints, budget, timeline, and must-not-fail risks.";
+var ENV_FILE_PATH = path2.resolve(process.cwd(), ".env");
+var SESSION_FILE_PATH = path2.resolve(process.cwd(), ".debaitable-session.json");
+var upsertEnvLine = (source, key, value) => {
+  const safeValue = value.replace(/\r?\n/g, "").trim();
+  const lines = source.length > 0 ? source.split(/\r?\n/) : [];
+  const prefix = `${key}=`;
+  let found = false;
+  const updated = lines.map((line) => {
+    if (line.startsWith(prefix)) {
+      found = true;
+      return `${prefix}${safeValue}`;
+    }
+    return line;
+  });
+  if (!found) {
+    updated.push(`${prefix}${safeValue}`);
+  }
+  return `${updated.filter((line) => line.length > 0).join("\n")}
+`;
+};
+var hydrateEnvFromFile = async () => {
+  let source = "";
+  try {
+    source = await readFile(ENV_FILE_PATH, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+    return;
+  }
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const equalIndex = line.indexOf("=");
+    if (equalIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, equalIndex).trim();
+    let value = line.slice(equalIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+};
+var persistOpenAiEnv = async (apiKey) => {
+  let current = "";
+  try {
+    current = await readFile(ENV_FILE_PATH, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  let next = upsertEnvLine(current, "OPENAI_API_KEY", apiKey);
+  next = upsertEnvLine(next, "OPENAI_MODEL", process.env.OPENAI_MODEL?.trim() || "gpt-5");
+  await writeFile2(ENV_FILE_PATH, next, "utf8");
+  await chmod(ENV_FILE_PATH, 384);
+};
+var loadPersistedHistory = async () => {
+  let source = "";
+  try {
+    source = await readFile(SESSION_FILE_PATH, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(source);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed;
+  } catch {
+    return [];
+  }
+};
+var persistHistory = async (history) => {
+  await writeFile2(SESSION_FILE_PATH, `${JSON.stringify(history, null, 2)}
+`, "utf8");
+};
+var ensureOpenAiApiKey = async () => {
+  if (process.env.OPENAI_API_KEY?.trim()) {
+    return;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return;
+  }
+  const apiKey = (await promptHiddenInput(
+    "OPENAI_API_KEY not found. Paste key to enable OpenAI mode (or press Enter to skip): "
+  )).trim();
+  if (!apiKey) {
+    return;
+  }
+  process.env.OPENAI_API_KEY = apiKey;
+  process.env.OPENAI_MODEL = process.env.OPENAI_MODEL?.trim() || "gpt-5";
+  await persistOpenAiEnv(apiKey);
+  console.log("Saved OPENAI_API_KEY to .env");
+};
+var promptHiddenInput = async (label) => {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return "";
+  }
+  process.stdout.write(label);
+  const stdin = process.stdin;
+  const wasRaw = stdin.isRaw;
+  stdin.setEncoding("utf8");
+  if (typeof stdin.setRawMode === "function") {
+    stdin.setRawMode(true);
+  }
+  stdin.resume();
+  return new Promise((resolve, reject) => {
+    let value = "";
+    const cleanup = () => {
+      stdin.off("data", onData);
+      if (typeof stdin.setRawMode === "function") {
+        stdin.setRawMode(Boolean(wasRaw));
+      }
+      stdin.pause();
+      process.stdout.write("\n");
+    };
+    const onData = (chunk) => {
+      if (chunk === "") {
+        cleanup();
+        reject(new Error("Input cancelled"));
+        return;
+      }
+      if (chunk === "\r" || chunk === "\n") {
+        cleanup();
+        resolve(value);
+        return;
+      }
+      if (chunk === "\x7F" || chunk === "\b") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+        }
+        return;
+      }
+      if (chunk.startsWith("\x1B")) {
+        return;
+      }
+      value += chunk;
+      process.stdout.write("*");
+    };
+    stdin.on("data", onData);
+  });
+};
+var renderResult = (state) => {
+  if (!state.currentResult?.record) {
+    return "No result yet. Run a decision to see output.";
+  }
+  const record = state.currentResult.record;
+  const lines = [];
+  lines.push("{bold}Final Decision{/bold}");
+  lines.push(`Decision: ${record.executiveDecision.decision.toUpperCase()}`);
+  lines.push(`Confidence: ${record.confidence}`);
+  lines.push(`Summary: ${record.summary}`);
+  lines.push("");
+  lines.push(`Decision Criteria: ${record.executiveDecision.stopGoCriteria}`);
+  lines.push("Reasoning:");
+  let reasoningIndex = 1;
+  for (const item of record.executiveDecision.why) {
+    lines.push(`${reasoningIndex}. ${item}`);
+    reasoningIndex += 1;
+  }
+  lines.push("Top Actions:");
+  for (const item of record.executiveDecision.topActions.slice(0, 4)) {
+    lines.push(`- ${item}`);
+  }
+  if (state.showDetails) {
+    lines.push("");
+    lines.push("{bold}Details{/bold}");
+    lines.push(`Rationale: ${record.rationale}`);
+    lines.push("Top Risks:");
+    for (const item of record.executiveDecision.topRisks) {
+      lines.push(`- ${item}`);
+    }
+    lines.push("Tradeoffs:");
+    for (const item of record.tradeoffs) {
+      lines.push(`- ${item}`);
+    }
+    lines.push("Risks:");
+    for (const item of record.risks) {
+      lines.push(`- ${item}`);
+    }
+    lines.push("Actions:");
+    for (const item of record.actions) {
+      lines.push(`- ${item}`);
+    }
+    lines.push(`Minority: ${record.minorityReport}`);
+  }
+  if (state.showAudit) {
+    lines.push("");
+    lines.push("{bold}Audit Timeline{/bold}");
+    for (const round of state.currentResult.rounds) {
+      lines.push(`- Round ${round.roundIndex} | ${round.roleKey}`);
+    }
+  } else {
+    lines.push("{gray-fg}[a] Show audit timeline{/gray-fg}");
+  }
+  return lines.join("\n");
+};
+var renderHistoryLabel = (item) => `${item.decision.toUpperCase()} | ${trimForLine(item.title, 40)}`;
+var DecisionTuiApp = class {
+  screen;
+  inputBox;
+  tipBox;
+  outputBox;
+  historyBox;
+  helpModal;
+  footer;
+  loadingTimer = null;
+  loadingFrame = 0;
+  suppressFocusHighlight = false;
+  state;
+  session;
+  constructor(history) {
+    const defaultMode = process.env.OPENAI_API_KEY ? "openai" : "heuristic";
+    this.state = createInitialState(defaultMode);
+    this.state.history = history;
+    this.session = {
+      store: new MemoryDecisionStore(),
+      queue: new MemoryDecisionQueue(),
+      provider: this.makeProvider(defaultMode),
+      roles: roleDefinitions,
+      runCounter: 0
+    };
+    this.screen = blessed.screen({
+      smartCSR: true,
+      title: "DebAItable TUI",
+      dockBorders: true,
+      fullUnicode: true
+    });
+    blessed.box({
+      parent: this.screen,
+      top: 0,
+      left: 0,
+      width: "100%",
+      height: 7,
+      tags: true,
+      style: { fg: THEME.brandFg, bg: THEME.panelBg },
+      content: `${BRAND_ASCII}
+Make specialized, trained LLMs debate to achieve a refined consensus.`
+    });
+    this.inputBox = blessed.textarea({
+      parent: this.screen,
+      top: 7,
+      left: 0,
+      width: "34%",
+      height: 6,
+      inputOnFocus: true,
+      keys: true,
+      mouse: true,
+      label: " Prompt ",
+      border: "line",
+      style: { border: { fg: THEME.panelBorder }, fg: THEME.primaryText, bg: THEME.bg },
+      value: "",
+      scrollable: true,
+      alwaysScroll: true,
+      scrollbar: { ch: " " },
+      wrap: true
+    });
+    this.inputBox.key(["enter"], () => {
+      void this.runCurrentInput();
+      return false;
+    });
+    this.tipBox = blessed.box({
+      parent: this.screen,
+      top: 13,
+      left: 0,
+      width: "34%",
+      height: 4,
+      label: " Context Tip ",
+      tags: true,
+      border: "line",
+      style: { border: { fg: THEME.panelBorder }, fg: THEME.primaryText, bg: THEME.bg },
+      content: CONTEXT_TIP
+    });
+    this.historyBox = blessed.list({
+      parent: this.screen,
+      top: 17,
+      left: 0,
+      width: "34%",
+      bottom: 5,
+      label: " Session History ",
+      border: "line",
+      keys: false,
+      vi: false,
+      mouse: true,
+      style: {
+        border: { fg: THEME.panelBorder },
+        fg: THEME.primaryText,
+        bg: THEME.bg,
+        selected: { bg: THEME.selectedBg, fg: THEME.selectedFg }
+      },
+      items: ["No decisions yet"]
+    });
+    this.historyBox.on("click", () => {
+      this.focusHistory();
+    });
+    this.historyBox.on("select", (_item, index) => {
+      this.state.selectedHistoryIndex = Number(index);
+      this.previewHistorySelection();
+      this.render();
+    });
+    this.outputBox = blessed.box({
+      parent: this.screen,
+      top: 7,
+      left: "34%",
+      width: "66%",
+      bottom: 5,
+      label: " Output ",
+      border: "line",
+      style: { border: { fg: THEME.panelBorder }, fg: THEME.primaryText, bg: THEME.bg },
+      scrollable: true,
+      alwaysScroll: true,
+      tags: true,
+      keys: true,
+      vi: true,
+      mouse: true,
+      content: renderResult(this.state)
+    });
+    this.outputBox.on("click", () => {
+      this.focusOutput();
+    });
+    this.helpModal = blessed.box({
+      parent: this.screen,
+      width: "58%",
+      height: 10,
+      top: "center",
+      left: "center",
+      label: " Help ",
+      border: "line",
+      tags: true,
+      hidden: true,
+      style: {
+        border: { fg: THEME.focusBorder },
+        fg: THEME.primaryText,
+        bg: THEME.panelBg
+      },
+      content: [
+        " Core controls",
+        " [Enter] Run decision",
+        " [Arrows] Move between prompt, history, and output",
+        " [A] Toggle audit timeline",
+        " [M] Toggle model (if OPENAI_API_KEY exists)",
+        " [Q] Quit  [Ctrl+C] Force quit",
+        " [?] Toggle this help"
+      ].join("\n")
+    });
+    this.helpModal.on("click", () => {
+      this.helpModal.hide();
+      this.render();
+    });
+    this.footer = blessed.box({
+      parent: this.screen,
+      bottom: 0,
+      left: 0,
+      width: "100%",
+      height: 4,
+      tags: true,
+      style: { fg: THEME.secondaryText, bg: THEME.panelBg },
+      content: this.renderFooterContent()
+    });
+    this.bindKeys();
+    this.render();
+    this.focusInput();
+  }
+  makeProvider(mode) {
+    return mode === "openai" ? createOpenAiProvider() : new HeuristicDebateProvider();
+  }
+  isTypingInPrompt() {
+    return this.screen.focused === this.inputBox;
+  }
+  stopPromptEditing() {
+    ;
+    this.inputBox.cancel?.();
+  }
+  focusHistory() {
+    this.stopPromptEditing();
+    this.suppressFocusHighlight = false;
+    this.historyBox.focus();
+    this.updateFocusStyles();
+    this.screen.render();
+  }
+  focusOutput() {
+    this.stopPromptEditing();
+    this.suppressFocusHighlight = false;
+    this.outputBox.focus();
+    this.updateFocusStyles();
+    this.screen.render();
+  }
+  updateFocusStyles() {
+    if (this.suppressFocusHighlight) {
+      ;
+      this.inputBox.style.border = {
+        fg: THEME.panelBorder
+      };
+      this.historyBox.style.border = {
+        fg: THEME.panelBorder
+      };
+      this.outputBox.style.border = {
+        fg: THEME.panelBorder
+      };
+      return;
+    }
+    const focused = this.screen.focused;
+    this.inputBox.style.border = {
+      fg: focused === this.inputBox ? THEME.focusBorder : THEME.panelBorder
+    };
+    this.historyBox.style.border = {
+      fg: focused === this.historyBox ? THEME.focusBorder : THEME.panelBorder
+    };
+    this.outputBox.style.border = {
+      fg: focused === this.outputBox ? THEME.focusBorder : THEME.panelBorder
+    };
+  }
+  renderFooterContent() {
+    const mode = this.state.mode.toUpperCase();
+    return [
+      ` Status: ${this.state.statusMessage} | Mode: ${mode}`,
+      " [?] Help  [Q] Quit"
+    ].join("\n");
+  }
+  setStatus(value) {
+    this.state.statusMessage = value;
+    this.footer.setContent(this.renderFooterContent());
+  }
+  focusInput() {
+    this.suppressFocusHighlight = false;
+    if (this.screen.focused !== this.inputBox) {
+      this.inputBox.focus();
+    }
+    this.updateFocusStyles();
+    this.screen.render();
+  }
+  getHistorySelectionIndex() {
+    const rawSelected = this.historyBox.selected;
+    if (typeof rawSelected === "number" && rawSelected >= 0) {
+      return Math.min(rawSelected, Math.max(this.state.history.length - 1, 0));
+    }
+    return this.state.selectedHistoryIndex;
+  }
+  previewHistorySelection() {
+    const item = this.state.history[this.state.selectedHistoryIndex];
+    if (!item) {
+      return;
+    }
+    this.state.currentResult = item.result;
+    this.state.currentInput = item.input;
+  }
+  log(message) {
+    this.state.logs = [...this.state.logs.slice(-50), message];
+    this.setStatus(message);
+  }
+  updateHistory() {
+    if (this.state.history.length === 0) {
+      this.historyBox.setItems(["No decisions yet"]);
+      this.state.selectedHistoryIndex = 0;
+      return;
+    }
+    this.historyBox.setItems(this.state.history.map(renderHistoryLabel));
+    const safeIndex = Math.min(this.state.selectedHistoryIndex, this.state.history.length - 1);
+    this.state.selectedHistoryIndex = Math.max(safeIndex, 0);
+    this.historyBox.select(this.state.selectedHistoryIndex);
+  }
+  render() {
+    this.tipBox.setContent(CONTEXT_TIP);
+    if (this.state.runState === "running") {
+      this.outputBox.setContent(this.renderLoadingOutput());
+    } else {
+      this.outputBox.setContent(renderResult(this.state));
+    }
+    this.footer.setContent(this.renderFooterContent());
+    this.updateHistory();
+    this.updateFocusStyles();
+    this.screen.render();
+  }
+  renderLoadingOutput() {
+    const dots = ".".repeat(this.loadingFrame % 4 + 1).padEnd(4, " ");
+    const spinner = ["|", "/", "-", "\\"][this.loadingFrame % 4];
+    return [`{bold}${spinner} Running debate ${dots}{/bold}`].join("\n");
+  }
+  startLoadingAnimation() {
+    if (this.loadingTimer) {
+      return;
+    }
+    this.loadingTimer = setInterval(() => {
+      if (this.state.runState !== "running") {
+        return;
+      }
+      this.loadingFrame += 1;
+      this.outputBox.setContent(this.renderLoadingOutput());
+      this.screen.render();
+    }, 180);
+  }
+  stopLoadingAnimation() {
+    if (!this.loadingTimer) {
+      return;
+    }
+    clearInterval(this.loadingTimer);
+    this.loadingTimer = null;
+    this.loadingFrame = 0;
+  }
+  async runCurrentInput() {
+    if (this.state.runState === "running") {
+      return;
+    }
+    const prompt = this.inputBox.getValue().trim();
+    if (!prompt) {
+      this.setStatus("Type a prompt first.");
+      this.render();
+      return;
+    }
+    const input = buildInputFromSituation(prompt);
+    this.state.currentInput = input;
+    this.state.runState = "running";
+    this.startLoadingAnimation();
+    this.log(`Running decision in ${this.state.mode.toUpperCase()} mode...`);
+    this.render();
+    try {
+      const run = await runDecisionPipeline(input, this.session, (message) => this.log(message));
+      const recordDecision = run.result.record?.executiveDecision.decision ?? "unknown";
+      this.state.currentResult = run.result;
+      this.state.history = [
+        {
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          decisionId: run.decisionId,
+          title: input.title,
+          decision: recordDecision,
+          artifactPath: run.artifactPath,
+          input,
+          result: run.result
+        },
+        ...this.state.history
+      ].slice(0, 50);
+      await persistHistory(this.state.history);
+      this.state.selectedHistoryIndex = 0;
+      this.state.runState = "done";
+      this.setStatus(`Done. ${recordDecision.toUpperCase()} | ${run.artifactPath}`);
+    } catch (error) {
+      this.state.runState = "error";
+      const message = error instanceof Error ? error.message : String(error);
+      this.log(`Error: ${message}`);
+      this.setStatus(`Error: ${message}`);
+    } finally {
+      this.stopLoadingAnimation();
+    }
+    this.render();
+    this.focusInput();
+  }
+  rerunSelectedWithEdits() {
+    this.state.selectedHistoryIndex = this.getHistorySelectionIndex();
+    const item = this.state.history[this.state.selectedHistoryIndex];
+    if (!item) {
+      this.setStatus("No history item selected.");
+      this.render();
+      return;
+    }
+    this.inputBox.setValue(item.input.context);
+    this.state.currentInput = item.input;
+    this.setStatus("Loaded previous prompt. Edit and press Enter to rerun.");
+    this.render();
+    this.focusInput();
+  }
+  bindKeys() {
+    this.screen.key(["?"], () => {
+      this.helpModal.hidden = !this.helpModal.hidden;
+      if (this.helpModal.hidden) {
+        this.focusInput();
+      }
+      this.screen.render();
+    });
+    this.screen.key(["escape"], () => {
+      if (!this.helpModal.hidden) {
+        this.helpModal.hide();
+        this.render();
+        return;
+      }
+      this.stopPromptEditing();
+      this.suppressFocusHighlight = true;
+      this.updateFocusStyles();
+      this.screen.render();
+    });
+    this.screen.on("mouse", (data) => {
+      if (this.helpModal.hidden || data.action !== "mousedown") {
+        return;
+      }
+      const lpos = this.helpModal.lpos;
+      if (!lpos) {
+        return;
+      }
+      const outsideX = data.x < lpos.xi || data.x > lpos.xl;
+      const outsideY = data.y < lpos.yi || data.y > lpos.yl;
+      if (outsideX || outsideY) {
+        this.helpModal.hide();
+        this.render();
+      }
+    });
+    this.screen.key(["q"], () => {
+      if (this.isTypingInPrompt()) {
+        return;
+      }
+      this.screen.destroy();
+      process.exit(0);
+    });
+    this.screen.key(["enter"], () => {
+      if (!this.helpModal.hidden || !this.isTypingInPrompt()) {
+        return;
+      }
+      void this.runCurrentInput();
+    });
+    this.screen.key(["C-c"], () => {
+      this.screen.destroy();
+      process.exit(0);
+    });
+    this.inputBox.key(["down"], () => {
+      this.focusHistory();
+      return false;
+    });
+    this.inputBox.key(["right"], () => {
+      this.focusOutput();
+      return false;
+    });
+    this.screen.key(["up"], () => {
+      if (this.screen.focused !== this.historyBox) {
+        return;
+      }
+      if (this.state.history.length === 0) {
+        return;
+      }
+      const selectedIndex = this.getHistorySelectionIndex();
+      if (selectedIndex > 0) {
+        this.state.selectedHistoryIndex = selectedIndex - 1;
+        this.previewHistorySelection();
+        this.render();
+        return;
+      }
+      this.focusInput();
+    });
+    this.screen.key(["down"], () => {
+      if (this.screen.focused !== this.historyBox) {
+        return;
+      }
+      if (this.state.history.length === 0) {
+        return;
+      }
+      const selectedIndex = this.getHistorySelectionIndex();
+      const nextIndex = Math.min(this.state.history.length - 1, selectedIndex + 1);
+      if (nextIndex !== selectedIndex) {
+        this.state.selectedHistoryIndex = nextIndex;
+        this.previewHistorySelection();
+        this.render();
+      }
+    });
+    this.screen.key(["right"], () => {
+      if (this.screen.focused !== this.historyBox) {
+        return;
+      }
+      this.focusOutput();
+    });
+    this.screen.key(["enter"], () => {
+      if (this.screen.focused !== this.historyBox) {
+        return;
+      }
+      this.rerunSelectedWithEdits();
+    });
+    this.outputBox.key(["left"], () => {
+      this.focusHistory();
+      return false;
+    });
+    this.screen.key(["a"], () => {
+      if (this.isTypingInPrompt()) {
+        return;
+      }
+      this.state.showAudit = !this.state.showAudit;
+      this.setStatus(`Audit ${this.state.showAudit ? "shown" : "hidden"}.`);
+      this.render();
+    });
+    this.screen.key(["m"], () => {
+      if (this.isTypingInPrompt()) {
+        return;
+      }
+      if (!process.env.OPENAI_API_KEY) {
+        this.setStatus("OPENAI_API_KEY missing. Heuristic mode only.");
+        this.render();
+        return;
+      }
+      const next = this.state.mode === "openai" ? "heuristic" : "openai";
+      this.state.mode = next;
+      this.session.provider = this.makeProvider(next);
+      this.setStatus(`Mode switched to ${next.toUpperCase()}.`);
+      this.render();
+    });
+  }
+  run() {
+    this.render();
+  }
+};
+var runTui = async () => {
+  await hydrateEnvFromFile();
+  await ensureOpenAiApiKey();
+  const history = await loadPersistedHistory();
+  const app = new DecisionTuiApp(history);
+  app.run();
+};
+
+// src/cli/main.ts
+runTui().catch((error) => {
+  console.error("CLI failed", error);
+  process.exitCode = 1;
+});