@scanton/phase2s 0.24.0 → 0.26.0

package/.phase2s/skills/deep-specify/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: deep-specify
-description: Structured spec interview — resolve ambiguity with Socratic questions before any code is written
+description: Structured spec interview — resolve ambiguity with Socratic questions, then output a 5-pillar spec consumable by phase2s goal
 model: smart
 triggers:
   - deep specify
@@ -14,9 +14,7 @@ triggers:
   - spec first
 ---
 
-You are a specification interviewer. Your job is to resolve ambiguity before any code is written. You ask sharp, targeted questions one at a time and synthesize the answers into a structured spec.
-
-This skill is ported from oh-my-codex's `$deep-interview` pattern, adapted for Phase2S.
+You are a specification interviewer. Your job is to resolve ambiguity before any code is written. You ask sharp, targeted questions one at a time and synthesize the answers into a 5-pillar structured spec.
 
 **Phase 1: Read context**
 Before asking anything, read any provided files, descriptions, or existing code. Identify the 3-5 most ambiguous or high-risk questions — the ones where a wrong assumption would cause the most rework. Prioritize questions about: scope boundaries, data shape, error handling, performance expectations, and who the user is.
@@ -31,41 +29,61 @@ For each question:
 
 Do not proceed to the spec until all questions are answered. If the user says "just pick one", make a choice and note the assumption explicitly in the spec.
 
-**Phase 3: Synthesize**
-After all answers, write a structured spec:
+**Phase 3: Synthesize — 5-pillar spec format**
 
-```
-SPEC: [slug / short name]
+After all answers, write a spec in this exact format and save it to `.phase2s/specs/YYYY-MM-DD-HH-MM-<slug>.md`. Create the directory if it does not exist.
+
+```markdown
+# Spec: {{title}}
+
+Generated: {{date}}
+Spec ID: {{slug}}
 
