Add Copilot SDK-powered spec compiler with autopilot mode

[basiclines]

Motivation

The TUIKit spec compiler previously only generated prompt files for manual copy-paste into external agents. This PR adds a fully automated compile build command that uses the GitHub Copilot SDK to compile component specs into target code -- including multi-pass refinement, interactive CLI prompts, and an unattended autopilot mode.

Approach

The core addition is compile build, which orchestrates a Copilot SDK session to transform component specs into working code for any target (Bun, Node, Go, Rust). Key design decisions:

• Depth-first compilation philosophy: The prompt instructs the agent to produce fewer components with full interactivity and passing tests, rather than broad surface coverage that barely works. Each pass deepens quality before adding breadth.
• Multi-pass loop with agent-driven locking: After each pass the agent runs compile lock --component <Name> to bank completed work. Subsequent passes only recompile dirty (unlocked) specs.
• Autopilot mode (--autopilot): Auto-continues passes without user confirmation, capped at dirty_count + 5 max attempts. Useful for CI or unattended builds.
• Interactive CLI via @clack/prompts: Replaced the previous gum dependency with a pure JS solution -- model picker, reasoning effort, output dir, and pass confirmation all work in-terminal with no external binaries.
• Agent summary rendering: After each pass, the agent's markdown summary is rendered in a styled terminal box using marked + marked-terminal + boxen.
• Web browsing for dependency verification: The system prompt instructs the agent to verify library versions via web search before assuming packages don't exist (avoids knowledge cutoff issues).

Notable details

• The system prompt acts as an index -- it references spec files by relative path rather than inlining them. Coding sessions must run from the dist target folder so these paths resolve correctly.
• Non-TTY environments (piped input) skip all interactive prompts and use sensible defaults, making the command scriptable.
• reasoningEffort is only passed to models that support it (checked via ModelInfo.supportedReasoningEfforts).

Files changed

• scripts/compile.ts -- Main compiler: SDK integration, prompt generation, build loop, autopilot, agent locking, summary rendering
• package.json -- Added @clack/prompts, marked, marked-terminal, boxen
• README.md -- Comprehensive docs: commands table, build flags, autopilot, multi-pass workflow, manual prompt generation
• bun.lock -- Updated lockfile

[Copilot]

Pull request overview

Adds an automated compile build command that uses the GitHub Copilot SDK to compile TUIKit specs into target implementations, including an interactive CLI configuration flow, multi-pass refinement (with optional autopilot), and terminal rendering of agent summaries.

Changes:

• Implement Copilot SDK–driven build orchestration (session creation, streaming output, pass loop, metrics, summary rendering).
• Add interactive terminal prompts (model/effort/output dir) and autopilot multi-pass behavior.
• Update docs and dependencies to support the new build workflow and UI output.

Show a summary per file

File	Description
scripts/compile.ts	Adds compile build command, Copilot SDK session orchestration, multi-pass loop, clack prompts, and agent summary rendering.
package.json	Adds dependencies for prompts, markdown rendering, and Copilot SDK.
bun.lock	Updates lockfile for the newly added dependencies.
README.md	Documents the new compile build workflow, flags, multi-pass behavior, and manual prompt usage.

Copilot's findings

Tip

Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Comments suppressed due to low confidence (4)

scripts/compile.ts:1200

• The help text says --no-lock "Skip auto-lock after successful build", but the build flow doesn't perform any auto-locking in this script (locking only happens if compile lock is run). Update the flag description (or implement auto-locking) so CLI help matches actual behavior.

  --effort <level>  Reasoning effort: low | medium | high | xhigh (default: high)
  --verbose         Show full agent transcript (raw streaming output)
  --no-lock         Skip auto-lock after successful build
  --autopilot       Auto-run passes without confirmation (max: components + 5)

README.md:292

• The README says the prompt is written to <out>/_compile-prompt.md, but compile prompt currently writes to <out>/<target>/_compile-prompt.md (e.g. dist/go/_compile-prompt.md). Please update this path (and related examples) to match the actual output location, or change the command to write directly into <out>/.

The prompt is written to `<out>/_compile-prompt.md`. It contains:

README.md:301

• This note says the agent session should set its working directory to the dist target folder so relative spec paths resolve, but the generated prompt references specs like docs/schema.md, tokens/..., and components/... (relative to the repo root). Running from dist/<target> would make those paths incorrect. Either update the prompt to emit paths relative to the dist folder, or change this guidance to say the working directory must be the repo root (SPECS_DIR).

> **Important:** Any coding session that uses this prompt should set its working
> directory to the dist target folder (where `_compile-prompt.md` lives). The
> prompt references spec files using relative paths that resolve correctly only
> from that location.

scripts/compile.ts:768

• --no-lock is passed into cmdBuild(), but the system prompt still instructs the agent to run compile lock after finishing components/tokens. If --no-lock is meant to prevent locking, conditionally omit these instructions (or block lock writes via the permission handler) when the flag is set.

LOCKING COMPLETED COMPONENTS:
After you fully complete a component (implementation + tests passing + demo wired),
lock it by running:
  bun run compile lock --target ${target} --component <Name>
This records the component as compiled so it won't be recompiled in future runs.

• Files reviewed: 3/4 changed files
• Comments generated: 4

[Copilot]

Using approveAll for onPermissionRequest means the agent can perform arbitrary file and shell operations once the session starts, including outside the intended output directory. Consider using a custom permission handler that restricts writes/deletes/commands to outDir (and target-specific test/demo commands) to reduce the blast radius, especially for --autopilot/CI use.

[Copilot]

printSummary() reports the lock file as "updated" whenever --no-lock is not set, but cmdBuild() never calls writeLock()/cmdLock() (locking is only done if the agent happens to run compile lock). This makes the summary misleading and the --no-lock flag effectively a no-op. Either implement an actual auto-lock step (e.g., only when the session completed without errors) or change the summary/flag semantics to reflect agent-driven locking.

This issue also appears in the following locations of the same file:

• line 764
• line 1197