@poetic-ai/poetic 1.42.0

package/dist/chunk-TGQZHDY2.js

@@ -0,0 +1,2373 @@
+import {
+  ANCHORED_CHAT_FEATURE_ENV,
+  isAnchoredChatEnabled,
+  isEnforcedAnchorProvider
+} from "./chunk-RDFRCT64.js";
+import {
+  DefaultPricingTable,
+  MAX_BUILD_INTENT_LENGTH,
+  estimateTaskCost,
+  explainBuildRoute,
+  resolvePlanExecuteCliBlockerMode
+} from "./chunk-Z2CUQDAR.js";
+import {
+  ACTIVE_RUN_STATUSES,
+  isActiveRunStatus,
+  normalizeRunStatus
+} from "./chunk-44N5WZZH.js";
+import {
+  buildCompetitionHealthSnapshot,
+  classifyRunHealth,
+  summarizeRunHealth
+} from "./chunk-KM3F7SYE.js";
+import {
+  extractTitleFromPrompt
+} from "./chunk-F5JO7HAS.js";
+import {
+  sanitizeSynthesisArtifactForPersistence
+} from "./chunk-GG6KJYW6.js";
+import {
+  resolveConfig
+} from "./chunk-XPU2XADL.js";
+import {
+  formatProviderNotReadyMessage,
+  formatProviderSetupGuidance,
+  selectReadyProvider
+} from "./chunk-AURFMVCD.js";
+import {
+  detectSandboxBoundaryAttestation,
+  isSandboxBoundaryAccepted,
+  resolveSandboxBoundaryPolicy,
+  willSandboxBeActive
+} from "./chunk-PCAGC5MR.js";
+import {
+  getCurrentBranch,
+  isProtectedPipelineBranch
+} from "./chunk-XQD2B6BB.js";
+import {
+  POETIC_TUI_TIMING,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/cli/tui/actions.ts
+import path2 from "path";
+
+// package.json
+var package_default = {
+  name: "@poetic-ai/poetic",
+  version: "1.42.0",
+  description: "AI orchestration CLI that runs competing provider variants in parallel and synthesizes the best solution",
+  type: "module",
+  main: "dist/index.js",
+  bin: {
+    poetic: "dist/entry.js"
+  },
+  scripts: {
+    preinstall: "node ./scripts/preinstall-node-check.mjs",
+    "pretest:native": "tsx scripts/pretest-version-check.ts",
+    pretest: "npm run -s pretest:native",
+    "pretest:all": "npm run -s pretest:native",
+    "pretest:unit": "npm run -s pretest:native",
+    "pretest:integration": "npm run -s pretest:native",
+    "pretest:integration:hosted": "npm run -s pretest:native",
+    "pretest:workflow-contracts": "npm run -s pretest:native",
+    "pretest:integration:providers": "npm run -s pretest:native",
+    "pretest:integration:orchestrator": "npm run -s pretest:native",
+    "pretest:integration:cli": "npm run -s pretest:native",
+    "pretest:regression": "npm run -s pretest:native",
+    "pretest:core": "npm run -s pretest:native",
+    "pretest:config": "npm run -s pretest:native",
+    "pretest:smoke": "npm run -s pretest:native",
+    "pretest:judge": "npm run -s pretest:native",
+    "pretest:installer": "npm run -s pretest:native",
+    "pretest:providers": "npm run -s pretest:native",
+    "pretest:providers:shared": "npm run -s pretest:native",
+    "pretest:provider:claude": "npm run -s pretest:native",
+    "pretest:provider:copilot": "npm run -s pretest:native",
+    "pretest:provider:cursor": "npm run -s pretest:native",
+    "pretest:provider:codex": "npm run -s pretest:native",
+    "pretest:provider:gemini": "npm run -s pretest:native",
+    "pretest:provider:opencode": "npm run -s pretest:native",
+    "pretest:orchestrator": "npm run -s pretest:native",
+    "pretest:prompts": "npm run -s pretest:native",
+    "pretest:telemetry": "npm run -s pretest:native",
+    "pretest:reliability": "npm run -s pretest:native",
+    "pretest:automation": "npm run -s pretest:native",
+    "pretest:quality": "npm run -s pretest:native",
+    "pretest:cli": "npm run -s pretest:native",
+    "pretest:cli:unit": "npm run -s pretest:native",
+    "pretest:execution": "npm run -s pretest:native",
+    "pretest:scripts": "npm run -s pretest:native",
+    "pretest:validation": "npm run -s pretest:native",
+    "pretest:coverage": "npm run -s pretest:native",
+    "pretest:coverage:partial": "npm run -s pretest:native",
+    "pretest:coverage:all": "npm run -s pretest:native",
+    "pretest:stress": "npm run -s pretest:native",
+    "pretest:planning": "npm run -s pretest:native",
+    "pretest:planning:unit": "npm run -s pretest:native",
+    "pretest:core:testing": "npm run -s pretest:native",
+    "preplanning:validate": "npm run -s pretest:native",
+    "pretest:e2e": "npm run -s pretest:native && npm run -s build",
+    "pretest:stabilized": "npm run -s pretest:native",
+    "pretest:extended": "npm run -s pretest:native",
+    "pretest:dogfood": "npm run -s pretest:native",
+    "pretest:changed": "npm run -s pretest:native",
+    "pretest:changed:gate": "npm run -s pretest:native",
+    "pretest:changed:inventory": "npm run -s pretest:native",
+    "pretest:neutrality:sentinel": "npm run -s pretest:native",
+    "preci:stress": "npm run -s pretest:native",
+    "check:config-reads": "tsx scripts/check-config-direct-reads.ts",
+    "check:architecture-boundaries": "tsx scripts/check-architecture-boundaries.ts",
+    "check:no-decorative-glyphs": "tsx scripts/check-no-decorative-glyphs.ts",
+    "check:neutrality": "tsx scripts/check-neutrality.ts",
+    "check:git-exec": "tsx scripts/check-git-exec.ts",
+    "check:hotspot-growth": "node scripts/check-hotspot-growth.mjs",
+    "check:recursive-rm": "tsx scripts/check-recursive-rm.ts",
+    "check:no-outcome-promotion": "tsx scripts/check-no-outcome-promotion.ts",
+    "check:pr-hygiene": "node scripts/check-pr-hygiene.mjs",
+    "check:tracked-paths": "node scripts/check-tracked-paths.mjs",
+    "check:provider-quirks:blocking": "tsx scripts/check-provider-quirks.ts",
+    "check:telemetry-integrity": "tsx scripts/check-telemetry-integrity.ts",
+    "check:processes": "node dist/entry.js processes --health --json",
+    "check:generated": "node scripts/check-generated.mjs",
+    prebuild: "node scripts/generate-provider-json.js && tsx scripts/generate-judge-scoring-schema.ts && tsx scripts/generate-config-schema.ts",
+    build: "tsup --config tsup.config.ts",
+    postbuild: "node scripts/copy-build-assets.mjs",
+    rebuild: "./scripts/build-poetic.sh",
+    "add-provider": "tsx scripts/add-provider.ts",
+    "providers:generate": "node --import tsx ./src/cli/commands/providers-registry.ts generate",
+    "providers:validate": "node --import tsx ./src/cli/commands/providers-registry.ts validate",
+    "providers:update-yaml": "tsx scripts/update-providers-yaml.ts",
+    "generate:provider-types": "node --import tsx ./scripts/generate-provider-types.ts",
+    "generate:config-schema": "node --import tsx ./scripts/generate-config-schema.ts",
+    "templates:verify": "node ./scripts/verify-templates.mjs",
+    dev: "tsx watch src/cli/entry.ts",
+    "dev:once": "node --import tsx src/cli/entry.ts",
+    cli: "node --import tsx src/cli/entry.ts",
+    test: "bash scripts/test-guard.sh npm run test:unit",
+    "test:all": "POETIC_PREFLIGHT_DONE=1 npm run test:unit && POETIC_PREFLIGHT_DONE=1 npm run test:integration && POETIC_PREFLIGHT_DONE=1 npm run test:regression",
+    "test:unit": "node scripts/test-unit-inventory.mjs",
+    "test:integration": "node scripts/dynamic-node-options.mjs vitest run tests/integration",
+    "test:integration:hosted": "node scripts/run-hosted-integration.mjs",
+    "test:workflow-contracts": "node scripts/dynamic-node-options.mjs vitest run tests/unit/scripts/automation-workflows-yaml.test.ts tests/unit/scripts/release-gate-contract.test.ts",
+    "test:integration:providers": "node scripts/dynamic-node-options.mjs vitest run tests/integration/providers",
+    "test:integration:orchestrator": "node scripts/dynamic-node-options.mjs vitest run tests/integration/orchestrator",
+    "test:integration:cli": "node scripts/dynamic-node-options.mjs vitest run tests/integration/cli/",
+    "test:regression": "node scripts/dynamic-node-options.mjs vitest run tests/regression",
+    "test:core": "POETIC_PREFLIGHT_DONE=1 npm run test:telemetry && POETIC_PREFLIGHT_DONE=1 npm run test:automation && POETIC_PREFLIGHT_DONE=1 npm run test:quality && POETIC_PREFLIGHT_DONE=1 npm run test:planning:unit && POETIC_PREFLIGHT_DONE=1 npm run test:core:testing",
+    "test:config": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/config",
+    "test:installer": "bash tests/installer/run-all.sh",
+    "dogfood:journey": "bash scripts/release/dogfood-real-providers.sh",
+    "compete-streak": "tsx scripts/compete-streak/run.ts",
+    "release:pack-smoke": "bash scripts/release/pack-and-smoke.sh",
+    "release:local-dist-canary": "node scripts/release/local-dist-canary.mjs",
+    "release:artifacts": "bash scripts/release/prepare-artifacts.sh",
+    "release:dependency-report": "node scripts/release/sbom-license-report.mjs --out-dir .poetic/tmp/release",
+    "release:license-report": "npm run -s release:dependency-report",
+    "release:secret-scan": "bash scripts/release/secret-scan.sh",
+    "release:secret-scan:artifact": "bash scripts/release/secret-scan.sh --artifact",
+    "release:gate": "bash scripts/release/run-gate.sh --mode merge",
+    "verify:release-gate": "npm run release:gate",
+    "release:gate:publish": "bash scripts/release/run-gate.sh --mode publish",
+    "release:verify-all": "npm run -s release:gate && npm run -s test:all && npm run -s release:gate:publish && echo '[release:verify-all] CI-only: shrinkwrap generation (release.yml) mutates working tree; POETIC_EXPECT_SHRINKWRAP=1 runs in CI only' && echo '[release:verify-all] Manual extended suites are opt-in: POETIC_RUN_EXTENDED_TESTS=1 npm run -s test:extended'",
+    "test:smoke": "node scripts/smoke-tests/run.mjs",
+    "smoke-test": "npm run -s test:smoke",
+    "test:sprint-smoke": "tsx scripts/sprint-smoke.ts",
+    "test:docs:smoke": "bash scripts/test-docs-smoke.sh",
+    "test:providers": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers",
+    "test:providers:shared": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers/shared",
+    "test:provider:claude": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers/claude",
+    "test:provider:copilot": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers/copilot",
+    "test:provider:cursor": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers/cursor",
+    "test:provider:codex": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers/codex",
+    "test:provider:gemini": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers/gemini",
+    "test:provider:opencode": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/providers/opencode",
+    "test:orchestrator": "node scripts/dynamic-node-options.mjs vitest run tests/unit/orchestrator",
+    "test:judge": "node scripts/dynamic-node-options.mjs vitest run tests/unit/orchestrator/judge-verdict-shipping-invariants.test.ts tests/unit/orchestrator/judge-fallback-selector.test.ts tests/unit/orchestrator/matrix-authority.test.ts tests/unit/orchestrator/judge-coordinator.test.ts tests/unit/orchestrator/winner-verification.test.ts tests/unit/core/verification/known-pre-existing-failures.test.ts tests/unit/core/judge/llm-winner-authority.test.ts tests/unit/core/judge/no-post-llm-mutation.test.ts tests/unit/core/judge/winner-from-scores.test.ts tests/unit/core/judge/ai-judge-schema-retry.test.ts",
+    "test:telemetry": "node scripts/dynamic-node-options.mjs vitest run tests/unit/telemetry src/telemetry/__tests__ src/telemetry/variants/__tests__",
+    "test:reliability": 'node scripts/dynamic-node-options.mjs vitest run tests/unit/cli/commands/telemetry-reliability.test.ts && node scripts/dynamic-node-options.mjs vitest run src/orchestrator/__tests__/basic-competition-master.test.ts -t "provider chaos canary" && node scripts/dynamic-node-options.mjs vitest run src/orchestrator/__tests__/basic-competition-master.test.ts -t "complex multi-file synthesis fallback"',
+    "test:automation:preflight": "node scripts/dynamic-node-options.mjs vitest run --silent=passed-only tests/unit/automation/flywheel-preflight.test.ts",
+    "test:automation": "node scripts/dynamic-node-options.mjs vitest run --maxWorkers=1 --no-file-parallelism --silent=passed-only tests/unit/automation --exclude tests/unit/automation/flywheel-preflight.test.ts && npm run -s test:automation:preflight",
+    "test:quality": "node scripts/dynamic-node-options.mjs vitest run tests/unit/quality",
+    "test:planning:unit": "node scripts/dynamic-node-options.mjs vitest run --maxWorkers=1 --no-file-parallelism tests/unit/planning src/planning/__tests__",
+    "test:core:testing": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/memory tests/unit/core/testing",
+    "test:prompts": "node scripts/dynamic-node-options.mjs vitest run tests/unit/prompts tests/unit/types tests/unit/utils tests/unit/core/judge/ai-judge-prompt-3bucket-excerpt.test.ts tests/unit/core/judge/criteria-ledger-confidence.test.ts tests/unit/core/judge/winner-from-scores.test.ts tests/unit/core/judge/evidence-proportionality-gate.test.ts tests/unit/core/judge/signal-reliability.test.ts src/prompts src/core/judge/__tests__",
+    "test:cli": "node scripts/dynamic-node-options.mjs vitest run tests/integration/providers-registry-cli.test.ts",
+    "test:cli:unit": "node scripts/dynamic-node-options.mjs vitest run tests/unit/cli",
+    "test:tui-semantic": "node scripts/dynamic-node-options.mjs vitest run tests/unit/cli/tui/e2e/journeys.test.ts tests/unit/cli/tui/ui-state-property.test.ts",
+    "test:execution": "node scripts/dynamic-node-options.mjs vitest run tests/unit/core/execution",
+    "test:scripts": "node scripts/dynamic-node-options.mjs vitest run tests/unit/scripts",
+    "test:validation": "node scripts/dynamic-node-options.mjs vitest run tests/unit/scripts tests/integration/validate-providers-script.test.ts",
+    "test:cli:watch": "vitest watch tests/integration/providers-registry-cli.test.ts",
+    "test:validation:watch": "vitest watch tests/unit/scripts tests/integration/validate-providers-script.test.ts",
+    "test:watch": "vitest watch",
+    "test:coverage": "node scripts/dynamic-node-options.mjs vitest run tests/unit/telemetry tests/unit/core tests/unit/orchestrator tests/unit/automation tests/unit/quality tests/unit/types tests/unit/utils --coverage",
+    "test:coverage:partial": "node scripts/dynamic-node-options.mjs vitest --config vitest.partial.config.ts run --coverage",
+    "test:coverage:all": "node scripts/dynamic-node-options.mjs vitest run --config vitest.partial.config.ts tests/unit/telemetry tests/unit/automation tests/unit/quality tests/unit/planning tests/unit/core/memory/memory-store.test.ts tests/unit/core/providers tests/unit/orchestrator tests/unit/prompts tests/unit/types tests/unit/utils tests/unit/cli tests/unit/core/judge/ai-judge-prompt-3bucket-excerpt.test.ts tests/unit/core/judge/criteria-ledger-confidence.test.ts tests/unit/core/judge/winner-from-scores.test.ts src/prompts src/core/judge/__tests__ tests/integration/providers-registry-cli.test.ts tests/integration/validate-providers-script.test.ts tests/unit/scripts --coverage.enabled",
+    "test:stress": "node scripts/dynamic-node-options.mjs node --import tsx tests/stress/memory-stress.js",
+    "ci:stress": "NODE_ENV=ci node scripts/dynamic-node-options.mjs node --import tsx tests/stress/memory-stress.js --ci",
+    "check:package-docs": "node --import tsx scripts/check-package-docs.mjs",
+    postinstall: "node ./scripts/preflight-native.mjs",
+    "preflight:native": "node ./scripts/preflight-native.mjs",
+    "verify:dist": "tsx scripts/verify-dist.ts",
+    "verify:release": "npm run -s verify:dist && node --import tsx ./scripts/verify-release-readiness.ts",
+    prepublishOnly: "npm run -s verify:dist",
+    "audit:errors": "node --import tsx ./scripts/audit-error-handling.ts --skip-destructive",
+    "audit:post-llm-mutations": "node --import tsx ./scripts/audit-post-llm-mutations.ts --strict",
+    clean: "rm -rf dist",
+    typecheck: "tsc --noEmit -p tsconfig.typecheck-full.json && tsc --noEmit -p tsconfig.tooling.json && tsc --noEmit -p integrations/bb-plugin-poetic/tsconfig.json && tsx scripts/check-test-imports.ts",
+    "typecheck:telemetry": "tsc --noEmit -p tsconfig.typecheck.json",
+    "typecheck:providers:opencode-glm": "npm run typecheck:providers:opencode",
+    "typecheck:providers:opencode": "tsc --noEmit -p tsconfig.providers-opencode.json",
+    lint: "biome check --changed --no-errors-on-unmatched",
+    "lint:ci": "node scripts/lint-ci.mjs",
+    "lint:full": "biome check src/ tests/ scripts/",
+    "lint:fix": "biome check --write --changed --no-errors-on-unmatched",
+    "lint:fix:full": "biome check --write src/ tests/ scripts/",
+    "lint-docs": "node ./scripts/lint-docs-cli.mjs",
+    "instructions:lint": "node --import tsx ./scripts/instruction-lint.ts",
+    "instructions:surface": "node --import tsx ./scripts/instruction-surface.ts",
+    format: "biome format --write src/ tests/ scripts/",
+    "format:check": "biome format src/ tests/ scripts/",
+    "check:esm": "node scripts/check-esm-compliance.js",
+    prepare: "node scripts/setup-git-hooks.mjs",
+    "prepare:full": "npm run clean && npm run templates:verify && npm run providers:validate && npm run providers:generate && npm run build && npm run check:esm && npm run -s verify:dist",
+    prepack: 'npm run -s check:package-docs && if [ "${POETIC_SKIP_PREPACK:-0}" = "1" ]; then echo "[prepack] POETIC_SKIP_PREPACK=1; skipping prepare:full"; else npm run prepare:full; fi',
+    "canary:backlog-execute": "node --import tsx ./scripts/reliability/run-backlog-execute-canary.ts",
+    "canary:backlog-execute:validate": "node --import tsx ./scripts/reliability/validate-backlog-execute-canary-artifacts.ts",
+    "canary:backlog-execute:scorecard": "node --import tsx ./scripts/reliability/reliability-scorecard.ts",
+    "test:planning": "node scripts/dynamic-node-options.mjs vitest run tests/planning",
+    "test:planning:watch": "vitest watch tests/planning",
+    "planning:validate": "node scripts/dynamic-node-options.mjs vitest run tests/planning/validation.test.ts",
+    "backup:telemetry": "node --import tsx scripts/backup-telemetry-db.ts",
+    "restore:telemetry": "node --import tsx scripts/restore-telemetry-db.ts",
+    "validate:judge-canary": "tsx scripts/validate-judge-canary.ts",
+    "judge:calibrate-thresholds": "tsx scripts/replay-judge-threshold-calibration.ts",
+    "test:e2e": "POETIC_E2E_USE_DIST=1 node scripts/dynamic-node-options.mjs vitest run tests/e2e --maxWorkers=1 --no-file-parallelism --reporter=verbose",
+    "test:e2e:watch": "vitest watch tests/e2e",
+    "test:stabilized": "node scripts/dynamic-node-options.mjs vitest run tests/stabilized --reporter=verbose",
+    "test:extended": `if [ "\${POETIC_RUN_EXTENDED_TESTS:-0}" = "1" ]; then POETIC_PREFLIGHT_DONE=1 npm run -s test:e2e && POETIC_PREFLIGHT_DONE=1 npm run -s test:stabilized; else echo '[test:extended] SKIP: set POETIC_RUN_EXTENDED_TESTS=1 to run test:e2e and test:stabilized'; fi`,
+    "test:dogfood": "bash scripts/release/dogfood-real-providers.sh",
+    "stress:autoloop-dogfood": "bash scripts/stress/autoloop-dogfood-streak.sh",
+    "stress:builder-dogfood": "bash scripts/stress/builder-dogfood-streak.sh",
+    "test:changed": "node ./scripts/test-changed.mjs",
+    "test:changed:gate": "node ./scripts/test-changed-gate.mjs",
+    "test:changed:inventory": "node ./scripts/test-changed-inventory.mjs",
+    "test:neutrality:sentinel": "node --import tsx ./scripts/run-non-node-verification-sentinel.ts",
+    "test:fast": "npm run test:changed",
+    "test:staged": "npm run test:changed -- --staged",
+    "test:related": "node scripts/dynamic-node-options.mjs vitest related",
+    "test:watch:orchestrator": "node scripts/dynamic-node-options.mjs vitest watch tests/unit/orchestrator",
+    "test:watch:prompts": "node scripts/dynamic-node-options.mjs vitest watch tests/unit/prompts tests/unit/types tests/unit/utils tests/unit/cli tests/unit/core/judge/ai-judge-prompt-3bucket-excerpt.test.ts tests/unit/core/judge/criteria-ledger-confidence.test.ts tests/unit/core/judge/winner-from-scores.test.ts src/prompts src/core/judge/__tests__",
+    "ci:gate": "npm run release:gate",
+    resources: "node scripts/show-resource-tier.mjs",
+    "ci:nightly": "npm run -s check:no-decorative-glyphs && npm run -s test:unit && npm run -s test:integration && npm run -s test:regression"
+  },
+  keywords: [
+    "ai",
+    "orchestration",
+    "cli",
+    "development",
+    "automation",
+    "variant-competition",
+    "quality-gates",
+    "telemetry",
+    "claude",
+    "codex",
+    "cursor",
+    "multi-provider"
+  ],
+  author: "Ed Brindley <61567470+ebrindley@users.noreply.github.com>",
+  license: "MIT",
+  homepage: "https://github.com/ebrindley/Poetic#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ebrindley/Poetic.git"
+  },
+  bugs: {
+    url: "https://github.com/ebrindley/Poetic/issues"
+  },
+  os: [
+    "darwin",
+    "linux"
+  ],
+  publishConfig: {
+    access: "public",
+    provenance: false
+  },
+  files: [
+    "dist/",
+    "!dist/**/*.map",
+    "!dist/.poetic-build-meta.json",
+    ".nvmrc",
+    "schemas/",
+    "scripts/sync.sh",
+    "scripts/preinstall-node-check.mjs",
+    "scripts/assert-node-runtime.mjs",
+    "scripts/preflight-native.mjs",
+    "scripts/setup-git-hooks.mjs",
+    "scripts/write-node-launcher.sh",
+    "src/resources/",
+    "templates/",
+    "integrations/bb-plugin-poetic/",
+    "!integrations/bb-plugin-poetic/node_modules/",
+    ".poetic/providers/",
+    "!.poetic/providers/*.lock",
+    "README.md",
+    "INSTALL.md",
+    "docs/README.md",
+    "docs/getting-started/README.md",
+    "docs/getting-started/QUICK_START.md",
+    "docs/getting-started/SETUP.md",
+    "docs/CLI_REFERENCE.md",
+    "docs/PROVIDER_SETUP.md",
+    "docs/TROUBLESHOOTING.md",
+    "docs/reference/AGENT_CONTEXT.md",
+    "docs/reference/PROVIDER_RELEASE_TIERS.md",
+    "docs/reference/SECURITY.md",
+    ".github/SECURITY.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md"
+  ],
+  dependencies: {
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@inkjs/ui": "^2.0.0",
+    ajv: "^8.20.0",
+    "ajv-formats": "^3.0.1",
+    "async-lock": "^1.4.1",
+    "better-sqlite3": "^12.5.0",
+    chalk: "^5.3.0",
+    "cli-table3": "^0.6.5",
+    commander: "^14.0.2",
+    "decimal.js": "^10.6.0",
+    execa: "^9.0.0",
+    "fast-xml-parser": "^5.7.3",
+    ink: "^7.0.2",
+    "js-yaml": "^4.3.1",
+    "jsonc-parser": "^3.3.1",
+    minimatch: "^10.2.5",
+    "p-limit": "^7.2.0",
+    "proper-lockfile": "^4.1.2",
+    react: "^19.2.6",
+    semver: "^7.7.3",
+    "simple-statistics": "^7.8.8",
+    "string-width": "^8.2.0",
+    yaml: "^2.8.3",
+    zod: "^4.1.12"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.3.4",
+    "@types/async-lock": "^1.4.2",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.10.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^19.2.14",
+    "@types/semver": "^7.7.1",
+    "@vitest/coverage-v8": "^4.1.8",
+    tsup: "^8.5.0",
+    tsx: "^4.0.0",
+    typescript: "5.4.5",
+    vitest: "^4.1.8"
+  },
+  engines: {
+    node: ">=24.0.0 <25.0.0",
+    npm: ">=9.0.0"
+  },
+  overrides: {
+    esbuild: "0.28.1",
+    picomatch: "4.0.4"
+  },
+  optionalDependencies: {
+    tiktoken: "^1.0.22"
+  }
+};
+
+// src/cli/tui/command-registry.ts
+var TUI_COMMANDS = [
+  {
+    name: "tab",
+    usage: "/tab <runs|plan|config>",
+    description: "Switch the left pane tab."
+  },
+  {
+    name: "lens",
+    usage: "/lens <sprint|tasks|backlog>",
+    description: "Switch the Plan tab lens."
+  },
+  {
+    name: "build",
+    usage: "/build <intent>",
+    description: "Tell me what you want and I'll build it."
+  },
+  {
+    name: "plan-run",
+    usage: "/plan-run <intent>",
+    description: "Plan the work and save it for later.",
+    aliases: ["execute-plan"]
+  },
+  {
+    name: "run",
+    usage: "/run <task>",
+    description: "Run a single task directly."
+  },
+  {
+    name: "compete",
+    usage: "/compete <task>",
+    description: "Implement several approaches and keep the best result."
+  },
+  {
+    name: "fusion",
+    usage: "/fusion <task>",
+    description: "Synthesize multiple AI perspectives without a winner."
+  },
+  {
+    name: "monitor",
+    usage: "/monitor <id>",
+    description: "Follow progress for an existing run."
+  },
+  {
+    name: "next",
+    usage: "/next",
+    description: "Show the next useful Poetic task."
+  },
+  {
+    name: "quickstart",
+    usage: "/quickstart [task...]",
+    description: "Open the guided first-run starter."
+  },
+  {
+    name: "knowledge",
+    usage: "/knowledge [status|declare <spec>|clear|resolve <keep|accept>|offer [guidance]|accept <token> <all|ids>|graduate <token>]",
+    description: "Inspect and manage the knowledge kit and stack intent contract."
+  },
+  {
+    name: "model",
+    usage: "/model [provider/model|model|provider|reset]",
+    description: "Choose the provider and model for this Conversation session."
+  },
+  {
+    name: "config",
+    usage: "/config",
+    description: "Open persistent and session configuration (alias: /settings).",
+    aliases: ["settings"]
+  },
+  {
+    name: "status",
+    usage: "/status",
+    description: "Show configured, requested, and provider-reported model state."
+  },
+  {
+    name: "context",
+    usage: "/context <attach|clear>",
+    description: "Attach the selected Work object to Conversation, or clear it."
+  },
+  {
+    name: "clear",
+    usage: "/clear",
+    description: "Clear the current TUI output."
+  },
+  {
+    name: "chat",
+    usage: "/chat <message>",
+    description: "Send a message to the current chat."
+  },
+  {
+    name: "help",
+    usage: "/help",
+    description: "Show available commands."
+  },
+  {
+    name: "quit",
+    usage: "/quit",
+    description: "Exit the TUI.",
+    aliases: ["exit"]
+  },
+  {
+    name: "answer",
+    usage: "/answer <blockerId>=<answer>",
+    description: "Reply to a blocker so work can continue.",
+    hidden: true
+  }
+];
+function normalizeTuiCommand(command) {
+  const normalized = command.trim().toLowerCase();
+  for (const definition of TUI_COMMANDS) {
+    if (definition.name === normalized || definition.aliases?.includes(normalized)) {
+      return definition.name;
+    }
+  }
+  return normalized;
+}
+function getTuiCommandSuggestions(input) {
+  const trimmed = input.trimStart();
+  if (!trimmed.startsWith("/")) return [];
+  const rawCommand = trimmed.slice(1).split(/\s+/, 1)[0]?.toLowerCase() ?? "";
+  return TUI_COMMANDS.filter((definition) => {
+    if (definition.hidden) return false;
+    if (definition.name.startsWith(rawCommand)) return true;
+    return definition.aliases?.some((alias) => alias.startsWith(rawCommand)) ?? false;
+  });
+}
+
+// src/cli/tui/chat-formatting.ts
+var SHORT_FOOTER_PROVIDERS = /* @__PURE__ */ new Set(["claude", "codex", "gemini", "grok", "copilot"]);
+var FULL_PATH_FOOTER_PROVIDERS = /* @__PURE__ */ new Set(["opencode", "cursor"]);
+var PROVIDER_DISPLAY_NAMES = {
+  claude: "Claude",
+  codex: "Codex",
+  cursor: "Cursor",
+  gemini: "Gemini",
+  opencode: "OpenCode",
+  grok: "Grok",
+  copilot: "Copilot"
+};
+function formatProviderName(provider) {
+  return Object.hasOwn(PROVIDER_DISPLAY_NAMES, provider) ? PROVIDER_DISPLAY_NAMES[provider] ?? provider : provider;
+}
+function formatShortModelAlias(model, provider) {
+  let trimmed = model.trim();
+  const providerKey = provider?.trim().toLowerCase();
+  if (!trimmed) return "-";
+  if (trimmed === "auto") return providerKey === "claude" ? "-" : "auto";
+  if (trimmed.includes("/")) return trimmed;
+  let contextSuffix = "";
+  if (providerKey === "claude") {
+    trimmed = trimmed.replace(/^(?:[a-z0-9-]+\.)?anthropic\./i, "");
+    if (trimmed.endsWith("[1m]")) {
+      contextSuffix = " [1m]";
+      trimmed = trimmed.slice(0, -"[1m]".length);
+    }
+    trimmed = trimmed.replace(/-\d{8}-v\d+:\d+$/i, "");
+  }
+  if (providerKey && trimmed.toLowerCase().startsWith(`${providerKey}-`)) {
+    const rest = trimmed.slice(providerKey.length + 1);
+    if (/^[a-z]/i.test(rest)) {
+      trimmed = rest;
+    }
+  }
+  const parts = trimmed.split("-").filter((part) => part.length > 0);
+  if (parts.length >= 2) {
+    const last = parts[parts.length - 1];
+    const secondLast = parts[parts.length - 2];
+    if (/^\d+$/.test(last) && /^\d+$/.test(secondLast)) {
+      parts.splice(parts.length - 2, 2, `${secondLast}.${last}`);
+    }
+  }
+  return `${parts.join(" ").replace(/\s+/g, " ").trim()}${contextSuffix}`;
+}
+function formatTuiFooterLabel(params) {
+  const provider = params.provider.trim().toLowerCase();
+  const model = params.model?.trim() ?? (provider === "cursor" ? "auto" : "");
+  const providerLabel = formatProviderName(provider);
+  if (FULL_PATH_FOOTER_PROVIDERS.has(provider)) {
+    return `${providerLabel} | ${model || "-"}`;
+  }
+  if (SHORT_FOOTER_PROVIDERS.has(provider)) {
+    return `${providerLabel} | ${formatShortModelAlias(model, provider)}`;
+  }
+  if (model.includes("/")) {
+    return `${providerLabel} | ${model}`;
+  }
+  return `${providerLabel} | ${formatShortModelAlias(model, provider)}`;
+}
+function formatElapsed(ms) {
+  if (ms === void 0) return void 0;
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m`;
+  return `${Math.round(ms / 36e5)}h`;
+}
+function formatTuiUserPromptLine(line) {
+  return `> ${line}`;
+}
+function formatTuiAssistantMessageContent(content) {
+  return content.trim();
+}
+function shouldShowTuiChatWorkingIndicator(message) {
+  return message.role === "assistant" && message.status === "streaming";
+}
+function shouldShowTuiChatTurnReceipt(message) {
+  return message.role === "assistant" && message.status === "done" && message.durationMs !== void 0;
+}
+function formatWorkingElapsed(elapsedMs) {
+  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
+function formatWorkingLine(params) {
+  const parts = [formatWorkingElapsed(params.elapsedMs), "c to cancel"];
+  if (params.tokensSoFar !== void 0 && params.tokensSoFar > 0) {
+    parts.push(`${params.tokensSoFar} tokens`);
+  }
+  return `Working (${parts.join(" - ")})`;
+}
+function formatTuiChatCostUsd(costUsd) {
+  if (costUsd !== 0 && Math.abs(costUsd) < 0.01) {
+    return `$${costUsd.toFixed(4)}`;
+  }
+  return `$${costUsd.toFixed(2)}`;
+}
+function formatTurnReceipt(params) {
+  const segments = [];
+  if (params.durationMs !== void 0) {
+    segments.push(`completed in ${formatReceiptDuration(params.durationMs)}`);
+  } else {
+    segments.push("completed");
+  }
+  if (params.costUsd !== void 0) {
+    segments.push(formatTuiChatCostUsd(params.costUsd));
+  }
+  const tokens = receiptTokenTotal(params.tokensIn, params.tokensOut);
+  if (tokens !== void 0) {
+    segments.push(`${tokens} tokens`);
+  }
+  if (segments.length <= 1 && params.durationMs === void 0) return void 0;
+  return `Turn ${segments.join(" - ")}`;
+}
+function formatReceiptDuration(ms) {
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
+function receiptTokenTotal(tokensIn, tokensOut) {
+  if (tokensIn === void 0 && tokensOut === void 0) return void 0;
+  return (tokensIn ?? 0) + (tokensOut ?? 0);
+}
+
+// src/cli/tui/model-selection.ts
+var EXPLICIT_MODEL_SOURCES = /* @__PURE__ */ new Set([
+  "cli",
+  "env",
+  "env-legacy",
+  "profile",
+  "project",
+  "user-config"
+]);
+function resolveTuiSelectedModel(resolved) {
+  if (!resolved || !EXPLICIT_MODEL_SOURCES.has(resolved.source)) return void 0;
+  const model = resolved.value.trim();
+  return model.length > 0 && model.toLowerCase() !== "auto" ? model : void 0;
+}
+function formatTuiSelectedModel(resolved) {
+  return resolveTuiSelectedModel(resolved) ?? "-";
+}
+
+// src/cli/tui/dashboard-helpers.ts
+var EXPLICIT_DEFAULT_PROVIDER_SOURCES = /* @__PURE__ */ new Set([
+  "cli",
+  "env",
+  "env-legacy",
+  "profile",
+  "project",
+  "user-config"
+]);
+function isExplicitDefaultProviderSource(source) {
+  return EXPLICIT_DEFAULT_PROVIDER_SOURCES.has(source);
+}
+function toEnforcedAnchorProvider(value) {
+  if (typeof value === "string" && isEnforcedAnchorProvider(value)) return value;
+  return null;
+}
+function resolveTuiChatProvider(params) {
+  if (params.anchoredProvider) return params.anchoredProvider;
+  const sessionProvider = toEnforcedAnchorProvider(params.sessionDefaultProvider);
+  if (sessionProvider) return sessionProvider;
+  try {
+    return toEnforcedAnchorProvider(
+      resolveConfig(void 0, params.repoRoot, { strictSynthesisModel: false }).defaultProvider.value
+    );
+  } catch {
+    return null;
+  }
+}
+async function preparePreviewSpawn(preview, repoRoot) {
+  const args = [...preview.executable.prefixArgs, ...preview.argv];
+  if (preview.sandbox.mode === "none") {
+    return { command: preview.executable.command, args, sandboxed: false };
+  }
+  const { wrapWithSandbox } = await import("./sandbox-RSO7VP6V.js");
+  return wrapWithSandbox({
+    workingDir: repoRoot,
+    command: preview.executable.command,
+    args,
+    providerName: preview.sandbox.providerName,
+    providerId: preview.sandbox.providerId,
+    readOnlyWorkingDir: preview.sandbox.mode === "read-only"
+  });
+}
+function resolveTuiImmediateCommandArgError(inputText) {
+  const match = /^\/([a-z-]+)\s+(.+)$/i.exec(inputText.trim());
+  if (!match) return null;
+  const command = normalizeTuiCommand(match[1] ?? "");
+  if (!["clear", "quit", "help", "config", "status"].includes(command)) return null;
+  return `/${command} does not take arguments.`;
+}
+function resolveTuiImmediateCommand(inputText) {
+  const match = /^\/([a-z-]+)$/i.exec(inputText.trim());
+  if (!match?.[1]) return null;
+  const command = normalizeTuiCommand(match[1]);
+  if (command === "help") return "help";
+  if (command === "config") return "config-tab";
+  if (command === "status") return "status";
+  if (command === "clear") return "clear";
+  if (command === "quit") return "quit";
+  return null;
+}
+function resolveTuiChatAvailable(activeChatProvider) {
+  return isAnchoredChatEnabled(process.env) && activeChatProvider !== null;
+}
+function shouldExecuteTuiSuggestionImmediately(command) {
+  return !command.usage.includes("<");
+}
+function shouldStartTuiPreviewImmediately(preview) {
+  return preview.kind === "chat" && preview.canSubmit;
+}
+function hasProviderSetupAttention(items) {
+  return items.some((item) => item.kind === "provider-auth");
+}
+function suggestedTaskLine(plan) {
+  const sprintTask = plan.tasks.find((task) => task.meta !== "done") ?? plan.tasks[0];
+  if (sprintTask) {
+    return `Suggested first task: /quickstart ${sprintTask.title}`;
+  }
+  const backlogItem = plan.backlog[0];
+  if (backlogItem) {
+    return `Suggested first task: /quickstart ${backlogItem.title}`;
+  }
+  return "Suggested first task: /quickstart Describe the change you want.";
+}
+function resolveTuiOnboardingHome(params) {
+  if (params.runs.length > 0) return null;
+  const providerNeedsSetup = hasProviderSetupAttention(params.attentionItems) || params.providerPromptResolution === "setup" || params.providerPromptResolution === "guidance";
+  const providerReady = params.providerPromptResolution === "none";
+  return {
+    readiness: providerNeedsSetup ? "Readiness: provider setup needed" : providerReady ? `Readiness: ready (${params.backendLabel})` : "Readiness: checking providers",
+    providerSetup: providerNeedsSetup ? "Provider setup: use the prompt, or open Config (3)." : providerReady ? "Provider setup: Config (3) changes defaults." : "Provider setup: checking installed provider CLIs.",
+    suggestedTask: suggestedTaskLine(params.planState),
+    quickstart: "Quickstart: /quickstart opens the guided starter."
+  };
+}
+function resolveTuiFirstRunProviderPrompt(params) {
+  const defaultReadiness = params.readiness.find(
+    (provider) => provider.provider === params.defaultProvider?.value
+  );
+  const explicitReadyDefault = params.defaultProvider && EXPLICIT_DEFAULT_PROVIDER_SOURCES.has(params.defaultProvider.source) && defaultReadiness?.ready;
+  if (explicitReadyDefault) return { kind: "none" };
+  if (params.defaultProvider && EXPLICIT_DEFAULT_PROVIDER_SOURCES.has(params.defaultProvider.source)) {
+    return {
+      kind: "guidance",
+      guidance: defaultReadiness ? formatProviderNotReadyMessage(defaultReadiness) : `Configured provider ${params.defaultProvider.value} is not ready.
+Run poetic provider list after setup completes.`
+    };
+  }
+  const selection = selectReadyProvider(params.readiness);
+  if (selection.kind === "none") {
+    return {
+      kind: "guidance",
+      guidance: formatProviderSetupGuidance(selection.candidates)
+    };
+  }
+  if (selection.kind === "single") {
+    return { kind: "save-scope", provider: selection.provider };
+  }
+  return { kind: "select-provider", candidates: selection.candidates };
+}
+var PROMPT_SEPARATOR_WIDTH = 120;
+function loadTuiActions() {
+  return import("./actions-LUJPINLJ.js");
+}
+function promptSeparator() {
+  const columns = process.stdout.columns;
+  const width = typeof columns === "number" && Number.isFinite(columns) ? Math.max(24, Math.min(columns, PROMPT_SEPARATOR_WIDTH)) : PROMPT_SEPARATOR_WIDTH;
+  return "\u2500".repeat(width);
+}
+function resolveTuiBackendLabel(repoRoot, anchoredProvider) {
+  try {
+    const config = resolveConfig(void 0, repoRoot, { strictSynthesisModel: false });
+    const provider = anchoredProvider ?? config.defaultProvider.value;
+    const model = resolveTuiSelectedModel(config.providerModels[provider]);
+    return formatTuiFooterLabel({ provider, model });
+  } catch {
+    return formatTuiFooterLabel({
+      provider: anchoredProvider ?? "poetic"
+    });
+  }
+}
+function resolveTuiChatModel(repoRoot, provider) {
+  try {
+    const config = resolveConfig(void 0, repoRoot, { strictSynthesisModel: false });
+    return resolveTuiSelectedModel(config.providerModels[provider]);
+  } catch {
+    return void 0;
+  }
+}
+function resolveTuiDisplayedChatModel(messages, provider, selectedModel, activeSessionId) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.provider !== provider || message.role !== "assistant" && message.role !== "error") {
+      continue;
+    }
+    if (message.status === "streaming" || activeSessionId !== void 0 && message.sessionId === activeSessionId) {
+      return message.model ?? selectedModel;
+    }
+  }
+  return selectedModel;
+}
+function previewNeedsRunBranch(preview) {
+  if (!preview || preview.route !== "planned") return false;
+  return preview.warnings.some((warning) => warning.startsWith("Protected branch "));
+}
+function countProposalQueueRows(queue) {
+  if (!queue) return 0;
+  return 1 + 2 + (queue.truncated ? 1 : 0) + queue.rejected.length + queue.actions.length;
+}
+function resolveTuiChatAgentPrompt(readiness) {
+  const chatReadiness = readiness.filter((provider) => toEnforcedAnchorProvider(provider.provider));
+  const readyCandidates = chatReadiness.filter((provider) => provider.ready);
+  if (readyCandidates.length > 0) {
+    return {
+      kind: "select-provider",
+      title: "Choose Chat Agent",
+      intro: "Choose an agent to chat with:",
+      candidates: readyCandidates
+    };
+  }
+  return {
+    kind: "guidance",
+    title: "Choose Chat Agent",
+    guidance: chatReadiness.length > 0 ? formatProviderSetupGuidance(chatReadiness) : "No supported chat agent was found. Run poetic provider list after setup completes."
+  };
+}
+
+// src/cli/tui/dashboard-snapshot.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+// src/cli/tui/competition-view.ts
+import { Box, Text } from "ink";
+import React from "react";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) return value;
+  }
+  return void 0;
+}
+function readNumber(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function readNestedString(record, pathParts) {
+  let current = record;
+  for (const part of pathParts) {
+    if (!isRecord(current)) return void 0;
+    current = current[part];
+  }
+  return typeof current === "string" && current.trim().length > 0 ? current : void 0;
+}
+function resolveVariantLabel(candidate) {
+  const explicit = readString(candidate, ["variant"]);
+  if (explicit) return explicit;
+  const provider = readString(candidate, ["provider"]) ?? "unknown";
+  const model = readString(candidate, ["model", "resolvedModel"]);
+  const strategy = readString(candidate, ["strategy"]);
+  const parts = [provider, model, strategy].filter(Boolean);
+  return parts.join(":");
+}
+function resolveStatus(candidate) {
+  const topLevel = readString(candidate, ["status", "state"]);
+  if (topLevel) return topLevel;
+  const execStatus = readNestedString(candidate, ["outcome", "execution", "status"]);
+  if (execStatus) return execStatus;
+  const success = candidate.success;
+  if (typeof success === "boolean") return success ? "completed" : "failed";
+  return "pending";
+}
+function resolveGates(candidate) {
+  const gates = [];
+  const verificationStatus = readNestedString(candidate, ["outcome", "verification", "status"]);
+  if (verificationStatus) gates.push(`verification=${verificationStatus}`);
+  const gatesPassed = candidate.outcome;
+  if (isRecord(gatesPassed)) {
+    const verification = gatesPassed.verification;
+    if (isRecord(verification)) {
+      const passed = verification.deterministicGatesPassed;
+      if (typeof passed === "boolean") {
+        gates.push(`gates=${passed ? "passed" : "failed"}`);
+      }
+    }
+  }
+  return [...new Set(gates)];
+}
+function candidateHasResults(candidate) {
+  return typeof candidate.success === "boolean" || isRecord(candidate.outcome) || typeof candidate.completeness === "number";
+}
+function extractCompetitionVariants(record) {
+  const candidatesRaw = record.candidates;
+  if (!Array.isArray(candidatesRaw)) {
+    return { variants: [], isComplete: false };
+  }
+  const winnerRecord = record.winner;
+  const winnerVariant = isRecord(winnerRecord) ? readString(winnerRecord, ["variant"]) ?? void 0 : typeof record.winner === "string" ? record.winner : void 0;
+  const topStatus = readString(record, ["status", "state"]) ?? "";
+  const isComplete = !ACTIVE_RUN_STATUSES.has(topStatus.toLowerCase());
+  const rationale = readString(record, ["rationale", "reasoning", "judgeReasoning"]);
+  const seenVariants = /* @__PURE__ */ new Set();
+  const variants = [];
+  for (const raw of candidatesRaw) {
+    if (!isRecord(raw)) continue;
+    if (!candidateHasResults(raw)) continue;
+    const variantLabel = resolveVariantLabel(raw);
+    if (seenVariants.has(variantLabel)) continue;
+    seenVariants.add(variantLabel);
+    const provider = readString(raw, ["provider"]) ?? "unknown";
+    const strategy = readString(raw, ["strategy"]);
+    const status = resolveStatus(raw);
+    const score = readNumber(raw, ["completeness", "judgeScore", "score"]);
+    const costUsd = readNumber(raw, ["costUsd", "cost_usd"]);
+    const tokenCount = readNumber(raw, ["tokens", "totalTokens", "tokenCount"]);
+    const gates = resolveGates(raw);
+    const isWinner = winnerVariant !== void 0 && variantLabel === winnerVariant;
+    variants.push({
+      variant: variantLabel,
+      provider,
+      strategy,
+      status,
+      score,
+      costUsd,
+      tokenCount,
+      gates,
+      isWinner
+    });
+  }
+  if (isComplete) {
+    variants.sort((a, b) => {
+      const scoreA = a.score ?? -1;
+      const scoreB = b.score ?? -1;
+      return scoreB - scoreA;
+    });
+  } else {
+    variants.sort((a, b) => {
+      const aActive = ACTIVE_RUN_STATUSES.has(a.status.toLowerCase()) ? 0 : 1;
+      const bActive = ACTIVE_RUN_STATUSES.has(b.status.toLowerCase()) ? 0 : 1;
+      return aActive - bActive;
+    });
+  }
+  return { variants, winner: winnerVariant, rationale, isComplete };
+}
+
+// src/cli/tui/dashboard-snapshot.ts
+var MAX_DASHBOARD_RUNS = 16;
+var MAX_DASHBOARD_FILES_PER_DIR = 200;
+var MAX_PENDING_BLOCKERS = 8;
+var MAX_PENDING_BLOCKERS_PER_RUN = 3;
+var MAX_PROMOTED_DECISIONS = 20;
+var STALE_RUN_AGE_MS = 24 * 60 * 60 * 1e3;
+var INACTIVE_BACKGROUND_RUN_AGE_MS = 30 * 60 * 1e3;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNestedValue(record, pathParts) {
+  let current = record;
+  for (const part of pathParts) {
+    if (!isRecord2(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function readNestedString2(record, paths) {
+  for (const pathParts of paths) {
+    const current = readNestedValue(record, pathParts);
+    if (typeof current === "string" && current.trim().length > 0) {
+      return current;
+    }
+  }
+  return void 0;
+}
+function readNestedNumber(record, paths) {
+  for (const pathParts of paths) {
+    const value = readNestedValue(record, pathParts);
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function readNestedStringArray(record, paths) {
+  for (const pathParts of paths) {
+    const value = readNestedValue(record, pathParts);
+    if (Array.isArray(value)) {
+      return value.filter(
+        (entry) => typeof entry === "string" && entry.length > 0
+      );
+    }
+  }
+  return [];
+}
+function readJson(filePath) {
+  try {
+    if (timingFilesReadActive) {
+      timingFilesRead += 1;
+    }
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    const sanitized = sanitizeSynthesisArtifactForPersistence(parsed);
+    return isRecord2(sanitized) ? sanitized : null;
+  } catch {
+    return null;
+  }
+}
+function readString2(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readNumber2(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readBoolean(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function formatCost(value) {
+  if (value === void 0) return void 0;
+  if (value < 0.01) return `$${value.toFixed(4)}`;
+  return `$${value.toFixed(2)}`;
+}
+function formatTokens(value) {
+  if (value === void 0) return void 0;
+  return value >= 1e3 ? `${Math.round(value / 100) / 10}k` : String(value);
+}
+function readStringArray(record, keys) {
+  const values = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    const value = record[key];
+    if (!Array.isArray(value)) continue;
+    for (const item of value) {
+      if (typeof item === "string" && item.trim().length > 0) {
+        values.add(item.trim());
+      }
+    }
+  }
+  return [...values];
+}
+function collectFilesChanged(record) {
+  const files = new Set(
+    readStringArray(record, ["filesModified", "modifiedFiles", "changedFiles", "filesChanged"])
+  );
+  const results = Array.isArray(record.results) ? record.results : [];
+  for (const result of results) {
+    if (!isRecord2(result)) continue;
+    for (const file of readStringArray(result, [
+      "filesModified",
+      "modifiedFiles",
+      "changedFiles",
+      "filesChanged"
+    ])) {
+      files.add(file);
+    }
+  }
+  return [...files].sort();
+}
+function collectGates(record) {
+  const gates = [];
+  const verificationStatus = readNestedString2(record, [
+    ["outcome", "verification", "status"],
+    ["verification", "status"],
+    ["verification", "outcome"]
+  ]) ?? void 0;
+  if (verificationStatus) {
+    gates.push(`verification=${verificationStatus}`);
+  }
+  const deterministicGatesPassed = readNestedBoolean(record, [
+    ["outcome", "verification", "deterministicGatesPassed"],
+    ["verification", "deterministicGatesPassed"],
+    ["qualityGates", "passed"]
+  ]);
+  if (deterministicGatesPassed !== void 0) {
+    gates.push(`gates=${deterministicGatesPassed ? "passed" : "failed"}`);
+  }
+  const verificationPassed = readNestedBoolean(record, [["verification", "passed"]]);
+  if (!verificationStatus && verificationPassed !== void 0) {
+    gates.push(`verification=${verificationPassed ? "passed" : "failed"}`);
+  }
+  return [...new Set(gates)];
+}
+function readNestedBoolean(record, paths) {
+  for (const pathParts of paths) {
+    let current = record;
+    for (const part of pathParts) {
+      if (!isRecord2(current)) {
+        current = void 0;
+        break;
+      }
+      current = current[part];
+    }
+    if (typeof current === "boolean") {
+      return current;
+    }
+  }
+  return void 0;
+}
+function parseTimestampMs(value) {
+  if (!value) return void 0;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+function listJsonFiles(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path.join(dir, entry.name));
+  } catch {
+    return [];
+  }
+}
+function inactiveDashboardRunKey(run) {
+  return [
+    run.kind,
+    normalizeRunStatus(run.status),
+    normalizeDashboardText(run.title ?? run.id),
+    normalizeDashboardText(run.errorReason ?? "")
+  ].join("\0");
+}
+function extractTitle(prompt, intentOrGoal, fallbackId) {
+  const promptTitle = extractTitleFromPrompt(prompt);
+  if (promptTitle) return promptTitle;
+  const intentTitle = extractTitleFromPrompt(intentOrGoal);
+  if (intentTitle) return intentTitle;
+  return fallbackId.includes("-") ? fallbackId.split("-")[0] || fallbackId.slice(0, 12) : fallbackId.slice(0, 12);
+}
+function deriveStatus(record) {
+  const explicitStatus = readString2(record, ["status", "state", "submission_status", "submissionStatus", "phase"]) ?? readNestedString2(record, [
+    ["outcome", "execution", "status"],
+    ["outcome", "verification", "status"],
+    ["verification", "status"]
+  ]);
+  if (explicitStatus) return explicitStatus;
+  const success = readBoolean(record, ["success"]);
+  if (success === true) return "completed";
+  if (success === false) return "failed";
+  return "unknown";
+}
+function normalizeTerminationReason(reason) {
+  const normalized = reason.trim().toLowerCase();
+  if (normalized === "completed") return void 0;
+  if (normalized === "timeout" || normalized === "timedout" || normalized === "timed_out") {
+    return "timed-out";
+  }
+  if (normalized.startsWith("canceled_") || normalized.startsWith("cancelled_")) {
+    return "canceled";
+  }
+  if (normalized === "failed_crash") return "crashed";
+  if (normalized.startsWith("failed_"))
+    return normalized.slice("failed_".length).replace(/_/g, "-");
+  return normalized.replace(/_/g, "-");
+}
+function deriveErrorReason(record) {
+  const explicitReason = readString2(record, [
+    "errorMessage",
+    "error",
+    "failureReason",
+    "terminationSource"
+  ]);
+  if (explicitReason) return explicitReason;
+  if (readBoolean(record, ["success"]) !== false) return void 0;
+  if (readBoolean(record, ["timedOut"])) return "timed-out";
+  const terminationReason = readString2(record, ["terminationReason"]);
+  return terminationReason ? normalizeTerminationReason(terminationReason) : void 0;
+}
+function isVariantSidecarFile(filePath) {
+  const fileName = path.basename(filePath);
+  return fileName.endsWith(".lifecycle.json") || fileName.endsWith(".adaptive-setup.json");
+}
+function computeRunHealth(filePath, stateRecord) {
+  const healthStartMs = timingHealthActive ? Date.now() : 0;
+  try {
+    const snapshot = buildCompetitionHealthSnapshot({ stateFilePath: filePath, stateRecord });
+    const events = classifyRunHealth(snapshot);
+    const summary = summarizeRunHealth(events);
+    const topEvent = events[0];
+    if (!topEvent) return void 0;
+    const isNominal = topEvent.category === "working" || topEvent.category === "idle";
+    const stalledEvent = events.find((event) => event.category === "stalled");
+    const stalledForMs = stalledEvent && typeof stalledEvent.evidence[0]?.data?.staleForMs === "number" ? stalledEvent.evidence[0].data.staleForMs : void 0;
+    return {
+      topCategory: topEvent.category,
+      worstSeverity: summary.worstSeverity,
+      eventCount: isNominal ? 0 : events.length,
+      stalled: stalledEvent !== void 0,
+      stalledForMs
+    };
+  } catch {
+    return void 0;
+  } finally {
+    if (timingHealthActive) {
+      timingHealthMs += Date.now() - healthStartMs;
+    }
+  }
+}
+function summarizeFileWithRecord(filePath, kind) {
+  const record = readJson(filePath);
+  if (!record) return null;
+  const id = readString2(record, ["taskId", "task_id", "workflowId", "workflow_id", "runId", "id"]) ?? path.basename(filePath, ".json");
+  const status = deriveStatus(record);
+  const provider = readString2(record, ["provider", "providerId", "selectedProvider"]);
+  const model = readString2(record, ["model", "modelId", "selectedModel"]);
+  const stage = readString2(record, ["stage", "currentStage", "lifecycleState", "step"]);
+  const updatedAt = readString2(record, ["updatedAt", "updated_at", "completedAt", "startedAt"]);
+  const costUsd = readNumber2(record, ["costUsd", "cost_usd", "totalCostUsd"]);
+  const inputTokens = readNestedNumber(record, [
+    ["tokenUsage", "inputTokens"],
+    ["usage", "inputTokens"]
+  ]);
+  const outputTokens = readNestedNumber(record, [
+    ["tokenUsage", "outputTokens"],
+    ["usage", "outputTokens"]
+  ]);
+  const tokenCount = readNumber2(record, ["tokens", "totalTokens", "token_count", "tokensUsed"]) ?? (inputTokens !== void 0 || outputTokens !== void 0 ? (inputTokens ?? 0) + (outputTokens ?? 0) : void 0);
+  const filesChanged = collectFilesChanged(record);
+  const gates = collectGates(record);
+  const promptRaw = readString2(record, ["prompt"]);
+  const title = extractTitle(promptRaw, readString2(record, ["intent", "goal"]), id);
+  const startedAt = readString2(record, ["startedAt", "started_at", "createdAt"]);
+  const startedAtMs = parseTimestampMs(startedAt);
+  const elapsedMs = readNumber2(record, ["elapsedMs", "elapsed_ms", "durationMs", "duration_ms"]);
+  const strategy = readString2(record, ["strategy", "executionStrategy"]);
+  const score = readNestedNumber(record, [
+    ["outcome", "score"],
+    ["winner", "score"],
+    ["judgeSelectedTopPick", "score"]
+  ]) ?? readNumber2(record, ["score", "winnerScore"]);
+  const errorReason = deriveErrorReason(record);
+  const initiatedBy = readString2(record, ["initiatedBy", "initiated_by"]);
+  const health = kind === "competition" || kind === "background" ? computeRunHealth(filePath, record) : void 0;
+  const pid = readNumber2(record, ["pid"]);
+  const launcherPid = readNumber2(record, ["launcherPid"]);
+  const processGone = pid !== void 0 && isActiveRunStatus(status) && !isPidAlive(pid) ? true : void 0;
+  return {
+    summary: {
+      id,
+      kind,
+      status,
+      provider,
+      model,
+      stage,
+      cost: formatCost(costUsd),
+      costUsd,
+      tokens: formatTokens(tokenCount),
+      tokenCount,
+      filesChanged,
+      gates,
+      updatedAt,
+      sourcePath: filePath,
+      title,
+      startedAtMs,
+      elapsedMs,
+      strategy,
+      score,
+      errorReason,
+      initiatedBy,
+      health,
+      pid,
+      launcherPid,
+      processGone
+    },
+    record
+  };
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function pushDetailLine(lines, label, value) {
+  if (value && value.trim().length > 0) lines.push(`${label}: ${value}`);
+}
+function summarizeFilesChanged(record) {
+  const filesChangedArray = readNestedValue(record, ["execution", "filesChanged"]) ?? readNestedValue(record, ["outcome", "execution", "filesChanged"]);
+  const filesChanged = Array.isArray(filesChangedArray) ? filesChangedArray.length : readNestedNumber(record, [
+    ["execution", "filesChanged"],
+    ["outcome", "execution", "filesChanged"],
+    ["filesChanged"],
+    ["gitMetrics", "filesChanged"],
+    ["worktreeSummary", "filesChanged"]
+  ]);
+  const linesAdded = readNestedNumber(record, [
+    ["linesAdded"],
+    ["gitMetrics", "linesAdded"],
+    ["worktreeSummary", "insertions"]
+  ]);
+  const linesRemoved = readNestedNumber(record, [
+    ["linesRemoved"],
+    ["gitMetrics", "linesDeleted"],
+    ["worktreeSummary", "deletions"]
+  ]);
+  if (filesChanged === void 0 && linesAdded === void 0 && linesRemoved === void 0) {
+    return void 0;
+  }
+  return [
+    filesChanged !== void 0 ? `${filesChanged} files` : void 0,
+    linesAdded !== void 0 ? `+${linesAdded}` : void 0,
+    linesRemoved !== void 0 ? `-${linesRemoved}` : void 0
+  ].filter(Boolean).join(", ");
+}
+function collectArtifactPaths(record) {
+  return [
+    readNestedString2(record, [
+      ["execution", "artifactPath"],
+      ["outcome", "execution", "artifactPath"],
+      ["artifactPath"],
+      ["planArtifactPath"],
+      ["manifestPath"],
+      ["synthesisArtifactPath"],
+      ["workerPacketArtifactPath"]
+    ]),
+    ...readNestedStringArray(record, [["artifactPaths"], ["artifacts"]])
+  ].filter((entry) => Boolean(entry));
+}
+function extractGoalSatisfaction(record) {
+  if (readString2(record, ["command"]) !== "build") return void 0;
+  const gateValue = readNestedValue(record, ["goalSatisfactionGate"]) ?? readNestedValue(record, ["outcome", "goalSatisfactionGate"]);
+  if (!isRecord2(gateValue)) return void 0;
+  const status = readString2(gateValue, ["status"]) ?? "unknown";
+  const reason = readString2(gateValue, ["reason"]);
+  const gaps = readNestedStringArray(gateValue, [["gaps"]]);
+  const proposedFollowups = readNestedStringArray(gateValue, [["proposedFollowups"]]);
+  const followupIntent = readString2(gateValue, ["followupIntent", "proposedFollowupIntent"]) ?? (status === "unsatisfied" && (gaps.length > 0 || proposedFollowups.length > 0) ? [
+    "Follow up on goal-satisfaction gaps.",
+    ...gaps.map((gap) => `Gap: ${gap}`),
+    ...proposedFollowups.map((followup) => `Action: ${followup}`)
+  ].join("\n") : void 0);
+  return { status, reason, gaps, followupIntent };
+}
+function extractCompetition(record) {
+  const winnerRecord = readNestedValue(record, ["winner"]);
+  const winnerFallbackParts = isRecord2(winnerRecord) ? [readString2(winnerRecord, ["provider"]), readString2(winnerRecord, ["strategy"])].filter(
+    (part) => Boolean(part)
+  ) : [];
+  const winnerFromObject = isRecord2(winnerRecord) ? readString2(winnerRecord, ["variant"]) ?? (winnerFallbackParts.length > 0 ? winnerFallbackParts.join(":") : void 0) : void 0;
+  const winner = winnerFromObject ?? readNestedString2(record, [
+    ["winner"],
+    ["winnerVariant"],
+    ["declaredWinner"],
+    ["judgeSelectedTopPick", "variant"],
+    ["retainedWinner"]
+  ]);
+  const scoreNumber = readNestedNumber(record, [
+    ["winner", "score"],
+    ["winnerScore"],
+    ["score"],
+    ["outcome", "score"],
+    ["judgeSelectedTopPick", "score"]
+  ]);
+  const rationale = (isRecord2(winnerRecord) ? readString2(winnerRecord, ["winnerSelectionReason"]) : void 0) ?? readNestedString2(record, [["rationale"], ["reasoning"], ["judgeReasoning"], ["outcome"]]);
+  const competitionView = extractCompetitionVariants(record);
+  const variants = competitionView.variants.length > 0 ? competitionView.variants : void 0;
+  if (!winner && scoreNumber === void 0 && !rationale && !variants) return void 0;
+  return {
+    winner,
+    score: scoreNumber === void 0 ? void 0 : scoreNumber.toFixed(1),
+    rationale,
+    variants
+  };
+}
+function readTuiRunDetail(run) {
+  const lines = [];
+  const limitations = [];
+  let artifacts = [];
+  let filesChanged;
+  let goalSatisfaction;
+  let competition;
+  pushDetailLine(lines, "Kind", run.kind);
+  pushDetailLine(lines, "Run ID", run.id);
+  pushDetailLine(lines, "Status", run.status);
+  pushDetailLine(lines, "Provider", run.provider);
+  pushDetailLine(lines, "Model", run.model);
+  pushDetailLine(lines, "Stage", run.stage);
+  pushDetailLine(lines, "Cost", run.cost);
+  pushDetailLine(lines, "Tokens", run.tokens);
+  pushDetailLine(lines, "Updated", run.updatedAt);
+  if (run.sourcePath) {
+    pushDetailLine(lines, "Source", run.sourcePath);
+    const record = readJson(run.sourcePath);
+    if (record) {
+      pushDetailLine(lines, "Workflow", readString2(record, ["workflowId", "workflow_id"]));
+      pushDetailLine(lines, "Sprint", readNestedString2(record, [["execution", "sprintId"]]));
+      filesChanged = summarizeFilesChanged(record);
+      artifacts = collectArtifactPaths(record);
+      goalSatisfaction = extractGoalSatisfaction(record);
+      competition = run.kind === "competition" || run.kind === "variant" ? extractCompetition(record) : void 0;
+    } else {
+      limitations.push("Detail source could not be read; showing summary fields only.");
+    }
+  } else {
+    limitations.push("No source telemetry path is available for this run.");
+  }
+  limitations.push("Cancel is available only for a command spawned by this TUI session.");
+  limitations.push("Raw logs are available only for the currently spawned command or chat turn.");
+  if (!goalSatisfaction && run.kind !== "background") {
+    limitations.push("Goal-satisfaction follow-up is available only for build outcomes.");
+  }
+  return {
+    summary: run,
+    sourcePath: run.sourcePath,
+    lines,
+    artifacts,
+    filesChanged,
+    goalSatisfaction,
+    competition,
+    limitations
+  };
+}
+var summaryCache = /* @__PURE__ */ new Map();
+function summarizeFileCached(filePath, mtimeMs, kind) {
+  const cached = summaryCache.get(filePath);
+  if (cached && cached.mtimeMs === mtimeMs) {
+    if (isActiveRunStatus(cached.summary.status)) {
+      const processGone = cached.summary.pid !== void 0 ? !isPidAlive(cached.summary.pid) ? true : void 0 : cached.summary.processGone;
+      const health = (kind === "competition" || kind === "background") && cached.record !== void 0 ? computeRunHealth(filePath, cached.record) : cached.summary.health;
+      const healthChanged = !isSameRunHealth(cached.summary.health, health);
+      const livenessChanged = processGone !== cached.summary.processGone;
+      if (healthChanged || livenessChanged) {
+        const refreshed = { ...cached.summary, processGone, health };
+        summaryCache.set(filePath, { ...cached, mtimeMs, summary: refreshed });
+        return refreshed;
+      }
+    }
+    return cached.summary;
+  }
+  const summarized = summarizeFileWithRecord(filePath, kind);
+  if (summarized) {
+    const retainRecord = kind === "competition" || kind === "background";
+    summaryCache.set(filePath, {
+      mtimeMs,
+      summary: summarized.summary,
+      record: retainRecord ? summarized.record : void 0,
+      kind
+    });
+    return summarized.summary;
+  }
+  if (cached) {
+    return {
+      ...cached.summary,
+      status: `stale (last known: ${cached.summary.status})`
+    };
+  }
+  return null;
+}
+function isSameRunHealth(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.topCategory === b.topCategory && a.worstSeverity === b.worstSeverity && a.eventCount === b.eventCount && a.stalled === b.stalled && a.stalledForMs === b.stalledForMs;
+}
+function pruneSummaryCache(seenPaths) {
+  for (const key of summaryCache.keys()) {
+    if (!seenPaths.has(key)) {
+      summaryCache.delete(key);
+    }
+  }
+}
+function collectFromDir(repoRoot, relativeDir, kind, seenPaths) {
+  const dir = path.join(repoRoot, relativeDir);
+  return listJsonFiles(dir).filter((filePath) => kind !== "variant" || !isVariantSidecarFile(filePath)).map((filePath) => {
+    try {
+      return { filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_DASHBOARD_FILES_PER_DIR).map(({ filePath, mtimeMs }) => {
+    seenPaths.add(filePath);
+    const summary = summarizeFileCached(filePath, mtimeMs, kind);
+    const observedAtMs = parseTimestampMs(summary?.updatedAt) ?? mtimeMs;
+    return summary ? { summary, observedAtMs, mtimeMs } : null;
+  }).filter((entry) => entry !== null);
+}
+function collectFlywheelManifests(repoRoot, seenPaths) {
+  const flywheelDir = path.join(repoRoot, ".poetic/tmp/flywheel");
+  let entries;
+  try {
+    entries = fs.readdirSync(flywheelDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(flywheelDir, entry.name, "manifest.json")).map((filePath) => {
+    let mtimeMs = 0;
+    try {
+      mtimeMs = fs.statSync(filePath).mtimeMs;
+    } catch {
+    }
+    seenPaths.add(filePath);
+    const summary = summarizeFileCached(filePath, mtimeMs, "workflow");
+    if (!summary) return null;
+    const observedAtMs = parseTimestampMs(summary.updatedAt) ?? mtimeMs;
+    return { summary, observedAtMs, mtimeMs };
+  }).filter((entry) => entry !== null);
+}
+function parsePromotedDecision(record) {
+  const id = readString2(record, ["id"]);
+  const title = readString2(record, ["title"]);
+  const severity = readString2(record, ["severity"]);
+  const disposition = readString2(record, ["disposition"]);
+  if (!id || !title || !severity || disposition !== "pending") {
+    return null;
+  }
+  const sourcePr = readNumber2(record, ["sourcePr"]);
+  const detail = readStringArray(record, ["detail"]);
+  return {
+    id,
+    title,
+    severity,
+    ...sourcePr !== void 0 ? { sourcePr } : {},
+    disposition,
+    detail
+  };
+}
+function collectPromotedDecisions(repoRoot) {
+  const dir = path.join(repoRoot, ".poetic/telemetry/state/decisions");
+  const files = listJsonFiles(dir).map((filePath) => {
+    try {
+      return { filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_PROMOTED_DECISIONS);
+  const decisions = [];
+  for (const { filePath } of files) {
+    const record = readJson(filePath);
+    if (!record) continue;
+    const decision = parsePromotedDecision(record);
+    if (decision) {
+      decisions.push(decision);
+    }
+  }
+  return decisions;
+}
+function collectPendingBlockers(repoRoot, nowMs) {
+  const dir = path.join(repoRoot, ".poetic/blocker-answers");
+  let hiddenPendingBlockerCount = 0;
+  const pendingBlockers = listJsonFiles(dir).filter((filePath) => filePath.endsWith(".pending.json")).map((filePath) => {
+    try {
+      return { filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null).filter((entry) => nowMs - entry.mtimeMs <= STALE_RUN_AGE_MS).sort((a, b) => b.mtimeMs - a.mtimeMs).flatMap(({ filePath }) => {
+    const record = readJson(filePath);
+    if (!record) return [];
+    const runId = readString2(record, ["runId"]) ?? path.basename(filePath, ".pending.json");
+    const intent = readString2(record, ["intent"]);
+    const unanswered = Array.isArray(record.unanswered) ? new Set(
+      record.unanswered.filter(
+        (id) => typeof id === "string" && id.trim().length > 0
+      )
+    ) : /* @__PURE__ */ new Set();
+    const blockers = Array.isArray(record.blockers) ? record.blockers : [];
+    const visibleBlockers = blockers.filter(isRecord2).filter((blocker) => {
+      const blockerId = readString2(blocker, ["id"]);
+      return blockerId !== void 0 && unanswered.has(blockerId);
+    }).map((blocker) => ({
+      runId,
+      blockerId: readString2(blocker, ["id"]) ?? "unknown",
+      intent,
+      category: readString2(blocker, ["category"]),
+      severity: readString2(blocker, ["severity"]),
+      question: readString2(blocker, ["question"]) ?? "Unanswered blocker",
+      sourcePath: filePath
+    }));
+    hiddenPendingBlockerCount += Math.max(
+      0,
+      visibleBlockers.length - MAX_PENDING_BLOCKERS_PER_RUN
+    );
+    return visibleBlockers.slice(0, MAX_PENDING_BLOCKERS_PER_RUN);
+  });
+  hiddenPendingBlockerCount += Math.max(0, pendingBlockers.length - MAX_PENDING_BLOCKERS);
+  return {
+    pendingBlockers: pendingBlockers.slice(0, MAX_PENDING_BLOCKERS),
+    hiddenPendingBlockerCount
+  };
+}
+function runRecencyKey(run) {
+  const updated = run.updatedAt ? Date.parse(run.updatedAt) : Number.NaN;
+  if (Number.isFinite(updated)) return updated;
+  return run.startedAtMs ?? 0;
+}
+function selectActiveRun(runs) {
+  let selected;
+  let selectedKey = Number.NEGATIVE_INFINITY;
+  for (const run of runs) {
+    if (!isActiveRunStatus(run.status) || run.processGone === true) continue;
+    const key = runRecencyKey(run);
+    if (selected === void 0 || key >= selectedKey) {
+      selected = run;
+      selectedKey = key;
+    }
+  }
+  return selected;
+}
+function selectDashboardRuns(collectedRuns, nowMs) {
+  let hiddenStaleRunCount = 0;
+  const visibleRuns = [];
+  for (const run of collectedRuns) {
+    const ageMs = nowMs - run.observedAtMs;
+    const maxAgeMs = run.summary.kind === "background" && !isActiveRunStatus(run.summary.status) ? INACTIVE_BACKGROUND_RUN_AGE_MS : STALE_RUN_AGE_MS;
+    if (ageMs > maxAgeMs) {
+      hiddenStaleRunCount += 1;
+      continue;
+    }
+    visibleRuns.push(run);
+  }
+  const dedupedRuns = dedupeInactiveDashboardRuns(visibleRuns);
+  const runs = dedupedRuns.sort((a, b) => a.observedAtMs - b.observedAtMs || a.mtimeMs - b.mtimeMs).slice(-MAX_DASHBOARD_RUNS).map((entry) => entry.summary);
+  return { runs, hiddenStaleRunCount };
+}
+function dedupeInactiveDashboardRuns(runs) {
+  const selected = [];
+  const seenInactiveKeys = /* @__PURE__ */ new Set();
+  for (const run of [...runs].sort(
+    (a, b) => b.observedAtMs - a.observedAtMs || b.mtimeMs - a.mtimeMs
+  )) {
+    if (isActiveRunStatus(run.summary.status)) {
+      selected.push(run);
+      continue;
+    }
+    const key = inactiveDashboardRunKey(run.summary);
+    if (seenInactiveKeys.has(key)) continue;
+    seenInactiveKeys.add(key);
+    selected.push(run);
+  }
+  return selected;
+}
+function normalizeDashboardText(value) {
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+var GIT_INFO_CACHE_TTL_MS = 5e3;
+var gitInfoCache = /* @__PURE__ */ new Map();
+function readCurrentBranch(repoRoot) {
+  try {
+    return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).trim();
+  } catch {
+    return "HEAD";
+  }
+}
+function readChangedFiles(repoRoot) {
+  try {
+    return execFileSync("git", ["status", "--short"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => {
+      const normalized = line.trim();
+      const renamed = normalized.match(/^R\S*\s+(.+?)\s+->\s+(.+)$/);
+      if (renamed?.[2]) return renamed[2];
+      return line.slice(3).trim();
+    }).filter(Boolean).slice(0, 8);
+  } catch {
+    return [];
+  }
+}
+function readGitInfo(repoRoot) {
+  const nowMs = Date.now();
+  const cached = gitInfoCache.get(repoRoot);
+  if (cached && nowMs - cached.cachedAtMs < GIT_INFO_CACHE_TTL_MS) {
+    return { branch: cached.branch, changedFiles: cached.changedFiles };
+  }
+  const branch = readCurrentBranch(repoRoot);
+  const changedFiles = readChangedFiles(repoRoot);
+  gitInfoCache.set(repoRoot, { branch, changedFiles, cachedAtMs: nowMs });
+  return { branch, changedFiles };
+}
+var timingHealthMs = 0;
+var timingHealthActive = false;
+var timingFilesRead = 0;
+var timingFilesReadActive = false;
+function appendTuiTimingLine(repoRoot, startedAtMs, gitMs, healthMs, filesRead) {
+  try {
+    const timingPath = path.join(repoRoot, ".poetic/tmp/tui-timing.jsonl");
+    const line = JSON.stringify({
+      ts: new Date(startedAtMs).toISOString(),
+      totalMs: Date.now() - startedAtMs,
+      gitMs,
+      healthMs,
+      filesRead
+    });
+    fs.mkdirSync(path.dirname(timingPath), { recursive: true });
+    fs.appendFileSync(timingPath, `${line}
+`);
+  } catch {
+  }
+}
+function summarizeGateState(runs) {
+  return [...new Set(runs.flatMap((run) => run.gates ?? []))].slice(0, 4);
+}
+function sumCosts(runs) {
+  const total = runs.reduce((sum, run) => sum + (run.costUsd ?? 0), 0);
+  return total > 0 ? formatCost(total) : void 0;
+}
+function sumTokens(runs) {
+  const total = runs.reduce((sum, run) => sum + (run.tokenCount ?? 0), 0);
+  return total > 0 ? formatTokens(total) : void 0;
+}
+function readTuiDashboardState(repoRoot) {
+  const timingEnabled = readEnv(POETIC_TUI_TIMING).value === true;
+  const startedAtMs = timingEnabled ? Date.now() : 0;
+  if (timingEnabled) {
+    timingHealthMs = 0;
+    timingFilesRead = 0;
+    timingHealthActive = true;
+    timingFilesReadActive = true;
+  }
+  const nowMs = Date.now();
+  const seenPaths = /* @__PURE__ */ new Set();
+  const { runs, hiddenStaleRunCount } = selectDashboardRuns(
+    [
+      ...collectFromDir(repoRoot, ".poetic/telemetry/state/background", "background", seenPaths),
+      ...collectFromDir(repoRoot, ".poetic/telemetry/state/competitions", "competition", seenPaths),
+      ...collectFromDir(repoRoot, ".poetic/telemetry/state/variants", "variant", seenPaths),
+      ...collectFlywheelManifests(repoRoot, seenPaths)
+    ],
+    nowMs
+  );
+  pruneSummaryCache(seenPaths);
+  const { pendingBlockers, hiddenPendingBlockerCount } = collectPendingBlockers(repoRoot, nowMs);
+  const promotedDecisions = collectPromotedDecisions(repoRoot);
+  const activeRun = selectActiveRun(runs);
+  const gitStartMs = timingEnabled ? Date.now() : 0;
+  const { branch, changedFiles } = readGitInfo(repoRoot);
+  const gitMs = timingEnabled ? Date.now() - gitStartMs : 0;
+  if (timingEnabled) {
+    timingHealthActive = false;
+    timingFilesReadActive = false;
+    appendTuiTimingLine(repoRoot, startedAtMs, gitMs, timingHealthMs, timingFilesRead);
+  }
+  return {
+    repoRoot,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    branch,
+    changedFiles,
+    activeRun,
+    totalCost: sumCosts(runs),
+    totalTokens: sumTokens(runs),
+    gateSummary: summarizeGateState(runs),
+    runs,
+    pendingBlockers,
+    promotedDecisions,
+    hiddenPendingBlockerCount,
+    hiddenStaleRunCount
+  };
+}
+function createInitialTuiDashboardState(repoRoot) {
+  return {
+    repoRoot,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    branch: "...",
+    changedFiles: [],
+    gateSummary: [],
+    runs: [],
+    pendingBlockers: [],
+    promotedDecisions: [],
+    hiddenPendingBlockerCount: 0,
+    hiddenStaleRunCount: 0
+  };
+}
+
+// src/cli/tui/actions.ts
+var WARN_INTENT_LENGTH = 4e3;
+var KNOWN_ESTIMATE_PROVIDERS = /* @__PURE__ */ new Set([
+  "claude",
+  "cursor",
+  "codex",
+  "gemini",
+  "copilot",
+  "opencode"
+]);
+var pricingTable = new DefaultPricingTable();
+var POETIC_PACKAGE_VERSION = typeof package_default.version === "string" && package_default.version.trim() ? package_default.version.trim() : "0.0.0";
+function quoteArg(arg) {
+  if (/^[A-Za-z0-9_./:=@+-]+$/.test(arg)) return arg;
+  return JSON.stringify(arg);
+}
+function commandDisplay(executable, argv) {
+  return [executable.display, ...argv.map(quoteArg)].join(" ");
+}
+function createSandboxPosture(options) {
+  if (options.mode === "none") {
+    return {
+      ...options,
+      active: false,
+      boundaryAccepted: false,
+      provenance: "none",
+      display: "none"
+    };
+  }
+  const attestation = detectSandboxBoundaryAttestation(options.providerName, options.providerId);
+  const boundaryPolicy = resolveSandboxBoundaryPolicy(process.env.POETIC_SANDBOX_BOUNDARY_POLICY);
+  const boundaryAccepted = isSandboxBoundaryAccepted(attestation, boundaryPolicy);
+  const active = willSandboxBeActive(options.providerName, options.providerId);
+  const status = active ? "active" : "inactive";
+  return {
+    ...options,
+    active,
+    boundaryAccepted,
+    provenance: attestation.provenance,
+    display: `${options.mode} ${status} (${attestation.provenance})`
+  };
+}
+function createCommandSandboxPosture() {
+  return createSandboxPosture({
+    mode: "workspace-write",
+    providerName: "poetic-tui",
+    providerId: "poetic-tui"
+  });
+}
+function createReadOnlyChatSandboxPosture(provider) {
+  return createSandboxPosture({
+    mode: "read-only",
+    providerName: provider ?? "anchored-chat",
+    providerId: provider ?? "anchored-chat"
+  });
+}
+function resolvePoeticExecutable(argv = process.argv) {
+  const node = process.execPath;
+  const entryPath = argv[1];
+  const version = POETIC_PACKAGE_VERSION;
+  if (entryPath && (entryPath.endsWith(".js") || entryPath.endsWith(".ts"))) {
+    return {
+      command: node,
+      prefixArgs: [entryPath],
+      display: `${quoteArg(node)} ${quoteArg(entryPath)}`,
+      version
+    };
+  }
+  return {
+    command: "poetic",
+    prefixArgs: [],
+    display: "poetic",
+    version
+  };
+}
+function parseInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return { command: "chat", value: trimmed };
+  }
+  const match = /^\/([A-Za-z-]+)(?:\s+(.*))?$/.exec(trimmed);
+  const command = normalizeTuiCommand(match?.[1]?.toLowerCase() ?? "help");
+  const value = match?.[2]?.trim() ?? "";
+  switch (command) {
+    case "build":
+    case "plan-run":
+    case "next":
+    case "quickstart":
+    case "knowledge":
+    case "run":
+    case "compete":
+    case "fusion":
+    case "monitor":
+    case "answer":
+    case "clear":
+    case "chat":
+    case "help":
+    case "quit":
+      return { command, value };
+    default:
+      return { command: "help", value: command };
+  }
+}
+function buildKnowledgeArgv(value) {
+  const parts = value.split(/\s+/).filter((part) => part.length > 0);
+  const sub = parts[0]?.toLowerCase() ?? "status";
+  const rest = parts.slice(1);
+  switch (sub) {
+    case "status":
+      return ["knowledge", "status"];
+    case "clear":
+      return ["knowledge", "clear"];
+    case "declare":
+      return ["knowledge", "declare", rest.join(" ")];
+    case "resolve":
+      return ["knowledge", "resolve", rest[0] ?? ""];
+    case "offer": {
+      const refresh = rest.some((part) => part === "--refresh" || part === "refresh");
+      const guidanceWords = rest.filter((part) => part !== "--refresh" && part !== "refresh");
+      return [
+        "knowledge",
+        "offer",
+        ...refresh ? ["--refresh"] : [],
+        ...guidanceWords.length > 0 ? ["--guidance", guidanceWords.join(" ")] : []
+      ];
+    }
+    case "accept":
+      return ["knowledge", "accept", rest[0] ?? "", rest[1] ?? ""];
+    case "graduate":
+      return ["knowledge", "graduate", rest[0] ?? ""];
+    default:
+      return ["knowledge", "status"];
+  }
+}
+function buildArgv(command) {
+  switch (command.command) {
+    case "plan-run":
+      return ["plan", "create", "--decompose", command.value];
+    case "build":
+      return ["build", command.value];
+    case "next":
+      return ["next"];
+    case "quickstart":
+      return command.value ? ["quickstart", ...command.value.split(/\s+/).filter((part) => part.length > 0)] : ["quickstart"];
+    case "knowledge":
+      return buildKnowledgeArgv(command.value);
+    case "run":
+      return ["run", command.value];
+    case "compete":
+      return ["compete", command.value];
+    case "fusion":
+      return ["fusion", command.value];
+    case "monitor":
+      return command.value ? ["monitor", command.value, "--follow"] : ["monitor"];
+    case "answer":
+      return ["build"];
+    case "clear":
+      return [];
+    case "chat":
+      return [];
+    case "help":
+      return ["--help"];
+    case "quit":
+      return [];
+  }
+}
+function parseAnswerValue(value) {
+  const separator = value.indexOf("=");
+  if (separator <= 0) return {};
+  const lhs = value.slice(0, separator).trim();
+  const answer = value.slice(separator + 1).trim();
+  if (!lhs || !answer) return { answer: answer || void 0 };
+  const scopeSeparator = lhs.indexOf(":");
+  if (scopeSeparator > 0) {
+    const runId = lhs.slice(0, scopeSeparator).trim();
+    const blockerId = lhs.slice(scopeSeparator + 1).trim();
+    return {
+      runId: runId || void 0,
+      blockerId: blockerId || void 0,
+      answer
+    };
+  }
+  return { blockerId: lhs, answer };
+}
+function resolveBranch(repoRoot) {
+  return getCurrentBranch(repoRoot);
+}
+function costUnknown(reason) {
+  return {
+    status: "unknown",
+    label: "unknown",
+    reason
+  };
+}
+function costNotApplicable(reason) {
+  return {
+    status: "not_applicable",
+    label: "not applicable",
+    reason
+  };
+}
+function formatUsd(amount) {
+  if (amount < 0.01) return "<$0.01";
+  return `$${amount.toFixed(2)}`;
+}
+function estimatePreviewCost(params) {
+  const provider = params.provider.toLowerCase();
+  if (!params.taskPrompt.trim()) {
+    return costUnknown("No prompt text is available for a cost estimate.");
+  }
+  if (!KNOWN_ESTIMATE_PROVIDERS.has(provider)) {
+    return costUnknown(`No local pricing estimate is available for provider ${params.provider}.`);
+  }
+  try {
+    const estimate = estimateTaskCost(
+      {
+        taskPrompt: params.taskPrompt,
+        provider,
+        model: params.model,
+        strategy: params.strategy
+      },
+      pricingTable
+    );
+    const theoretical = estimate.isTheoreticalCost ? " theoretical" : "";
+    const modelSuffix = estimate.model ? `:${estimate.model}` : "";
+    if (estimate.estimatedCostUsd === null) {
+      return costUnknown(`No local pricing estimate is available for provider ${params.provider}.`);
+    }
+    return {
+      status: "estimated",
+      label: `${formatUsd(estimate.estimatedCostUsd)}${theoretical} (${estimate.confidence}, ${provider}${modelSuffix})`,
+      reason: params.reason,
+      estimatedUsd: estimate.estimatedCostUsd,
+      provider,
+      model: estimate.model,
+      confidence: estimate.confidence,
+      isTheoreticalCost: estimate.isTheoreticalCost,
+      assumptions: estimate.assumptions
+    };
+  } catch (error) {
+    return costUnknown(
+      `Local cost estimator failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function estimateDefaultProviderCost(params) {
+  try {
+    const resolved = resolveConfig(void 0, params.repoRoot, { strictSynthesisModel: false });
+    const provider = params.defaultProviderOverride ?? resolved.defaultProvider.value;
+    return estimatePreviewCost({
+      taskPrompt: params.taskPrompt,
+      provider,
+      model: params.defaultProviderOverride ? resolved.providerModels[provider]?.value ?? "auto" : resolved.defaultModel.value,
+      strategy: params.strategy ?? resolved.defaultStrategy.value,
+      reason: params.reason
+    });
+  } catch (error) {
+    return costUnknown(
+      `Could not resolve the default provider/model: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function chatActionDisplay(provider) {
+  return provider ? `TUI action: send read-only chat turn to ${provider}` : "TUI action: send read-only chat turn";
+}
+function createCommandPreview(options) {
+  const executable = options.executable ?? resolvePoeticExecutable();
+  const parsed = parseInput(options.input);
+  let argv = buildArgv(parsed);
+  const warnings = [];
+  const errors = [];
+  const branch = resolveBranch(options.repoRoot);
+  if (parsed.command === "help") {
+    const title = parsed.value ? `Unknown command: /${parsed.value}` : "Help";
+    if (parsed.value) {
+      errors.push(`Unknown command: /${parsed.value}`);
+    }
+    return {
+      kind: "help",
+      title,
+      argv,
+      argvDisplay: parsed.value ? commandDisplay(executable, argv) : "TUI action: show help",
+      executable,
+      canSubmit: false,
+      warnings,
+      errors,
+      branch,
+      sandbox: createSandboxPosture({
+        mode: "none",
+        providerName: "poetic-tui",
+        providerId: "poetic-tui"
+      }),
+      cost: costNotApplicable("Help preview does not run a provider.")
+    };
+  }
+  if (parsed.command === "chat") {
+    const provider = options.anchoredProvider;
+    if (!parsed.value) {
+      errors.push("Enter a message to chat.");
+    }
+    if (!provider) {
+      errors.push("No chat provider selected. Choose one with /model.");
+    }
+    if (!isAnchoredChatEnabled(process.env)) {
+      errors.push(`TUI chat is disabled by ${ANCHORED_CHAT_FEATURE_ENV}.`);
+    }
+    return {
+      kind: "chat",
+      title: "Chat preview",
+      argv,
+      argvDisplay: chatActionDisplay(provider),
+      executable,
+      canSubmit: errors.length === 0,
+      warnings,
+      errors,
+      branch,
+      anchorProvider: provider,
+      chatMessage: parsed.value,
+      sandbox: createReadOnlyChatSandboxPosture(provider),
+      cost: provider ? estimatePreviewCost({
+        taskPrompt: parsed.value,
+        provider,
+        // Mirror the model actually threaded into the chat turn: explicit
+        // user config only; undefined lets the estimator (like the provider
+        // CLI) fall back to its own default.
+        model: resolveTuiChatModel(options.repoRoot, provider),
+        reason: "Estimated from the anchored chat message and selected provider."
+      }) : costUnknown("No anchored provider is selected.")
+    };
+  }
+  let answerBlockerId;
+  let buildIntent = parsed.value;
+  if (parsed.command === "answer") {
+    const parsedAnswer = parseAnswerValue(parsed.value);
+    answerBlockerId = parsedAnswer.blockerId;
+    if (!parsedAnswer.blockerId || !parsedAnswer.answer) {
+      errors.push("/answer requires blockerId=value (or runId:blockerId=value).");
+    } else {
+      const pendingBlockers = readTuiDashboardState(options.repoRoot).pendingBlockers;
+      const matches = pendingBlockers.filter(
+        (blocker) => blocker.blockerId === parsedAnswer.blockerId && (parsedAnswer.runId === void 0 || blocker.runId === parsedAnswer.runId)
+      );
+      const pending = matches[0];
+      if (!pending) {
+        const scope = parsedAnswer.runId ? ` in run ${parsedAnswer.runId}` : "";
+        errors.push(`No pending blocker found for ${parsedAnswer.blockerId}${scope}.`);
+      } else if (matches.length > 1) {
+        const runIds = matches.map((match) => match.runId).join(", ");
+        errors.push(
+          `Blocker ${parsedAnswer.blockerId} appears in multiple runs (${runIds}); scope with runId:blockerId=value.`
+        );
+      } else if (!pending.intent) {
+        errors.push(
+          `Pending blocker ${parsedAnswer.blockerId} (run ${pending.runId}) does not include an intent; re-run planned build to regenerate.`
+        );
+      } else {
+        buildIntent = pending.intent;
+        argv = [
+          "build",
+          "--planned",
+          "--answer",
+          `${pending.runId}:${parsedAnswer.blockerId}=${parsedAnswer.answer}`,
+          pending.intent
+        ];
+        warnings.push(`Answers pending blocker ${parsedAnswer.blockerId} in run ${pending.runId}.`);
+      }
+    }
+  }
+  if (["build", "plan-run", "run", "compete", "fusion"].includes(parsed.command) && !parsed.value) {
+    errors.push(`/${parsed.command} requires an intent or task text.`);
+  }
+  if (parsed.command === "knowledge") {
+    const knowledgeParts = parsed.value.split(/\s+/).filter((part) => part.length > 0);
+    const knowledgeSub = knowledgeParts[0]?.toLowerCase() ?? "status";
+    const knowledgeRest = knowledgeParts.slice(1);
+    if (knowledgeSub === "declare" && knowledgeRest.length === 0) {
+      errors.push("/knowledge declare requires a stack spec (e.g. swift,swiftui,macos-26).");
+    } else if (knowledgeSub === "resolve" && knowledgeRest[0] !== "keep" && knowledgeRest[0] !== "accept") {
+      errors.push("/knowledge resolve requires keep or accept.");
+    } else if (knowledgeSub === "accept" && knowledgeRest.length < 2) {
+      errors.push("/knowledge accept requires <token> <all|id,id,...>.");
+    } else if (knowledgeSub === "graduate" && knowledgeRest.length === 0) {
+      errors.push("/knowledge graduate requires a review token from /knowledge offer.");
+    } else if (!["status", "declare", "clear", "resolve", "offer", "accept", "graduate"].includes(
+      knowledgeSub
+    )) {
+      errors.push(
+        `Unknown /knowledge subcommand '${knowledgeSub}' \u2014 use status, declare, clear, resolve, offer, accept, or graduate.`
+      );
+    }
+    if (["declare", "clear", "resolve", "accept", "graduate"].includes(knowledgeSub)) {
+      warnings.push("This writes knowledge/intent files in the repo (committed).");
+    }
+    if (knowledgeSub === "offer") {
+      warnings.push("Offer runs a resource search via the default ask provider.");
+    }
+  }
+  const isBuild = parsed.command === "build" || parsed.command === "answer";
+  let route;
+  let routeReason;
+  let blockerMode;
+  if (isBuild) {
+    if (buildIntent.length > WARN_INTENT_LENGTH && buildIntent.length <= MAX_BUILD_INTENT_LENGTH) {
+      warnings.push(
+        `Intent is ${buildIntent.length} characters; consider moving detail into a file.`
+      );
+    }
+    if (buildIntent.length > MAX_BUILD_INTENT_LENGTH) {
+      errors.push(`Intent exceeds the ${MAX_BUILD_INTENT_LENGTH}-character limit.`);
+    }
+    const routeExplanation = explainBuildRoute(
+      {
+        planned: parsed.command === "answer" || options.buildRouteOverride === "planned"
+      },
+      buildIntent
+    );
+    route = routeExplanation.route;
+    routeReason = routeExplanation.reason;
+    if (route === "planned") {
+      blockerMode = resolvePlanExecuteCliBlockerMode({});
+      if (branch === "HEAD") {
+        warnings.push("Detached HEAD: planned execution requires an active branch.");
+      } else if (isProtectedPipelineBranch(branch)) {
+        warnings.push(
+          `Protected branch '${branch}': create a run branch before planned execution.`
+        );
+      }
+    }
+  }
+  if (parsed.command === "compete") {
+    warnings.push("Competition can run multiple providers and may cost more than a build.");
+  }
+  if (parsed.command === "monitor" && !parsed.value) {
+    errors.push("/monitor requires a task ID.");
+  }
+  let cost;
+  if (isBuild) {
+    if (route === "planned") {
+      cost = costUnknown(
+        "Planned builds may decompose into multiple provider calls; providers are selected during execution."
+      );
+    } else {
+      cost = estimateDefaultProviderCost({
+        taskPrompt: buildIntent,
+        repoRoot: options.repoRoot,
+        reason: "Estimated from the build intent and resolved default provider/model.",
+        defaultProviderOverride: options.defaultProviderOverride
+      });
+    }
+  } else if (parsed.command === "run") {
+    cost = estimateDefaultProviderCost({
+      taskPrompt: parsed.value,
+      repoRoot: options.repoRoot,
+      reason: "Estimated from the run prompt and resolved default provider/model.",
+      defaultProviderOverride: options.defaultProviderOverride
+    });
+  } else if (parsed.command === "compete") {
+    cost = costUnknown(
+      "Competition provider/model selection and variant count are resolved at execution time."
+    );
+  } else if (parsed.command === "fusion") {
+    cost = costUnknown("Fusion panel providers and synthesis cost are resolved at execution time.");
+  } else if (parsed.command === "plan-run") {
+    cost = costUnknown(
+      "Planning uses the configured planning provider; final cost is known after the plan is created."
+    );
+  } else if (parsed.command === "quickstart") {
+    cost = costUnknown("Quickstart decides provider usage during execution.");
+  } else if (parsed.command === "knowledge" && (parsed.value.split(/\s+/)[0]?.toLowerCase() ?? "status") === "offer") {
+    cost = costUnknown("The knowledge offer runs a bounded resource search via the ask provider.");
+  } else {
+    cost = costNotApplicable("This preview does not start provider execution.");
+  }
+  return {
+    kind: isBuild ? "build" : "command",
+    title: parsed.command === "answer" ? `Answer ${answerBlockerId ?? "blocker"}` : isBuild ? "Build preview" : `${parsed.command} preview`,
+    argv,
+    argvDisplay: commandDisplay(executable, argv),
+    executable,
+    canSubmit: errors.length === 0,
+    warnings,
+    errors,
+    route,
+    routeReason,
+    branch,
+    blockerMode,
+    sandbox: createCommandSandboxPosture(),
+    cost
+  };
+}
+function createCommandPreviewFromAgentAction(options) {
+  const executable = options.executable ?? resolvePoeticExecutable();
+  const directInput = ["build", "run", "compete", "fusion"].includes(options.action.command) ? `/${options.action.command} ${options.action.command === "build" ? options.action.argv.at(-1) ?? "" : options.action.args.join(" ")}` : "/next";
+  const directPreview = createCommandPreview({
+    input: directInput,
+    repoRoot: options.repoRoot,
+    executable,
+    buildRouteOverride: options.action.command === "build" ? "planned" : void 0
+  });
+  const sandbox = options.action.risk === "read" ? createSandboxPosture({
+    mode: "none",
+    providerName: "poetic-tui",
+    providerId: "poetic-tui"
+  }) : directPreview.sandbox;
+  const warnings = options.action.risk === "managed-write" ? ["This suggested command writes Poetic-managed state after approval."] : directPreview.warnings;
+  return {
+    ...directPreview,
+    kind: options.action.command === "build" ? "build" : "command",
+    title: `Suggested: ${options.action.command}`,
+    argv: options.action.argv,
+    argvDisplay: commandDisplay(executable, options.action.argv),
+    executable,
+    canSubmit: true,
+    warnings,
+    errors: [],
+    sandbox,
+    cost: options.action.command === "build" ? costNotApplicable("Dry-run preview does not start provider execution.") : directPreview.cost,
+    suggestedAction: options.action
+  };
+}
+function createRunBranchName(intent) {
+  const slug = intent.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "poetic-build";
+  return path2.posix.join("run", slug);
+}
+
+export {
+  formatProviderName,
+  formatTuiFooterLabel,
+  formatElapsed,
+  formatTuiUserPromptLine,
+  formatTuiAssistantMessageContent,
+  shouldShowTuiChatWorkingIndicator,
+  shouldShowTuiChatTurnReceipt,
+  formatWorkingLine,
+  formatTuiChatCostUsd,
+  formatTurnReceipt,
+  readTuiRunDetail,
+  readTuiDashboardState,
+  createInitialTuiDashboardState,
+  formatTuiSelectedModel,
+  TUI_COMMANDS,
+  getTuiCommandSuggestions,
+  resolvePoeticExecutable,
+  createCommandPreview,
+  createCommandPreviewFromAgentAction,
+  createRunBranchName,
+  isExplicitDefaultProviderSource,
+  resolveTuiChatProvider,
+  preparePreviewSpawn,
+  resolveTuiImmediateCommandArgError,
+  resolveTuiImmediateCommand,
+  resolveTuiChatAvailable,
+  shouldExecuteTuiSuggestionImmediately,
+  shouldStartTuiPreviewImmediately,
+  resolveTuiOnboardingHome,
+  resolveTuiFirstRunProviderPrompt,
+  loadTuiActions,
+  promptSeparator,
+  resolveTuiBackendLabel,
+  resolveTuiChatModel,
+  resolveTuiDisplayedChatModel,
+  previewNeedsRunBranch,
+  countProposalQueueRows,
+  resolveTuiChatAgentPrompt
+};
+//# sourceMappingURL=chunk-TGQZHDY2.js.map