-INTENT
-What are we building and why? (2-3 sentences. Not a bulleted list. State the problem and the solution.)
+## Problem Statement
+{{self_contained_context — what are we building, why, for whom, and what problem does it solve. 2-4 sentences. Complete enough that someone who wasn't in this conversation can understand it.}}
 
-BOUNDARIES
-What is explicitly in scope? (Concrete. Not "handle errors" — say "return HTTP 400 with {error: string} for invalid input".)
-- [concrete item 1]
-- [concrete item 2]
+## Acceptance Criteria
+1. {{criterion — independently testable, specific, not vague}}
+2. {{criterion}}
+3. {{criterion}}
 
-NON-GOALS
-What are we explicitly NOT building? (Be blunt. This prevents scope creep.)
-- [item 1]
-- [item 2]
+## Constraint Architecture
+**Must Do:** {{hard requirements — things that are non-negotiable}}
+**Cannot Do:** {{explicit non-goals and off-limits approaches}}
+**Should Prefer:** {{style, architectural, or implementation preferences}}
+**Should Escalate:** {{situations where the executor should stop and ask the user}}
 
-CONSTRAINTS
-Performance, security, compatibility, time, or cost limits that affect design choices. Omit if none.
+## Decomposition
+### Sub-task 1: {{name}}
+- **Input:** {{what this sub-task receives or reads}}
+- **Output:** {{what this sub-task produces or modifies}}
+- **Success criteria:** {{how to know this sub-task is done}}
 
-SUCCESS CRITERIA
-How will we know it's done? Each criterion should be independently testable.
-- [ ] [testable criterion 1]
-- [ ] [testable criterion 2]
+### Sub-task 2: {{name}}
+- **Input:** {{input}}
+- **Output:** {{output}}
+- **Success criteria:** {{success criteria}}
+
+(repeat for each sub-task, ordered by dependency)
+
+## Evaluation Design
+| Test Case | Input | Expected Output |
+|-----------|-------|-----------------|
+| {{test name}} | {{input or scenario}} | {{expected result}} |
+
+## Eval Command
+{{command to run to validate the spec is complete, e.g. "npm test" or "npm test -- --grep 'rate limiting'"}}
 ```
 
-Save to `.phase2s/specs/YYYY-MM-DD-<slug>.md`. Create the directory if it does not exist.
+**Deriving eval design:** If the user says "just use npm test" or doesn't provide specific test cases, derive the eval design from the acceptance criteria — write one test case per criterion that describes what a passing test would look like. Do not force the user to enumerate test cases manually if they have a test suite.
+
+**Decomposition guidance:** Break into 2-6 sub-tasks, each representing a distinct, independently implementable unit of work. Ordered by dependency (sub-task 2 can depend on sub-task 1 being done). Each sub-task should take roughly 15-45 minutes of focused implementation work.
 
 **Gate:**
 End every session with:
 ```
-SPEC READY: .phase2s/specs/YYYY-MM-DD-<slug>.md
-NEXT: run /plan or /autoplan to start implementation planning
+SPEC READY: .phase2s/specs/YYYY-MM-DD-HH-MM-<slug>.md
+NEXT: run `phase2s goal .phase2s/specs/YYYY-MM-DD-HH-MM-<slug>.md` to execute autonomously
 ```
 
 If the user provides context (file paths, a description, a task), read it before asking questions.

package/README.md

@@ -1,21 +1,12 @@
 # Phase2S
 
-Phase2S is a personal AI coding assistant you run in your terminal. You type questions about your code, ask it to review files, debug problems, or implement a feature — and it answers using your ChatGPT subscription, OpenAI API key, Anthropic API key, or a local Ollama model.
+Three things Phase2S does that most AI coding tools don't:
 
-Think of it as a slash-command layer on top of AI. Instead of typing "please review this file for security issues and flag each problem with a severity level", you type `/review src/core/auth.ts` and get a structured, consistent answer every time.
+1. **Runs on your ChatGPT subscription** — If you pay for ChatGPT Plus or Pro, you can use that same subscription to power a full coding assistant in your terminal. No API key, no per-token billing. The $20/month you're already paying starts pulling its weight.
 
-```
-you > /review src/core/agent.ts
-assistant > Reviewing src/core/agent.ts...
-
-  CRIT: The `maxTurns` check runs after tool execution, not before.
-        An LLM that loops tool calls can exceed the limit by one turn.
+2. **Gives Claude Code a second opinion** — If you use Claude Code as your daily driver, Phase2S plugs in as an MCP server and gives Claude a tool to call that runs your plan through GPT from a completely different model with completely different training. Before Claude executes anything big, it gets challenged by a second AI that has no stake in agreeing with it.
 
-  WARN: `getConversation()` returns the live object, not a copy.
-        Callers that mutate it will corrupt the conversation state.
-
-  NIT:  Inline comment on line 47 is stale — describes old batch behavior.
-```
+3. **Executes specs autonomously** — Write a spec describing what you want built and how you'll know it's done. Run `phase2s goal your-spec.md`. Phase2S breaks it into sub-tasks, implements each one, runs your tests, checks whether the results match your criteria, and retries with failure analysis if anything falls short. You come back when it's done.
 
 ---
 
@@ -23,9 +14,7 @@ assistant > Reviewing src/core/agent.ts...
 
 Requires [Node.js](https://nodejs.org) >= 20.
 
-**Option A: ChatGPT Plus or Pro subscription (recommended)**
-
-No API key, no per-token billing. All 29 skills work.
+**If you have ChatGPT Plus or Pro (recommended)**
 
 ```bash
 npm install -g @openai/codex @scanton/phase2s
@@ -33,9 +22,9 @@ codex auth
 phase2s
 ```
 
-**Option B: OpenAI API key**
+`codex auth` opens a browser window and logs into your ChatGPT account. You do it once. After that, `phase2s` uses your subscription automatically — no API keys, no credits to manage.
 
-Unlocks token-by-token streaming and model-per-skill routing.
+**If you have an OpenAI API key**
 
 ```bash
 npm install -g @scanton/phase2s
@@ -44,9 +33,7 @@ export PHASE2S_PROVIDER=openai-api
 phase2s
 ```
 
-**Option C: Anthropic API key**
-
-Run all 29 skills on Claude 3.5 Sonnet (or any Anthropic model).
+**If you have an Anthropic API key**
 
 ```bash
 npm install -g @scanton/phase2s
@@ -55,9 +42,7 @@ export PHASE2S_PROVIDER=anthropic
 phase2s
 ```
 
-**Option D: Local Ollama (free, private, offline)**
-
-No API keys. Runs entirely on your machine after the initial model pull.
+**If you want to run everything locally (free, private, no internet)**
 
 ```bash
 npm install -g @scanton/phase2s
@@ -68,110 +53,207 @@ phase2s
 
 ---
 
-## Quick start
+## Feature 1: Your ChatGPT subscription, in your terminal
 
-Once you're at the `you >` prompt:
+Most people who pay for ChatGPT Plus use it by opening a browser tab and typing. Phase2S turns it into a programmable coding tool you can use from the command line, from scripts, and from inside Claude Code.
 
 ```
-you > /review src/core/agent.ts      — code review with CRIT/WARN/NIT tagging
-you > /diff                          — review all uncommitted changes
-you > /satori add rate limiting      — implement + test + retry until green
-you > /health                        — code quality score (tests, types, lint)
-you > /remember                      — save a project convention to memory
+you > /review src/core/auth.ts
+
+  CRIT: session.destroy() is called without await on line 83.
+        If it rejects (Redis timeout, etc.), the error is silently dropped
+        and the response goes out before the session is actually cleared.
+
+  WARN: The JWT expiry check on line 47 uses Date.now() directly.
+        Clock skew between your server and the token issuer can cause
+        valid tokens to fail. Use a small leeway (±30s) instead.
+
+  NIT:  The error message on line 91 says "auth failed" but should say
+        "session_expired" to match the error codes in api-errors.ts.
 ```
 
-One-shot mode (no REPL):
+```
+you > /satori add rate limiting to the API
 
-```bash
-phase2s run "/explain src/core/agent.ts"   # routes through the explain skill
-phase2s run --dry-run "/satori add auth"   # preview which skill + model, no execution
+-- Attempt 1 --
+[creates src/utils/rate-limiter.ts]
+[creates src/middleware/rate-limit.ts]
+[registers middleware in app.ts]
+[writes tests in test/middleware/rate-limit.test.ts]
+npm test: FAIL — bucket not clearing on window expiry
+
+-- Attempt 2 --
+[fixes resetAt logic in RateLimiter.check()]
+npm test: PASS (23 tests)
+
+Done in 2 attempts.
 ```
 
-Tab completion (bash/zsh):
+The 29 built-in skills cover the full development loop: specify, plan, implement, test, review, debug, ship, deploy. All of them run on your subscription.
 
-```bash
-eval "$(phase2s completion bash)"          # add to ~/.bashrc for persistent completion
-phase2s run "/exp<TAB>"                    # completes to /explain
+[Full skill list →](docs/skills.md)
+
+---
+
+## Feature 2: Claude Code + Phase2S adversarial review
+
+If you use Claude Code, here's the problem: one model reviewing its own work has blind spots. Claude agrees with Claude. The same training data, the same biases, the same failure modes.
+
+Phase2S solves this by plugging into Claude Code as an MCP server. When Claude is about to execute a plan, it can call Phase2S — which runs the same plan through GPT using your ChatGPT subscription — and get back a structured challenge:
+
+```
+VERDICT: CHALLENGED
+STRONGEST_CONCERN: The token bucket resets per-request rather than per-window.
+OBJECTIONS:
+1. RateLimiter.check() increments the counter and checks it in the same call.
+   When the window expires, the bucket resets on the next request — meaning
+   a client can always make exactly one request immediately after the window
+   closes, even if they were throttled. The reset should happen on a fixed
+   schedule, not lazily on first request.
+2. The middleware is registered after the auth middleware in app.ts line 34.
+   Unauthenticated requests bypass rate limiting entirely.
+APPROVE_IF: Fix the window reset logic and move middleware before auth.
 ```
 
-Resume your last session:
+Claude gets specific, falsifiable objections from a model that wasn't involved in writing the plan. You see the verdict. You decide whether to proceed.
+
+**Setup takes about 2 minutes.** [Step-by-step guide →](docs/claude-code.md)
+
+---
+
+## Feature 3: The dark factory
+
+Write a spec. Run one command. Come back when it's done.
+
+`phase2s goal` reads your spec, breaks it into sub-tasks, implements each one through the `/satori` skill (which runs implement → test → retry until green), runs your eval command, checks whether your acceptance criteria actually passed, and if they didn't — analyzes what broke, figures out which sub-tasks need to be re-run, and tries again with that failure context.
+
+It keeps going until all criteria pass or it runs out of attempts.
 
 ```bash
-phase2s --resume
+# Write the spec interactively
+phase2s
+you > /deep-specify add pagination to the search endpoint
+
+# Execute it autonomously
+phase2s goal .phase2s/specs/2026-04-04-11-00-pagination.md
 ```
 
----
+```
+Goal executor: Pagination for search endpoint
+Sub-tasks: 3 | Eval: npm test | Max attempts: 3
+
+=== Attempt 1/3 ===
+Running sub-task: Cursor-based pagination logic
+[satori: implement → test → retry until green]
+
+Running sub-task: API response format update
+[satori: implement → test → retry until green]
+
+Running sub-task: Frontend page controls
+[satori: implement → test → retry until green]
+
+Running evaluation: npm test
 
-## What's included
+Acceptance criteria:
+  ✗ Returns correct next_cursor on paginated results
+  ✓ Returns 20 items per page by default
+  ✓ next_cursor is null on last page
 
-29 built-in skills across 6 categories. A few highlights:
+Retrying 1 sub-task(s): Cursor-based pagination logic
 
-- `/satori` — implement a task, run `npm test`, retry on failure (up to 3 times). Stops when tests are green, not when the model thinks it's done.
-- `/consensus-plan` — planner + architect + critic passes before producing a plan. Catches the errors that only show up in implementation.
-- `/deep-specify` — Socratic interview before writing code. Saves a spec with Intent, Boundaries, and Success criteria.
-- `/debug` — reproduce, isolate, fix, and verify a bug end-to-end.
-- `/remember` — save project conventions to persistent memory. Injected into every future session automatically.
-- `/skill` — create a new `/command` from inside Phase2S. Three questions, no YAML editing.
-- `/land-and-deploy` — push, open a PR, merge it, wait for CI, confirm the land. Picks up where `/ship` leaves off.
+=== Attempt 2/3 ===
+Running sub-task: Cursor-based pagination logic
+[satori: implement → test → retry until green]
 
-List everything:
+Running evaluation: npm test
+
+Acceptance criteria:
+  ✓ Returns correct next_cursor on paginated results
+  ✓ Returns 20 items per page by default
+  ✓ next_cursor is null on last page
+
+✓ All acceptance criteria met after 2 attempt(s).
+```
+
+This uses your ChatGPT subscription for all the implementation work. No API key needed.
+
+[Full dark factory guide →](docs/dark-factory.md)
+
+---
+
+## All 29 skills
+
+```
+you > /review src/auth.ts        — code review: CRIT / WARN / NIT
+you > /diff                      — review all uncommitted changes
+you > /satori add pagination     — implement + test + retry until green
+you > /deep-specify add OAuth    — spec interview → 5-pillar spec file
+you > /consensus-plan add OAuth  — planner + architect + critic passes
+you > /debug logout fails        — reproduce, isolate, fix, verify
+you > /investigate why 500s      — evidence trail to root cause
+you > /health                    — code quality score (tests, types, lint)
+you > /audit                     — secrets scan, dependency CVEs, injection
+you > /ship                      — diff review + commit message
+you > /land-and-deploy           — push, PR, CI wait, merge
+you > /remember                  — save a project convention to memory
+you > /retro                     — weekly velocity and pattern analysis
+```
 
 ```bash
-phase2s skills
+phase2s skills        # full list with model tier badges
+phase2s skills --json # machine-readable for scripts
 ```
 
+[Skills reference →](docs/skills.md)
+
 ---
 
 ## Docs
 
-- [GitHub Actions](docs/github-action.md) — `uses: scanton/phase2s@v1` reference, inputs, outputs, examples
-- [Getting started](docs/getting-started.md) — full setup walkthrough, first session, first skill call
-- [Skills reference](docs/skills.md) — all 29 skills with examples and arguments
-- [Workflows](docs/workflows.md) — real development sessions: feature, debug, review, weekly rhythm
-- [Memory and persistence](docs/memory.md) — session resume, `/remember`, what Phase2S writes to disk
-- [Writing custom skills](docs/writing-skills.md) — SKILL.md format, frontmatter fields, examples
-- [Advanced](docs/advanced.md) — streaming, tool loop, model routing (requires API key)
-- [Claude Code integration](docs/claude-code.md) — MCP server setup, cross-model adversarial review
-- [Configuration](docs/configuration.md) — `.phase2s.yaml` reference, environment variables
+- [Getting started](docs/getting-started.md) — first install, first session, all four provider options
+- [Dark factory](docs/dark-factory.md) — write a spec, run `phase2s goal`, get a feature
+- [Claude Code integration](docs/claude-code.md) — MCP setup, adversarial review, CLAUDE.md routing rules
+- [Skills reference](docs/skills.md) — all 29 skills with examples
+- [Workflows](docs/workflows.md) — real development sessions end to end
+- [Memory and persistence](docs/memory.md) — session resume, `/remember`, what gets saved
+- [Writing custom skills](docs/writing-skills.md) — create your own `/commands`
+- [GitHub Action](docs/github-action.md) — `uses: scanton/phase2s@v1` for CI (requires API key)
+- [Advanced](docs/advanced.md) — streaming, model routing, tool allow/deny
+- [Configuration](docs/configuration.md) — `.phase2s.yaml` and environment variables
 
 ---
 
 ## Roadmap
 
-- [x] Codex CLI provider (uses ChatGPT subscription, no API key required)
+- [x] Codex CLI provider (ChatGPT subscription, no API key required)
 - [x] 29 built-in skills across 6 categories
-- [x] SKILL.md compatibility with `~/.codex/skills/`
-- [x] Smart skill argument parsing (file paths vs. context strings)
-- [x] File sandbox: tools reject paths outside the project directory, including symlink escapes
-- [x] 365 tests covering all tools, core modules, agent integration, and the GitHub Action (`npm test`)
-- [x] CI: runs `npm test` on every push and PR (GitHub Actions, Node.js 22)
-- [x] Direct OpenAI API provider with live tool calling
-- [x] Anthropic API provider — Claude 3.5 Sonnet and family, all 29 skills
-- [x] Ollama provider — local models, offline, no API keys required
-- [x] Streaming output — responses stream token-by-token
-- [x] `npm install -g @scanton/phase2s`
-- [x] Session persistence — auto-save after each turn, `--resume` to continue
-- [x] Model-per-skill routing — `fast_model` / `smart_model` tiers in `.phase2s.yaml`
-- [x] Satori persistent execution — retry loop with shell verification, context snapshots, attempt logs
-- [x] Consensus planning — planner + architect + critic passes
-- [x] Claude Code MCP integration — all skills available as Claude Code tools via `phase2s mcp`
-- [x] `/adversarial` skill — cross-model adversarial review with structured output
-- [x] Persistent memory — `/remember` saves learnings to `.phase2s/memory/learnings.jsonl`
-- [x] `/skill` meta-skill — create new skills from inside Phase2S
-- [x] Session file security — session files written with `mode: 0o600` (owner-only)
-- [x] `/land-and-deploy` skill — push, PR, CI wait, merge, deploy confirmation via `gh` CLI
-- [x] Model tier badges in `phase2s skills` output — `[fast]` / `[smart]` per skill at a glance
-- [x] `phase2s run --dry-run "/explain foo"` — preview skill routing without executing
-- [x] Typed input hints in REPL — boolean shows `(yes/no)`, enum shows `[option1/option2]`
-- [x] `phase2s skills --json` — machine-readable skill list for scripts and tooling
-- [x] Clean install — no deprecation warnings from `npm install -g @scanton/phase2s`
-- [x] npm publish — `@scanton/phase2s` on npm, `npm install -g @scanton/phase2s`
-- [x] Multi-turn skills — `{{ASK: question?}}` inline prompts in SKILL.md templates
-- [x] Shell completion — `eval "$(phase2s completion bash)"` for tab-complete in bash/zsh
-- [x] Tool allow/deny — `tools:` and `deny:` in `.phase2s.yaml` restrict agent tool access
-- [x] Headless browser tool — navigate, click, type, screenshot, evaluate JS via Playwright (opt-in: `browser: true`)
-- [x] GitHub Action — `uses: scanton/phase2s@v1` runs any skill in CI, posts results as PR comments and Step Summaries
-- [ ] Real Codex streaming (JSONL stdout parsing)
+- [x] File sandbox: tools reject paths outside project directory, including symlink escapes
+- [x] 389 tests covering all tools, core modules, agent integration, and goal executor
+- [x] CI: runs `npm test` on every push and PR
+- [x] OpenAI API provider with live tool calling
+- [x] Anthropic API provider — Claude 3.5 Sonnet and family
+- [x] Ollama provider — local models, offline, no API keys
+- [x] Streaming output
+- [x] Session persistence — auto-save + `--resume`
+- [x] Model-per-skill routing — `fast_model` / `smart_model` tiers
+- [x] Satori persistent execution — retry loop with shell verification
+- [x] Consensus planning — planner + architect + critic
+- [x] Claude Code MCP integration — all skills as Claude Code tools
+- [x] `/adversarial` — cross-model adversarial review
+- [x] Persistent memory — `/remember` + auto-inject into sessions
+- [x] `/skill` — create new skills from inside Phase2S
+- [x] `/land-and-deploy` — push, PR, CI wait, merge
+- [x] Model tier badges in `phase2s skills` output
+- [x] `--dry-run` for skill routing preview
+- [x] Typed input hints in REPL
+- [x] `phase2s skills --json`
+- [x] Shell completion — `eval "$(phase2s completion bash)"`
+- [x] Tool allow/deny in `.phase2s.yaml`
+- [x] Headless browser tool via Playwright
+- [x] GitHub Action — `uses: scanton/phase2s@v1`
+- [x] `phase2s goal <spec.md>` — dark factory: spec in, feature out
+- [x] 5-pillar spec format — `/deep-specify` output feeds directly into `phase2s goal`
+- [x] Real Codex streaming (JSONL stdout parsing) — step-by-step feedback for multi-step tasks
 
 ---
 

package/dist/src/cli/goal.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Goal executor — "dark factory" mode.
+ *
+ * Reads a 5-pillar spec file, breaks it into sub-tasks, runs each through
+ * /satori (implement + test + retry), checks acceptance criteria against eval
+ * output, retries failed sub-tasks with failure context, and loops until all
+ * criteria pass or max attempts are exhausted.
+ *
+ * Usage: phase2s goal <spec-file> [--max-attempts <n>]
+ */
+import { Agent } from "../core/agent.js";
+import { type Spec, type SubTask } from "../core/spec-parser.js";
+export interface GoalOptions {
+    maxAttempts?: string;
+}
+export interface GoalResult {
+    success: boolean;
+    attempts: number;
+    criteriaResults: Record<string, boolean>;
+}
+export declare function runGoal(specFile: string, options?: GoalOptions): Promise<GoalResult>;
+export declare function buildSatoriContext(subtask: SubTask, constraints: Spec["constraints"], failureContext?: string): string;
+export declare function checkCriteria(criteria: string[], evalOutput: string, agent: Agent): Promise<Record<string, boolean>>;
+export declare function analyzeFailures(failing: string[], evalOutput: string, spec: Spec, agent: Agent): Promise<string>;
+export declare function identifyFailedSubtasks(failing: string[], decomposition: SubTask[], failureContext: string, agent: Agent): Promise<SubTask[]>;
+/**
+ * Run a shell command, capturing stdout + stderr.
+ * NEVER throws on non-zero exit — non-zero exit = test failures = valid output.
+ * On timeout, returns a timeout message + any partial output captured.
+ */
+export declare function runCommand(cmd: string, timeoutMs?: number): Promise<string>;
+//# sourceMappingURL=goal.d.ts.map

package/dist/src/cli/goal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goal.d.ts","sourceRoot":"","sources":["../../../src/cli/goal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,OAAO,EAAa,KAAK,IAAI,EAAE,KAAK,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAI5E,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAiH9F;AAMD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,EAChC,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAwBR;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAAE,EAClB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAwClC;AAeD,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EAAE,EACjB,aAAa,EAAE,OAAO,EAAE,EACxB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,OAAO,EAAE,CAAC,CA8BpB;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,SAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBlF"}