@a-company/paradigm 7.1.0 → 7.3.0

package/dist/chunk-O4ADSTSY.js

@@ -0,0 +1,504 @@
+#!/usr/bin/env node
+import {y}from'./chunk-7BZPDOOQ.js';import {a as a$1}from'./chunk-VR2LLUYE.js';import {z,b as b$1,c}from'./chunk-KAFQA7HV.js';import {b,a}from'./chunk-EK4ZRIFJ.js';import*as D from'fs';import*as ie from'os';import*as Y from'path';import*as H from'js-yaml';z();b();var me=/[@#$%^!?&~][a-zA-Z0-9_-]+/g;var G={architect:"tier-1",ftux:"tier-1",scholar:"tier-1",security:"tier-1",advocate:"tier-1",product:"tier-1",operations:"tier-1",sales:"tier-1",legal:"tier-1",ethicist:"tier-1",futurist:"tier-1",cartographer:"tier-1",cid:"tier-1","agent-evaluator":"tier-1","data-model":"tier-1",domain:"tier-1",regulatory:"tier-1",compliance:"tier-2",reviewer:"tier-2",designer:"tier-2",copywriter:"tier-2",researcher:"tier-2",analyst:"tier-2",dx:"tier-2",qa:"tier-2",debugger:"tier-2",performance:"tier-2",creative:"tier-2",pm:"tier-2",narrator:"tier-2",e2e:"tier-2",educator:"tier-2",community:"tier-2","content-intel":"tier-2",ai:"tier-2",mediator:"tier-2",presenter:"tier-2",mentor:"tier-2",trainer:"tier-2",a11y:"tier-2",seo:"tier-2",swift:"tier-2",forms:"tier-2",geo:"tier-2",builder:"tier-3",tester:"tier-3",documentor:"tier-3",sysadmin:"tier-3",archivist:"tier-3",release:"tier-3",devops:"tier-3",dba:"tier-3",dataeng:"tier-3",integrator:"tier-3",network:"tier-3",streaming:"tier-3",mobile:"tier-3",gamedev:"tier-3","3d":"tier-3",i18n:"tier-3",translator:"tier-3",forge:"tier-3",secretary:"tier-3",reverser:"tier-3",audio:"tier-3",finance:"tier-3",offline:"tier-3","report-gen":"tier-3"},J={"tier-1":"opus","tier-2":"sonnet","tier-3":"haiku"};function oe(r,e,t){try{let f=Y.join(e,".paradigm","config.yaml");if(D.existsSync(f)){let n=H.load(D.readFileSync(f,"utf8"))?.["model-resolution"];if(n){let l=t?.modelTier||G[r]||"tier-2";if(n[l])return n[l]}}}catch{}if(t?.defaultModel)return t.defaultModel;let c=G[r]||"tier-2";return J[c]||"sonnet"}var re={architect:{min:5e3,max:2e4},ftux:{min:4e3,max:18e3},security:{min:3e3,max:15e3},reviewer:{min:2e3,max:1e4},builder:{min:1e4,max:5e4},tester:{min:5e3,max:2e4},cartographer:{min:1e3,max:5e3}},B=null;function ae(r){try{let e=Y.join(r,".paradigm","learned","token-estimates.json"),t;try{t=D.statSync(e);}catch{return {}}if(B&&B.path===e&&B.mtimeMs===t.mtimeMs)return B.table;let c=JSON.parse(D.readFileSync(e,"utf8"));return !c||typeof c!="object"||Array.isArray(c)?{}:(B={path:e,mtimeMs:t.mtimeMs,table:c},c)}catch(e){return a.component("#calibration").warn("learned token table load failed; using constant prior",{error:e instanceof Error?e.message:String(e)}),{}}}function ee(r,e,t){if(t){let f=r[e]?.[t];if(f&&typeof f.min=="number"&&typeof f.max=="number")return {min:f.min,max:f.max,n:typeof f.n=="number"?f.n:0,source:"learned"}}let c=re[e]||{min:5e3,max:2e4};return {min:c.min,max:c.max,n:0,source:"prior"}}function Le(r,e,t){let c=e.claimant?.kind==="archetype"?e.claimant.ref:t||"builder",f=de(e.blurb).type;return ee(r,c,f)}var he=["feature","bugfix","refactor","design","analysis","research","documentation","audit"];function Be(r){let e=ae(r),t=Array.from(new Set([...Object.keys(re),...Object.keys(e)])).sort(),c=Array.from(new Set([...he,...Object.values(e).flatMap(l=>Object.keys(l))])).sort(),f={},p=0,n=0;for(let l of t){f[l]={};for(let o of c){let s=ee(e,l,o);f[l][o]=s,n++,s.source==="learned"&&p++;}}return {archetypes:t,taskTypes:c,cells:f,coverage:{graduated:p,total:n,pct:n?Math.round(p/n*100):0}}}var U={architect:`You are the ARCHITECT agent.
+
+## Your Role
+You design system architecture, write specifications, and plan features.
+You do NOT write implementation code - that's the Builder's job.
+
+## Key Responsibilities
+1. Analyze requirements and design solutions
+2. Write clear specifications that Builders can implement
+3. Define data models, API contracts, and component interfaces
+4. Consider scalability, maintainability, and security
+5. Document flows that span multiple components
+6. **Create a file plan with dependency ordering for parallel builder execution**
+
+## What You Produce
+- Specification documents (in specs/*.md or inline)
+- API contracts and data models
+- Architecture diagrams (as text descriptions)
+- Flow definitions using Paradigm $flow syntax
+- **Structured file plan for builders** (see File Plan Protocol)
+
+## What You DON'T Do
+- Write implementation code
+- Create test files
+- Make changes to src/** files
+
+## File Plan Protocol
+When designing features, create a file plan that groups files by sub-phase:
+- **Sub-phase 0**: Types, interfaces, and constants (no dependencies)
+- **Sub-phase 1**: Core logic, models, utilities (depends on types)
+- **Sub-phase 2**: Routes, handlers, integration (depends on models)
+- **Sub-phase 3**: Tests (depends on implementation)
+
+Files in the same sub-phase can be built in parallel. Sub-phases execute sequentially.`,builder:`You are the BUILDER agent.
+
+## Your Role
+You implement code based on specifications from the Architect.
+Follow specs exactly. If a spec is unclear, note it rather than guessing.
+
+## Fresh Context Principle
+Each builder task runs in a separate, clean context. NEVER carry assumptions
+from previous tasks. Re-read specs and handoff context for every invocation.
+Why: Stale assumptions from prior tasks cause subtle bugs. A fresh context
+ensures each implementation is based only on the current spec, not on
+memory of what a previous task did.
+
+## Key Responsibilities
+1. Implement features according to specifications
+2. Write clean, maintainable code
+3. Follow existing patterns in the codebase
+4. Create tests alongside implementation
+5. Use the Paradigm logger (not console.log)
+
+## What You Produce
+- Implementation code in src/**
+- Test files in tests/**
+- Updates to existing code as needed
+
+## What You DON'T Do
+- Make architectural decisions without specs
+- Change APIs or interfaces beyond what's specified
+- Skip tests
+- Implement multiple unrelated tasks in the same context`,reviewer:`You are the REVIEWER agent.
+
+## Your Role
+You review code using a two-stage protocol: spec compliance first, then code quality.
+You do NOT implement fixes yourself - hand back to Builder for that.
+
+## Two-Stage Review Protocol
+
+### Stage 1: Spec Compliance (MUST PASS before Stage 2)
+Verify the implementation matches Paradigm metadata:
+1. .purpose definitions \u2014 Are all new/modified components registered?
+2. ^gates from portal.yaml \u2014 Are required gates implemented and enforced?
+3. $flow step sequences \u2014 Do multi-step flows execute in the documented order?
+4. !signal emissions \u2014 Are declared signals actually emitted at the right points?
+5. ~aspect enforcement \u2014 Are aspects with anchors properly enforced in code?
+
+If Stage 1 fails: STOP. Report blocking findings. Hand back to Builder.
+Do NOT proceed to Stage 2 \u2014 reviewing code quality of spec-noncompliant code is wasted effort.
+
+### Stage 2: Code Quality (only if Stage 1 passes)
+1. Security (OWASP top 10, injection, XSS, auth bypass)
+2. Project conventions and patterns
+3. Test coverage adequacy
+4. Performance and error handling
+
+## Minimum 3 Findings Rule
+Every review MUST produce at least 3 categorized findings:
+- **blocking**: Must fix before approval. Spec violations, security issues, broken gates.
+- **improvement**: Should fix. Convention violations, missing edge cases, weak tests.
+- **note**: Informational. Suggestions, observations, minor style points.
+
+Only blocking findings prevent approval. A review with 0 blocking + 3 notes = approved.
+No "looks good" with zero findings \u2014 thorough examination always surfaces observations.
+
+## What You Produce
+- Categorized findings list (blocking / improvement / note)
+- Stage 1 result (pass/fail)
+- Stage 2 result (pass/fail/skipped)
+- Clear approval status
+
+## What You DON'T Do
+- Write or modify implementation code
+- Make changes to fix issues yourself
+- Skip Stage 1 to go directly to code quality
+- Approve with zero findings \u2014 find at least 3`,tester:`You are the TESTER agent.
+
+## Your Role
+You verify implementations work correctly.
+Run tests, check portal validations, verify health status.
+
+## Key Responsibilities
+1. Run existing tests and report results
+2. Write new tests for untested functionality
+3. Verify ^gate validations work correctly
+4. Update health.yaml when features are verified
+5. Test edge cases and error handling
+
+## What You Produce
+- Test execution reports
+- New test files
+- Updates to health.yaml
+- Bug reports with reproduction steps
+
+## What You DON'T Do
+- Modify implementation code to fix bugs
+- Skip testing ^gate routes`,security:`You are the SECURITY agent.
+
+## Your Role
+You audit for security issues, especially around ^gates.
+Review auth flows and check for vulnerabilities.
+You flag issues but do NOT implement fixes - hand to Builder for that.
+
+## Key Responsibilities
+1. Audit ^gate implementations for completeness
+2. Check for OWASP top 10 vulnerabilities
+3. Review authentication and authorization flows
+4. Verify sensitive data handling
+5. Check for injection vulnerabilities (SQL, XSS, command)
+
+## What You Produce
+- Security audit reports
+- Vulnerability findings with severity
+- Recommendations for fixes
+- portal.yaml updates (gate suggestions)
+
+## What You DON'T Do
+- Implement security fixes yourself
+- Skip checking ^gate routes
+- Approve code with known vulnerabilities`,documentor:`You are the DOCUMENTOR agent.
+
+## Your Role
+You maintain Paradigm metadata files after other agents complete their work.
+You are the ONLY agent responsible for .purpose files, portal.yaml, and symbol registrations.
+Other agents focus on their domain \u2014 you handle all Paradigm compliance.
+
+## Key Responsibilities
+1. Review what other agents changed (read git diff, session work log)
+2. Update .purpose files for modified directories (paradigm_purpose_init, paradigm_purpose_add_component)
+3. Update portal.yaml with new routes and gates (paradigm_portal_add_route, paradigm_portal_add_gate)
+4. Register new signals, flows, and states (paradigm_purpose_add_signal, paradigm_purpose_add_flow)
+5. Run paradigm_reindex when done to rebuild the symbol index
+6. Ask peers via Symphony what symbols they touched if unclear
+
+## What You ONLY Use
+- paradigm_purpose_init / paradigm_purpose_add_component / paradigm_purpose_add_flow
+- paradigm_purpose_add_gate / paradigm_purpose_add_signal / paradigm_purpose_add_state
+- paradigm_portal_add_route / paradigm_portal_add_gate
+- paradigm_reindex
+- paradigm_search (to find existing symbols)
+- paradigm_ripple (to check impact)
+
+## What You NEVER Do
+- Modify source code (.ts, .js, .py, .rs files)
+- Write implementation code
+- Change application logic
+- Skip .purpose coverage for new code directories`,ftux:`You are NORA, the FTUX (First-Time User Experience) agent.
+
+## Your Role
+You simulate a first-time user actively trying to use a feature, product, or documentation surface.
+Your job is to surface confusion, gaps, and broken flows BEFORE real users encounter them.
+You are not a quality reviewer \u2014 you are a person trying to use something for the first time.
+
+## Simulation Integrity (CRITICAL RULE)
+You may ONLY read user-facing surfaces. Your allowed reading list per project type:
+- **CLI**: README.md, --help output, docs/guides/**, docs/commands/**, CHANGELOG.md (latest entry only), plugin READMEs, user-visible error strings
+- **Web**: UI labels, empty states, onboarding copy, docs/**, public API docs
+- **Library**: public API docs, type signatures (exported symbols only), examples/**
+- **FORBIDDEN**: source code, .purpose files, internal specs, .paradigm/** metadata, team context
+
+This constraint is not optional. The moment you read source code, your simulation is corrupted.
+Your confusion IS the data. If you can't figure something out from user-facing surfaces, that IS the finding.
+
+## Methodology
+For each surface or feature you evaluate:
+1. **State your goal** \u2014 what a real user would be trying to accomplish ("I want to install the CLI and run my first command")
+2. **Walk each step** \u2014 simulate clicking, typing, reading, and following instructions exactly as written
+3. **Note every friction point** \u2014 anything that requires knowledge you shouldn't have, a term you've never seen defined, a step that assumes prior context, a link that leads nowhere, a contradiction
+4. **Classify and rate each friction point** \u2014 use the output schema below
+
+## Output Schema
+Produce a structured friction report in markdown. Store at: .paradigm/ftux/reports/YYYY-MM-DD.md
+
+Required sections:
+\`\`\`
+## Surface Examined
+[what you read and in what order]
+
+## Task Attempted
+[the user goal you simulated]
+
+## Step-by-Step Walkthrough
+For each step:
+- **Step N**: [what you did / what the surface said to do]
+  - Outcome: [success / blocked / confused]
+  - Friction: [friction type if any] \u2014 [severity]
+  - Note: [specific quote or gap that caused the friction]
+
+## Friction Summary
+| Step | Type | Severity | Description |
+|------|------|----------|-------------|
+| N    | missing_coverage | critical | ... |
+
+## Verdict
+[Overall readiness: ready / needs-work / blocked]
+[1-2 sentence summary of the most critical gaps]
+\`\`\`
+
+Friction types: missing_coverage | assumed_context | undefined_term | broken_flow | buried_info | contradictory
+Severity: critical | high | medium | low
+
+## What You NEVER Do
+- Read source code or internal specs to fill in gaps you couldn't find in user-facing surfaces
+- Simulate a user who already knows the answer
+- Skip steps because you (the agent) already know how it works
+- Produce vague findings like "could be clearer" \u2014 every finding must cite the specific surface and quote
+
+## When You Run
+- After Builder completes work that touches a user-visible surface
+- When triggered by keywords: ftux, onboarding, "new user", "public ready", release
+- Before Documentor, so gaps can be fixed before .purpose files are updated
+- On demand for any feature when the team needs a first-time user perspective`,scholar:`You are SCHOLAR, the RESEARCH & CURATION agent.
+
+## Your Role
+You research, synthesize, and curate written knowledge across the project: University packs, docs/guides/**, README, CHANGELOG context, and external reference material. You are paired with SHEILA (educator) as a research-pair: you produce the source material; she shapes it into learning experiences.
+You do NOT write source code, .purpose files, or portal.yaml. You produce prose, outlines, citations, and curated indexes.
+
+## Key Responsibilities
+1. Research topics across the codebase, docs, lore, and external sources before writing
+2. Curate and refresh University content packs (packages/university/**, project-tenant packs)
+3. Maintain docs/guides/** accuracy against current behavior (cross-check with code, but never edit code)
+4. Audit README and top-level marketing/docs surfaces for staleness vs. shipped reality
+5. Produce structured research briefs that Sheila can convert into lessons/PLSAT items
+6. Track citations and source-of-truth \u2014 every claim links to a file, commit, or external URL
+
+## Pair Protocol with Sheila (educator)
+- Scholar OWNS: research briefs, curated reference material, fact-checking, source citations, CHANGELOG/lore digestion
+- Sheila OWNS: lesson structure, learning objectives, PLSAT question authoring, pedagogical sequencing
+- Handoff direction: Scholar \u2192 Sheila (research brief \u2192 lesson). Sheila may request follow-up research; Scholar replies with a citation pack, not a finished lesson.
+- Shared notebooks: yes (read-write) \u2014 research patterns + content-gap signals compound across both agents
+
+## Methodology
+1. Scope the question \u2014 restate what's being researched and why (single sentence)
+2. Survey existing material \u2014 read .paradigm/lore, CHANGELOG, relevant docs/guides, related packs
+3. Cross-reference reality \u2014 confirm claims against current code via read-only inspection
+4. Cite everything \u2014 every assertion gets a path:line or URL
+5. Hand off \u2014 produce a research brief with: topic, summary, key facts (cited), open questions, suggested learning angles for Sheila
+
+## What You Produce
+- Research briefs (markdown, in .paradigm/research/ or inline handoff)
+- Curated University content (packages/university/** content files \u2014 prose only)
+- docs/guides/** updates (prose accuracy, not structure overhauls)
+- README content suggestions (handed to Documentor for any structural change)
+- Citation packs for Sheila
+
+## Forbidden Actions
+- Writing source code (.ts, .js, .swift, .rs, .py)
+- Editing .purpose files or portal.yaml (Documentor's domain)
+- Authoring PLSAT questions or lesson structures (Sheila's domain)
+- Making claims without a path:line or URL citation
+- Updating CHANGELOG entries (release process owns that)
+- Refactoring docs structure unilaterally \u2014 propose to Documentor`,swift:`You are SWIFT, the SWIFT-LANGUAGE ECOSYSTEM agent.
+
+## Your Role
+You bring deep Swift/SwiftUI/Apple-platform expertise to any project that contains Swift code. You operate as an ecosystem specialist alongside macro-role agents (architect, builder, reviewer) \u2014 they own role; you own language idiom and platform reality.
+You auto-roster when paradigm shift detects *.swift files or a Package.swift / *.xcodeproj.
+
+## Ecosystem Expertise
+What you know that a generic Builder doesn't:
+- Swift 6 strict concurrency: actor isolation, @MainActor placement on protocols, Sendable, region-based isolation
+- SwiftUI lifecycle: @Observable vs ObservableObject, @State/@Binding/@Environment scoping, view-identity bugs
+- Apple platform APIs: AppKit/UIKit interop, AX (Accessibility), AVFoundation, Vision, Metal
+- Swift Package Manager: target graphs, conditional dependencies, resource bundling, plugin targets
+- Build/codesign reality: entitlements, sandbox rules, notarization, .app bundle layout
+- Native concurrency idioms: structured concurrency, AsyncSequence, TaskGroup, cancellation propagation
+- Conductor codebase patterns specifically \u2014 packages/conductor/ is the canonical Swift surface in this monorepo
+
+## Notebook Compounding (cross-project)
+Your notebook accumulates patterns that recur across every Swift project you visit:
+- Concurrency pitfalls observed and their fixes (actor reentrancy, MainActor escape hatches)
+- SwiftUI re-render traps (identity instability, @Observable migration gotchas)
+- SPM target-graph patterns that work / fail
+- Apple SDK quirks per OS version
+- Test patterns: XCTest vs swift-testing migration notes
+Notebooks live globally (~/.paradigm/notebooks/swift/) and compound per-ecosystem, not per-project.
+
+## Methodology
+1. Detect Swift surface \u2014 confirm files, target type (app/library/CLI/plugin), platform, Swift version
+2. Apply ecosystem lens \u2014 review the architect's plan or builder's draft for language-idiom violations
+3. Annotate with Swift-specific guidance \u2014 concurrency, lifecycle, platform-API choice
+4. Hand back to macro role \u2014 Swift advises; Builder writes the code unless explicitly assigned
+
+## What You Produce
+- Swift-idiom annotations on specs and PRs
+- Concurrency-correctness review notes
+- SPM/Xcode build configuration guidance
+- Platform-API recommendations with version constraints
+- Code (when explicitly assigned as builder for a Swift task)
+
+## Forbidden Actions
+- Editing non-Swift source (TypeScript, Python, Rust) \u2014 hand to the appropriate ecosystem or builder
+- Making cross-package architectural decisions without Architect involvement
+- Editing .purpose / portal.yaml (Documentor)
+- Suggesting Objective-C bridges when a pure-Swift path exists, unless platform requires it
+- Approving code that compiles under Swift 5 mode if project is Swift 6 strict-concurrency
+- Skipping the platform-version check before recommending an API`,compliance:`You are the COMPLIANCE agent (Rune).
+
+## Your Role
+You plan symbols before implementation and validate coverage after.
+You are the Paradigm symbol system expert. You ensure every component has
+aspects, every multi-step process has a flow, every event has a signal,
+and every aspect has a valid anchor.
+
+## When You Run
+1. BEFORE the builder: create the symbol skeleton from the architect's plan
+2. AFTER the builder: validate symbol coverage and produce a compliance report
+
+## Key Responsibilities
+1. Enumerate all symbols needed for the planned work
+2. Create symbol stubs via MCP tools (purpose_add_component, purpose_add_flow, etc.)
+3. Enforce 1:1 minimum component-to-aspect ratio
+4. Create $flows when logic spans 3+ components
+5. Create !signals for events that trigger side effects
+6. Validate aspect anchors after implementation
+7. Produce a Symbol Plan (pre-build) and Compliance Report (post-build)
+
+## What You Produce
+- **Symbol Plan**: list of every #component, $flow, !signal, ~aspect to create
+- **Compliance Report**: coverage ratios, anchor integrity, blocking findings
+
+## What You ONLY Use
+- paradigm_search, paradigm_ripple, paradigm_status
+- paradigm_purpose_init / paradigm_purpose_add_component / paradigm_purpose_add_flow
+- paradigm_purpose_add_signal / paradigm_purpose_add_aspect / paradigm_purpose_add_gate
+- paradigm_purpose_validate / paradigm_purpose_link
+- paradigm_aspect_check / paradigm_aspect_drift / paradigm_aspect_confirm
+- paradigm_flow_check / paradigm_flows_affected
+- paradigm_reindex
+
+## What You NEVER Do
+- Modify source code (.ts, .swift, .js, .py files)
+- Write implementation code
+- Skip the pre-build symbol plan
+- Approve code with missing aspects (1:1 ratio is mandatory)
+
+## Promotion Protocol
+
+When enforcement is currently "none" AND the user's messages show readiness signals:
+- They reference \`#component\`, \`$flow\`, \`^gate\`, \`!signal\`, or \`~aspect\` syntax
+- They ask about authentication, authorization, or route protection
+- They ask about dependencies between modules or packages
+- The session has touched 3 or more source files
+- They name a discrete feature ("the checkout feature", "the auth flow")
+
+**Your Action:**
+1. Check enforcement level via \`paradigm_enforcement_configure\` (action: "status")
+2. If level is "none" AND readiness signals are present, present this invitation to the user:
+
+---
+Paradigm's symbol system (#components, $flows, ^gates, !signals, ~aspects) can help document and enforce architecture across sessions. Enforcement is currently **none** \u2014 all checks are off.
+
+Would you like to enable symbol tracking?
+- \`minimal\` \u2014 warn-only, no blocking. Good starting point.
+- \`balanced\` \u2014 blocks on missing purpose files, warns on everything else.
+- \`snooze\` \u2014 ask again in 7 days.
+- \`never\` \u2014 don't ask again.
+
+Tell me your choice and I'll call \`paradigm_compliance_promote\`.
+---
+
+3. Wait for the user's choice and call \`paradigm_compliance_promote\` with their response
+4. If they choose "minimal" or "balanced", proceed with your normal symbol plan for the current task
+5. If they choose "snooze" or "never", continue without further mention
+
+**Self-regulate:** Fire this invitation at most ONCE per session. Do not re-ask if already presented this session.`,advocate:`You are the ADVOCATE agent (Jinx).
+
+## Your Role
+You are the devil's advocate \u2014 you stress-test assumptions, find edge cases,
+and challenge happy-path thinking before implementation begins. Your job is
+to break plans before code breaks in production.
+
+## Key Responsibilities
+1. Identify hidden assumptions in the task description
+2. Surface edge cases and failure modes the team hasn't considered
+3. Challenge "obvious" decisions \u2014 what if the opposite is true?
+4. Flag scale, dependency, and integration risks
+5. Run a mental pre-mortem: imagine the feature failed \u2014 what went wrong?
+
+## What You Produce
+- A concise list of risks, assumptions, and edge cases
+- A verdict: GREENLIGHT (proceed) or ESCALATE (needs full orchestration)
+- Specific questions the team should answer before building
+
+## What You DON'T Do
+- Write implementation code
+- Block progress without justification \u2014 you challenge, not obstruct
+- Repeat concerns already addressed in the task description
+- Produce lengthy analysis \u2014 be sharp and concise`,cartographer:`You are TOPO, the CARTOGRAPHER agent.
+
+## Your Role
+You maintain and audit the project's architectural layer map (.paradigm/arch.yaml).
+You read the map, compute drift between declared architecture and live symbols, and
+render diagrams. You are advisory-only \u2014 you never block progress, never write source
+code, and never modify .purpose files or portal.yaml.
+
+## Key Responsibilities
+1. Load arch.yaml and summarize the tier structure for the team
+2. Compute drift: unassigned components (in symbol index but not in any tier) and
+   missing_purpose entries (in arch.yaml but not indexed)
+3. Render Mermaid diagrams of the architecture on request
+4. Surface architectural drift as advisory findings \u2014 not as blocking errors
+5. Recommend how to resolve drift without implementing
+
+## When You Run
+- After the Builder stage, when arch.yaml exists in the project
+- On demand when the user asks for an architecture overview or diagram
+
+## What You Produce
+- Tier summary: component counts per tier, tech stack per tier
+- Drift report: unassigned symbols, stale map entries
+- Mermaid diagram string ready for copy-paste
+- Advisory recommendations for resolving drift (never blocking)
+
+## What You NEVER Do
+- Block a build or deployment because of architectural drift
+- Write source code
+- Modify .purpose files, portal.yaml, or arch.yaml directly
+- Produce lengthy analysis \u2014 be sharp, summarize, and hand off`};function Ge(){return [{name:"paradigm_orchestrate_inline",description:`REQUIRED before implementing features. Start with mode="quick" for fast pre-check, or mode="plan" for full orchestration planning.
+
+Plans and coordinates multi-agent task execution within the same session.
+- mode: "quick" - Lightweight pre-implementation check (~3-4k tokens). Jinx (advocate) stress-tests assumptions, reviewer checks feasibility. Returns greenlight or escalates to full orchestration. NOTE: quick is a pre-check only \u2014 it does NOT satisfy orchestration-required enforcement. Enforcement is satisfied by a COMPLETED run (verdicts > 0 \u2014 a settled task DAG or a debrief with real agent verdicts) or by declaring \`paradigm solo\`.
+- mode: "plan" - See suggested agents, estimated tokens, and get orchestration plan
+- mode: "execute" - Get full prompts and execution strategy for any IDE
+
+After getting prompts, launch agents using the Task tool. Stages marked canRunParallel: true can be launched simultaneously in a single message.
+
+**Orchestration modes:** Two execution models depending on environment:
+- Faceted (default): Each agent launches as an isolated Task tool context \u2014 separate memory, separate prompt, true multi-agent. Requires Claude Code (Task tool support).
+- Sequential (solo): Agents run in the same session context one after another. Same memory throughout. Works in Cursor and other IDEs without Task tool support.
+The active mode is set via \`orchestration.default_mode\` in agents.yaml (defaults to "faceted").
+
+When to use this tool:
+- mode="quick": Before any implementation \u2014 fast sanity check (does NOT satisfy enforcement; a completed run with verdicts>0 or \`paradigm solo\` does)
+- mode="plan": Task affects 3+ files, involves security, or mentions multiple symbols
+- mode="execute": Ready to implement, need full agent prompts
+
+Examples:
+- "Fix the login bug" \u2192 quick (greenlight or escalate)
+- "Add user authentication with JWT" \u2192 plan \u2192 architect + security + builder + tester
+- "Should I use soft delete or hard delete?" \u2192 plan \u2192 architect only (analysis)
+- "Refactor the payment module" \u2192 plan \u2192 architect + builder`,inputSchema:{type:"object",properties:{task:{type:"string",description:'The task to orchestrate (e.g., "Build @payment-system with Stripe integration")'},mode:{type:"string",enum:["quick","plan","execute"],description:'Mode: "quick" for lightweight pre-check (advocate + reviewer), "plan" returns suggested agents and plan, "execute" returns prompts ready for Task tool'},agents:{type:"array",items:{type:"string"},description:'Optional: Override which agents to use (e.g., ["architect", "builder"])'}},required:["task"]},annotations:{readOnlyHint:true,destructiveHint:false},aliases:["plan","coordinate","team","multi-agent","orchestrate","agents","spawn agents"]},{name:"paradigm_agent_prompt",description:"Get the complete prompt for a specific agent to execute a task. Use this when you need to spawn an agent via the Task tool with full context.",inputSchema:{type:"object",properties:{agent:{type:"string",enum:["advocate","architect","builder","cartographer","compliance","ftux","scholar","swift","tester","reviewer","security","documentor"],description:"The agent role to get prompt for"},task:{type:"string",description:"The specific task for this agent"},handoffContext:{type:"string",description:"Optional: Context passed from a previous agent"},previousAgent:{type:"string",description:"Optional: Name of the agent that handed off"}},required:["agent","task"]},annotations:{readOnlyHint:true,destructiveHint:false}}]}async function Ue(r,e,t){return r==="paradigm_orchestrate_inline"?fe(e,t):r==="paradigm_agent_prompt"?be(e,t):{handled:false,text:""}}async function fe(r,e){let t=r.task,c$1=r.mode||"execute",f=r.agents;try{let h=Y.join(e.rootDir,".paradigm","events");D.existsSync(h)||D.mkdirSync(h,{recursive:!0}),D.appendFileSync(Y.join(h,"team-funnel.jsonl"),JSON.stringify({timestamp:new Date().toISOString(),type:"orchestrated",source:"orchestrate_inline",mode:c$1})+`
+`,"utf8");}catch{}let p=ue(e.rootDir);if(!p){let h=JSON.stringify({error:"No agents.yaml found",suggestion:"Run `paradigm team init` to set up multi-agent orchestration"},null,2);return a$1(h.length,"paradigm_orchestrate_inline"),{handled:true,text:h}}let n=b$1(e.rootDir);if(n&&p.agents){let h={};for(let[m,u]of Object.entries(p.agents))n.includes(m)&&(h[m]=u);p.agents=h;}let l=K(t),o=[];try{let{processPendingEvents:h,loadNominations:m}=await import('./nomination-engine-EFXDEPZN.js');h(e.rootDir),o=m(e.rootDir,{pending_only:!0,limit:10}).filter(d=>d.urgency==="high"||d.urgency==="critical").map(d=>({agent:d.agent,urgency:d.urgency,brief:d.brief}));}catch{}let s=de(t);if(c$1==="quick")return ye(t,l,s,o,p,e);let i=ke(t,p.agents,f,s,p.orchestration,e.rootDir);if(c$1==="plan"){let h=Ie(t,p.agents),m=Me(i,s),u;try{let{loadNotebookEntries:S}=await import('./notebook-loader-TZVIMNDJ.js'),v=l.map(E=>E.replace(/^[#$^!~@&%?]/,"").toLowerCase()),M={},_=new Set;for(let E of i.stages)for(let P of E.agents){if(_.has(P.name))continue;_.add(P.name);let j=S(P.name,e.rootDir),I=v.length>0?S(P.name,e.rootDir,{concepts:v}):j;j.length>0&&(M[P.name]={totalEntries:j.length,relevantEntries:I.length});}Object.keys(M).length>0&&(u=M);}catch{}let d=i.stages.flatMap(S=>S.agents.map(v=>v.name)),k=ce(d,p.agents),R=k.length>0?{edges:k,note:"Shows which agents hand off to which based on agents.yaml handoff_to. Stage ordering was derived from this graph."}:void 0,x=JSON.stringify({task:t,mode:"plan",classification:{type:s.type,confidence:s.confidence,...s.alternativeType?{alternativeType:s.alternativeType}:{},overrideHint:s.overrideHint,complexity:s.complexity,securityRequired:s.securityRequired,costMultiplier:s.costMultiplier},plan:i,suggestedAgents:h,costPreview:m,...R?{collaborationGraph:R}:{},...u?{notebookKnowledge:u,notebookNote:"Agents with relevant notebook entries will have curated knowledge injected into their prompts during execute mode."}:{},...o.length>0?{activeNominations:o,nominationNote:`${o.length} high-urgency agent nomination(s) pending. These agents have been flagged by the system for attention on this project.`}:{},instructions:["Review task classification and cost preview above","Review suggested agents based on task triggers",...R?["Review collaboration graph \u2014 stage ordering was derived from agent handoff_to edges"]:[],...u?["Review notebook knowledge \u2014 agents with relevant entries will receive curated snippets in execute mode"]:[],...o.length>0?["Review active nominations \u2014 agents flagged by the system may need to be included"]:[],'Call again with mode="execute" to get full prompts and execution strategy',"Stages marked canRunParallel: true can be launched simultaneously","After each agent completes, pass handoff context to the next stage"]},null,2);return a$1(x.length,"paradigm_orchestrate_inline"),{handled:true,text:x}}let b=new Map;try{let{loadAgentProfile:h,buildProfileEnrichment:m}=await import('./agent-loader-W3RQJVW7.js'),{loadDecisions:u}=await import('./decision-loader-HELL2AMX.js'),{loadJournalEntries:d}=await import('./journal-loader-CNNA4EAU.js'),{loadNominations:k}=await import('./nomination-engine-EFXDEPZN.js'),{loadAgentState:R}=await import('./agent-state-KSQ3S7OB.js'),{loadNotebookEntries:x}=await import('./notebook-loader-TZVIMNDJ.js'),S=u(e.rootDir,{status:"active",limit:5}).map(_=>({title:_.title,decision:_.decision.slice(0,150)})),v=k(e.rootDir,{pending_only:!0,limit:10}).map(_=>({urgency:_.urgency,brief:_.brief})),M=l.map(_=>_.replace(/^[#$^!~@&%?]/,"").toLowerCase());for(let _ of i.stages)for(let E of _.agents)if(!b.has(E.name)){let P=h(e.rootDir,E.name);if(P){if(!c(E.name,e.rootDir))continue;let j=d(E.name,{transferable:!0,limit:5}).map(N=>({trigger:N.trigger,insight:N.insight.slice(0,150)})),I=R(E.name,e.rootDir),z;try{let N=x(E.name,e.rootDir,M.length>0?{concepts:M}:void 0);if(N.length>0){let V=N.sort(($,W)=>W.confidence-$.confidence||new Date(W.updated).getTime()-new Date($.updated).getTime()).slice(0,5);z=V.map($=>({context:$.context,snippet:$.snippet,concepts:$.concepts}));try{let{recordNotebookReference:$}=await import('./session-work-log-T2IE4Y4T.js');$(e.rootDir,E.name,V.map(W=>W.id));}catch{}try{let{incrementApplied:$}=await import('./notebook-loader-TZVIMNDJ.js');for(let W of V)$(E.name,W.id,e.rootDir);}catch{}}}catch{}let L=m(P,l,z,{recentDecisions:S,journalInsights:j,pendingNominations:v},I?{lastSession:I.lastSession,pendingWork:I.pendingWork,recentPatterns:I.recentPatterns,sessionsOnProject:I.sessionsOnProject}:void 0);if(P.permissions){let N=[`
+## Permission Constraints`];P.permissions.paths?.deny?.length&&N.push(`**Denied paths:** ${P.permissions.paths.deny.join(", ")}`),P.permissions.paths?.write?.length&&N.push(`**Writable paths:** ${P.permissions.paths.write.join(", ")}`),P.permissions.tools?.deny?.length&&N.push(`**Denied tools:** ${P.permissions.tools.deny.join(", ")}`),P.permissions.dangerous_actions?.length&&N.push(`**Requires approval for:** ${P.permissions.dangerous_actions.join(", ")}`),L+=`
+`+N.join(`
+`);}b.set(E.name,{enrichment:L.trim()?L:"",nickname:P.nickname,description:P.description});}}}catch{}let a;try{let h=await y("paradigm_captain_brief",{taskDescription:t,symbols:l,depth:"standard"},e);h.handled&&(a=JSON.parse(h.text).renderedBrief);}catch{}let g=[];for(let h of i.stages){let m=[];for(let u of h.agents){let d=p.agents[u.name],k=b.get(u.name),R={name:d?.name||u.name,role:d?.role||U[u.name]||`${u.name} agent`,description:k?.description,focus:d?.focus||{reads:["**/*"],writes:["**/*"]},defaultModel:oe(u.name,e.rootDir,d),triggers:d?.triggers,handoff_to:d?.handoff_to,context:d?.context,protocol:d?.protocol},x=le({agent:R,task:u.task,symbols:l,dependsOn:u.dependsOn,profileEnrichment:k?.enrichment,nickname:k?.nickname,captainBrief:a});m.push(x);}g.push({stage:h.stage,canRunParallel:h.canRunParallel,agents:m});}let y$1=`orch-${Date.now().toString(36)}-${Math.random().toString(36).substring(2,6)}`;Ye(e.rootDir,y$1,t,i);let{epicTaskId:A,agentTaskIds:T}=await Ne(e.rootDir,y$1,t,i);for(let h of g)for(let m of h.agents){let u=T.get(m.agent);u&&(m.taskId=u,m.prompt+=`
+
+## Task tracking (v7 DAG)
+Your DAG task-id is \`${u}\`. On start, call \`paradigm_task_update({ id: "${u}", status: "in-progress" })\`; when finished, call \`paradigm_task_done({ id: "${u}" })\` (or \`paradigm_task_update\` \u2192 done) so the orchestration loop can settle.`);}try{let{appendSessionWorkEntry:h}=await import('./session-work-log-T2IE4Y4T.js');for(let m of g)for(let u of m.agents)h(e.rootDir,{timestamp:new Date().toISOString(),type:"agent-contribution",agent:u.agent,contribution:u.taskDescription?.slice(0,200)||t.slice(0,200),attribution:u.attribution,symbols:l});}catch{}try{let{recordAgentSession:h}=await import('./agent-state-KSQ3S7OB.js'),u=(await import('./session-tracker-BZ7FU4AT.js')).default?.session?.sessionId||y$1;for(let d of g)for(let k of d.agents)h(k.agent,e.rootDir,{sessionId:u,summary:`${k.attribution||k.agent}: ${(k.taskDescription||t).slice(0,200)}`,symbolsTouched:l});}catch{}let w=`thr-orch-${y$1}`;try{let h=await import('./symphony-loader-VA4UREOM.js'),m=Y.basename(e.rootDir),u=`${m}/maestro`;try{h.getMyIdentity(e.rootDir)||h.registerAgent(e.rootDir,"maestro","Maestro (orchestrator)");}catch{}h.createThread(`Orchestration: ${t.slice(0,80)}`,{id:u,name:"Maestro",type:"agent",project:m,role:"orchestrator"});let d=Y.join(ie.homedir(),".paradigm","score","threads"),k=D.readdirSync(d).filter(x=>x.endsWith(".json")).sort(),R=k[k.length-1];if(R){let x=Y.join(d,R),S=Y.join(d,`${w}.json`),v=JSON.parse(D.readFileSync(x,"utf8"));v.id=w,D.writeFileSync(S,JSON.stringify(v,null,2),"utf8"),x!==S&&D.unlinkSync(x);}for(let x of g)for(let S of x.agents){let v=h.buildMessage({threadRoot:w,sender:{id:u,name:"Maestro",type:"agent",project:m,role:"orchestrator"},intent:"task",text:`[Maestro] Stage ${x.stage}: Assigned to ${S.attribution||S.agent} \u2014 ${S.taskDescription||t}`,symbols:l,metadata:{task:{stage:x.stage,canRunParallel:x.canRunParallel,...S.taskId?{taskId:S.taskId}:{}}}});h.routeMessage(v);}}catch{}let O={orchestrationId:y$1,task:t,mode:"execute",classification:{type:s.type,confidence:s.confidence,...s.alternativeType?{alternativeType:s.alternativeType}:{},overrideHint:s.overrideHint},symbols:l,totalAgents:i.estimatedAgents,...o.length>0?{activeNominations:o}:{},...A?{emittedTasks:{epicTaskId:A,stageTasks:g.flatMap(h=>h.agents.filter(m=>m.taskId).map(m=>({stage:h.stage,agent:m.agent,taskId:m.taskId})))}}:{},stages:g,executionInstructions:["Execute stages in order (stage 0, then stage 1, etc.)","Agents within a stage can be run in parallel if your environment supports it","Pass handoff context between stages",'Present each agent response as an attributed message using the attribution prefix (e.g., "[architect] Rate limiter should go before ^authenticated")',"Do NOT synthesize agent responses \u2014 show them as distinct contributions from each agent","After all agents in a stage complete, reconcile their outputs before proceeding to the next stage"],finalStep:{mandatory:true,description:"FINAL STEPS (mandatory, in order):",steps:[{order:1,action:"Call paradigm_captain_debrief",args:{orchestrationId:`${y$1} (use the orchestrationId from this response)`,sessionSummary:"(summarize what was accomplished)",touchedFiles:"(list all files modified during this session)",newSymbols:"(optional: list any new symbols registered)"}},{order:2,action:"Take the sessionInsights from the debrief result and call paradigm_ambient_learn_postflight",args:{sessionId:`${y$1} (use the orchestrationId from this response)`,context:"(pass the sessionInsights object from the debrief result here)"},note:"This is Loid's learning pass \u2014 she processes what the crew learned and ensures it compounds."},{order:3,action:"Session is complete."}],note:"Step 1 closes the session, updates .purpose coverage, records lore, and clears the stop hook. Step 2 runs Loid's learning pass on the session insights. Both steps are required \u2014 the session is NOT complete until both run."},claudeCode:{method:"Task tool",example:{description:g[0]?.agents[0]?.taskDescription||"Agent task",prompt:"(see agent prompts above)",subagent_type:"general-purpose"},parallel:"Launch multiple Task calls in one message for parallel stages"},sequential:{method:"Execute each role in sequence within this session",steps:i.stages.map((h,m)=>({stage:m,rolePrompt:`Adopt the ${h.agents[0]?.name} role. Focus ONLY on: ${h.agents.map(u=>u.task).join(", ")}`,constraint:m===0?"Design/plan only \u2014 do NOT write implementation code":m===i.stages.length-1?"Verify and test \u2014 do NOT change implementation":"Implement following the design from the previous stage"}))},cli:{method:"paradigm team orchestrate",command:`paradigm team orchestrate "${t}"`,note:"Spawns independent agent processes \u2014 works from any terminal"},symphony:{enabled:true,orchestrationThread:w,instructions:["After each agent completes, call paradigm_symphony_send to report progress. This makes the work visible in Conductor.",'Use intent "context" for analysis, "proposal" for recommendations, "decision" for decisions made',`Set threadRoot to "${w}" so all contributions are in one thread`,"Include the symbols array from the agent relay output"],perAgentInstruction:`When each agent finishes, run: paradigm_symphony_send threadId="${w}" intent="task-complete" text="[agentName] Summary of completed work" symbols=[touched symbols]`,exampleCall:{intent:"context",text:"[architect] Rate limiter should be placed before ^authenticated gate to prevent unauthenticated flood",threadRoot:w,symbols:["#rate-limiter","^authenticated"]}}},C=JSON.stringify(O,null,2);return a$1(C.length,"paradigm_orchestrate_inline"),{handled:true,text:C}}async function ye(r,e,t,c,f,p){let n=r.toLowerCase(),l;try{let w=await y("paradigm_captain_brief",{taskDescription:r,symbols:e,depth:"quick"},p);if(w.handled){let O=JSON.parse(w.text);l={coverage:`${O.coverage?.label||"unknown"} (${Math.round((O.coverage?.score||0)*100)}%)`,warnings:O.warnings||[]};}}catch{}let o=[];t.securityRequired&&o.push("security-adjacent task (auth, gates, permissions detected)"),t.complexity==="high"&&o.push(`high complexity task (type: ${t.type})`),e.length>=4&&o.push(`${e.length} symbols in scope \u2014 cross-cutting change`);let s=c.filter(w=>w.urgency==="critical");s.length>0&&o.push(`${s.length} critical agent nomination(s) pending`);let i={assumptions:[],risks:[],edgeCases:[],questions:[]};(n.includes("simple")||n.includes("just")||n.includes("only"))&&i.assumptions.push("Task framed as simple \u2014 verify no hidden complexity"),(n.includes("always")||n.includes("never"))&&i.assumptions.push("Absolute language detected \u2014 edge cases likely exist"),!n.includes("error")&&!n.includes("fail")&&!n.includes("invalid")&&i.assumptions.push("No error/failure handling mentioned \u2014 what happens when it fails?"),e.some(w=>w.startsWith("$"))&&i.risks.push("Flow symbols detected \u2014 multi-step changes have ordering/rollback risk"),e.some(w=>w.startsWith("^"))&&(i.risks.push("Gate symbols detected \u2014 authorization changes require security review"),o.some(w=>w.includes("security"))||o.push("gate symbols in scope \u2014 security review recommended")),t.matchedKeywords.some(w=>["migration","database","schema"].includes(w))&&i.risks.push("Data migration risk \u2014 irreversible changes need rollback plan"),t.matchedKeywords.some(w=>["delete","remove","drop"].includes(w))&&i.risks.push("Destructive operation \u2014 verify nothing depends on removed items"),(n.includes("add")||n.includes("new"))&&i.edgeCases.push("New feature \u2014 how does it interact with existing features?"),(n.includes("refactor")||n.includes("rename"))&&i.edgeCases.push("Refactor \u2014 all callers updated? Integration tests cover the change?"),(n.includes("fix")||n.includes("bug"))&&i.edgeCases.push("Bug fix \u2014 does the fix address the root cause or just the symptom?"),n.includes("test")||i.questions.push("How will this be tested?"),e.length===0&&i.questions.push("No symbols referenced \u2014 which components are actually affected?");let b={concerns:[],suggestions:[]};for(let w of e){let O=w.replace(/^[#$^!~@&%?]/,"");!f.agents[O]&&w.startsWith("#");}t.costMultiplier.max>1&&b.concerns.push(`Higher-than-average complexity (${t.costMultiplier.min}x-${t.costMultiplier.max}x baseline) \u2014 consider breaking into smaller tasks`);let a=[];try{let{loadNotebookEntries:w}=await import('./notebook-loader-TZVIMNDJ.js'),O=e.map(h=>h.replace(/^[#$^!~@&%?]/,"").toLowerCase()),C=w("advocate",p.rootDir,O.length>0?{concepts:O}:void 0);C.length>0&&(a=C.sort((h,m)=>m.confidence-h.confidence).slice(0,3).map(h=>h.snippet));}catch{}let y$1=o.length>=2||o.some(w=>w.includes("security")||w.includes("critical"))?"escalate":"greenlight",A={mode:"quick",task:r,verdict:y$1,classification:{type:t.type,confidence:t.confidence,...t.alternativeType?{alternativeType:t.alternativeType}:{},overrideHint:t.overrideHint,complexity:t.complexity,securityRequired:t.securityRequired},advocate:{agent:"Jinx (advocate)",...i.assumptions.length>0?{assumptions:i.assumptions}:{},...i.risks.length>0?{risks:i.risks}:{},...i.edgeCases.length>0?{edgeCases:i.edgeCases}:{},...i.questions.length>0?{questions:i.questions}:{},...a.length>0?{notebookInsights:a}:{}},reviewer:{agent:"reviewer",...b.concerns.length>0?{concerns:b.concerns}:{},...b.suggestions.length>0?{suggestions:b.suggestions}:{}},...o.length>0?{escalationSignals:o}:{},...c.length>0?{activeNominations:c}:{},...l?{captainBrief:l}:{},symbols:e,instructions:y$1==="greenlight"?["Quick check passed \u2014 proceed with implementation.","Orchestration enforcement is satisfied.",i.questions.length>0?`Address Jinx's questions during implementation: ${i.questions.join("; ")}`:"No open questions from advocate."]:["Quick check recommends full orchestration.",`Escalation reasons: ${o.join("; ")}`,'Call paradigm_orchestrate_inline mode="plan" for full agent planning.',"Orchestration enforcement is satisfied regardless of verdict."]},T=JSON.stringify(A,null,2);return a$1(T.length,"paradigm_orchestrate_inline"),{handled:true,text:T}}async function be(r,e){let t=r.agent,c=r.task,f=r.handoffContext,p=r.previousAgent,n=ue(e.rootDir),l=b$1(e.rootDir);if(l&&!l.includes(t)){let T=JSON.stringify({warning:`Agent "${t}" is not on this project's roster`,suggestion:`Run paradigm_agent_activate id="${t}" to add it, or check .paradigm/roster.yaml`,activeRoster:l},null,2);return a$1(T.length,"paradigm_agent_prompt"),{handled:true,text:T}}let o=n?.agents[t],s={name:o?.name||t,role:o?.role||U[t]||U.builder,focus:o?.focus||{reads:["**/*"],writes:["**/*"]},defaultModel:oe(t,e.rootDir,o),triggers:o?.triggers,handoff_to:o?.handoff_to,context:o?.context,protocol:o?.protocol},i=K(c),b,a;try{let{loadAgentProfile:T,buildProfileEnrichment:w}=await import('./agent-loader-W3RQJVW7.js'),{loadDecisions:O}=await import('./decision-loader-HELL2AMX.js'),{loadJournalEntries:C}=await import('./journal-loader-CNNA4EAU.js'),{loadNominations:h}=await import('./nomination-engine-EFXDEPZN.js'),{loadNotebookEntries:m}=await import('./notebook-loader-TZVIMNDJ.js'),u=T(e.rootDir,t);if(u){a=u.nickname,s.description=u.description;let d=O(e.rootDir,{status:"active",limit:5}).map(v=>({title:v.title,decision:v.decision.slice(0,150)})),k=C(t,{transferable:!0,limit:5}).map(v=>({trigger:v.trigger,insight:v.insight.slice(0,150)})),R=h(e.rootDir,{pending_only:!0,limit:10}).map(v=>({urgency:v.urgency,brief:v.brief})),x;try{let v=i.map(_=>_.replace(/^[#$^!~@&%?]/,"").toLowerCase()),M=m(t,e.rootDir,v.length>0?{concepts:v}:void 0);if(M.length>0){let _=M.sort((E,P)=>P.confidence-E.confidence||new Date(P.updated).getTime()-new Date(E.updated).getTime()).slice(0,5);x=_.map(E=>({context:E.context,snippet:E.snippet,concepts:E.concepts}));try{let{recordNotebookReference:E}=await import('./session-work-log-T2IE4Y4T.js');E(e.rootDir,t,_.map(P=>P.id));}catch{}}}catch{}let S=w(u,i,x,{recentDecisions:d,journalInsights:k,pendingNominations:R});if(u.permissions){let v=[`
+## Permission Constraints`];u.permissions.paths?.deny?.length&&v.push(`**Denied paths:** ${u.permissions.paths.deny.join(", ")}`),u.permissions.paths?.write?.length&&v.push(`**Writable paths:** ${u.permissions.paths.write.join(", ")}`),u.permissions.tools?.deny?.length&&v.push(`**Denied tools:** ${u.permissions.tools.deny.join(", ")}`),u.permissions.dangerous_actions?.length&&v.push(`**Requires approval for:** ${u.permissions.dangerous_actions.join(", ")}`),S+=`
+`+v.join(`
+`);}S.trim()&&(b=S);}}catch{}let g=le({agent:s,task:c,symbols:i,handoffContext:f,previousAgent:p,profileEnrichment:b,nickname:a}),y={agent:t,model:g.model,prompt:g.prompt,attribution:g.attribution,taskToolParams:{description:g.taskDescription,prompt:g.prompt,subagent_type:g.subagentType,model:g.model},focusAreas:g.focusAreas,usage:"Use the Task tool with the taskToolParams to spawn this agent. Present the response with the attribution prefix."},A=JSON.stringify(y,null,2);return a$1(A.length,"paradigm_agent_prompt"),{handled:true,text:A}}function ce(r,e){let t=new Set(r),c=[];for(let f of r){let p=e[f];if(p?.handoff_to)for(let n of p.handoff_to)t.has(n)&&c.push({from:f,to:n});}return c}function we(r,e){let t=ce(r,e);if(t.length===0)return null;let c=new Set,f=new Set(t.map(a=>`${a.from}->${a.to}`));for(let a of t)if(f.has(`${a.to}->${a.from}`)){let g=[a.from,a.to].sort().join(",");c.add(g);}let p=new Map;for(let a of c){let[g,y]=a.split(","),A=p.get(g)||g,T=p.get(y)||y,w=A<T?A:T;for(let[O,C]of p)(C===A||C===T)&&p.set(O,w);p.set(g,w),p.set(y,w);}for(let a of r)p.has(a)||p.set(a,a);let n=[...new Set(p.values())],l=new Map,o=new Map;for(let a of n)l.set(a,0),o.set(a,new Set);for(let a of t){let g=p.get(a.from),y=p.get(a.to);g!==y&&(o.get(g).has(y)||(o.get(g).add(y),l.set(y,(l.get(y)||0)+1)));}let s=new Map,i=[];for(let a of n)(l.get(a)||0)===0&&(i.push(a),s.set(a,0));for(;i.length>0;){let a=i.shift(),g=s.get(a)||0;for(let y of o.get(a)||[]){let A=(l.get(y)||1)-1;l.set(y,A);let T=g+1;s.set(y,Math.max(s.get(y)||0,T)),A===0&&i.push(y);}}if(s.size<n.length)return null;let b=new Map;for(let a of r){let g=p.get(a);b.set(a,s.get(g)||0);}return b}function ke(r,e,t,c,f,p){let n=K(r),l=r.toLowerCase(),o=[],s=[];if(t&&t.length>0)for(let d=0;d<t.length;d++){let k=t[d];e[k]&&s.push({name:k,task:`${k==="architect"?"Design":k==="builder"?"Implement":k==="tester"?"Test":"Process"}: ${r}`,dependsOn:d>0?[t[d-1]]:[],required:true,stage:d});}else if(c&&c.type!=="feature"&&c.type!=="unknown"){let d=c.recommendedAgents.length>0?c.recommendedAgents:["architect"],k={architect:Z(c.type)?"Analyze":"Design",security:Z(c.type)?"Assess security of":"Review security of",builder:"Implement",tester:"Test",reviewer:"Review"},R=0,x=null;for(let S of d){if(!e[S])continue;let v=x?[x]:[],M=k[S]||"Process",_=S==="architect"||S==="builder";s.push({name:S,task:`${M}: ${r}`,required:_,stage:R,dependsOn:v}),x=S,R++;}}else {let d=l.includes("design")||l.includes("architect")||l.includes("plan")||l.includes("spec"),k=l.includes("auth")||l.includes("security")||l.includes("gate")||n.some(_=>_.startsWith("^")),R=l.includes("build")||l.includes("implement")||l.includes("create")||l.includes("add")||l.includes("fix"),x=l.includes("review")||l.includes("check"),S=l.includes("test")||l.includes("verify")||l.includes("validate");if(d&&e.architect&&s.push({name:"architect",task:`Design and specify: ${r}`,dependsOn:[],required:true,stage:0}),k&&e.security&&s.push({name:"security",task:`Review security aspects of: ${r}`,dependsOn:[],required:false,stage:0}),R&&e.builder){let _=d&&e.architect?["architect"]:[];s.push({name:"builder",task:`Implement: ${r}`,dependsOn:_,required:true,stage:_.length>0?1:0});}let v=s.some(_=>_.name==="builder"),M=v?2:d?1:0;if(x&&e.reviewer&&s.push({name:"reviewer",task:`Review: ${r}`,dependsOn:v?["builder"]:[],required:false,stage:M}),S&&e.tester&&s.push({name:"tester",task:`Test and validate: ${r}`,dependsOn:v?["builder"]:[],required:false,stage:M}),s.length===0){let _=c?.recommendedAgents||["architect","builder","tester"],E={architect:"Design",security:"Review security of",builder:"Implement",tester:"Test",reviewer:"Review"},P=0,j=null;for(let I of _){if(!e[I])continue;let z=j?[j]:[],L=E[I]||"Process",N=I==="architect"||I==="builder";s.push({name:I,task:`${L}: ${r}`,required:N,stage:P,dependsOn:z}),j=I,P++;}}}let i=s.map(d=>d.name),b=we(i,e);if(b)for(let d of s){d.stage=b.get(d.name)||0;let k=[];for(let R of i){if(R===d.name)continue;e[R]?.handoff_to?.includes(d.name)&&(b.get(R)||0)<d.stage&&k.push(R);}k.length>0&&(d.dependsOn=k);}let a=new Map;for(let d of s){let k=a.get(d.stage)||[];k.push(d),a.set(d.stage,k);}let g=Array.from(a.keys()).sort((d,k)=>d-k);for(let d of g){let k=a.get(d)||[];o.push({stage:d,agents:k.map(R=>({name:R.name,task:R.task,dependsOn:R.dependsOn,required:R.required})),canRunParallel:k.length>1});}let y=s.some(d=>d.name==="builder"||d.name==="tester"),T=(c?Z(c.type):false)||!y,w=false;if(!T){let d=g.length>0?g[g.length-1]+1:0;o.push({stage:d,agents:[{name:"documentor",task:"Review all changes made by previous agents. Update .purpose files, portal.yaml, and symbol registrations using only paradigm_purpose_* and paradigm_portal_* MCP tools. Run paradigm_reindex when done. Do NOT modify source code.",dependsOn:s.map(k=>k.name),required:true}],canRunParallel:false}),w=true;}let O=ae(p||"."),C=c?.type,h=0,m=0;for(let d of s){let k=ee(O,d.name,C);h+=k.min,m+=k.max;}w&&(h+=2e3,m+=8e3);let u=f?.default_mode||"faceted";return {task:r,mode:u,stages:o,symbols:n,estimatedAgents:s.length+(w?1:0),estimatedTokens:{min:h,max:m}}}function le(r){let{agent:e,task:t,symbols:c,handoffContext:f,previousAgent:p}=r,n=[];r.profileEnrichment&&(n.push(r.profileEnrichment),n.push("---"),n.push("")),r.captainBrief&&(n.push(r.captainBrief),n.push(""));let l=U[e.name]||e.description||e.role||U.builder;if(n.push(l),n.push(""),n.push("---"),n.push(""),n.push("## Your Task"),n.push(""),n.push(t),n.push(""),c.length>0){n.push("## Symbols in Scope"),n.push("");for(let b of c){let a=ve(b);n.push(`- \`${b}\` (${a})`);}n.push("");}f&&(n.push("## Context from Previous Agent"),p&&n.push(`*Handed off from ${p}:*`),n.push(""),n.push(f),n.push("")),(e.focus?.reads||e.focus?.writes)&&(n.push("## Focus Areas"),n.push(""),n.push(`**Read from:** ${e.focus?.reads?.join(", ")||"**/*"}`),n.push(`**Write to:** ${e.focus?.writes?.join(", ")||"**/*"}`),n.push("")),n.push(`## Output Format
+
+When you complete your task, end with a structured summary block:
+
+\`\`\`yaml
+# Agent Relay
+status: success | partial | failed | blocked
+summary: |
+  Brief summary of what was accomplished
+artifacts:
+  - path/to/file1.ts  # created or modified
+decisions:
+  - Key decision 1
+handoff_to: builder | reviewer | tester | architect | security  # optional
+handoff_context: |
+  Context the next agent needs to know
+\`\`\`
+
+This structured output helps track progress and pass context between agents.`);let o=n.join(`
+`),s=e.defaultModel||J[G[e.name]||"tier-2"]||"sonnet",i=r.nickname?`[${r.nickname} (${e.name})]`:`[${e.name}]`;return {agent:e.name,model:s,prompt:o,taskDescription:`${e.name}: ${t.slice(0,50)}${t.length>50?"...":""}`,subagentType:"general-purpose",attribution:i,focusAreas:e.focus||{reads:["**/*"],writes:["**/*"]}}}function K(r){let e=r.match(me)||[];return [...new Set(e)]}function ve(r){let e=r.charAt(0);return {"@":"feature","#":"component",$:"flow","%":"state","^":"gate","!":"signal","?":"idea","&":"integration","~":"deprecated"}[e]||"unknown"}var Se=["should","what","how","why","recommend","analyze","compare","evaluate","assess","review","explain","describe","investigate","which","best practice","trade-off","pros and cons"],Ae=["document","write docs","readme",".purpose","purpose file","jsdoc","tsdoc","comments","docstring","api docs"],xe=["bug","fix","broken","not working","issue","error","crash","fails","failing","wrong","incorrect","regression","patch"],_e=["rename","refactor","migrate","restructure","move","reorganize","clean up","cleanup","consolidate","extract","inline","simplify"],Te=["auth","permission","admin","delete","purge","password","credential","token","secret","key","encrypt","decrypt","ownership","transfer","privilege","escalation","impersonation","takeover","rbac","acl","role","guard","middleware","session","cookie","csrf","xss","injection","sanitize"],Re=["audit","self-audit","inspect","examine","survey","inventory","find issues","identify problems","identify gaps","gap analysis","health check","sanity check","post-mortem","postmortem"],Pe=["design","architect","architecture","spec","specify","specification","blueprint","plan","propose","proposal","rfc","schema design","api design","data model"],Ee=["research","investigate","explore","study","discover","spike","prototype","feasibility","survey the","literature","prior art","options for","approaches to"],De=new Set(["analysis","audit","design","research","documentation"]),Oe=[{pattern:/^(please\s+)?(audit|self-audit)\b/,family:"audit"},{pattern:/^(please\s+)?(analy[sz]e|assess|evaluate|examine|inspect|review)\b/,family:"analysis"},{pattern:/^(please\s+)?(design|architect|spec|specify|plan|propose)\b/,family:"design"},{pattern:/^(please\s+)?(research|investigate|explore|study)\b/,family:"research"},{pattern:/^(please\s+)?(document|write\s+docs)\b/,family:"documentation"}],Ce={audit:1.3,analysis:1.1,design:1.2,research:1.2,documentation:1.1,bugfix:1,refactor:1};function de(r){let e=r.toLowerCase(),t=K(r),c=m=>m.filter(u=>e.includes(u.toLowerCase())),f={audit:c(Re),analysis:c(Se),design:c(Pe),research:c(Ee),documentation:c(Ae),bugfix:c(xe),refactor:c(_e)},p=c(Te),n={};for(let[m,u]of Object.entries(f))n[m]=u.length*(Ce[m]??1);let l;for(let{pattern:m,family:u}of Oe)if(m.test(e)){l=u,n[u]=(n[u]??0)+5;break}let o=Object.entries(n).filter(([,m])=>m>0).sort((m,u)=>u[1]-m[1]),s,i,b=0,a=0;o.length===0?s="feature":(s=o[0][0],b=o[0][1],i=o[1]?.[0],a=o.reduce((m,[,u])=>m+u,0));let g=a>0?b/a:.4;l&&(g=Math.max(g,.7)),g=Math.round(g*100)/100;let y=f[s]||[],A="medium",T=r.split(/\s+/).length;t.length>=5||T>=100?A="high":t.length<=1&&T<30&&(A="low");let w=p.length>0||t.some(m=>m.startsWith("^")),O={audit:["architect"],analysis:["architect"],design:["architect"],research:["architect"],documentation:["architect"],bugfix:["security","builder"],refactor:["architect","builder"],feature:["architect","security","builder","tester"]},C={audit:{min:.3,max:.5},analysis:{min:.3,max:.5},design:{min:.4,max:.7},research:{min:.3,max:.6},documentation:{min:.25,max:.45},bugfix:{min:.5,max:.8},refactor:{min:.6,max:.85},feature:{min:.8,max:1.2}},h=`classified ${s} (${g.toFixed(2)})`+(i?`; alt ${i}`:"")+"; override with agents:[...] if misrouted";return {type:s,confidence:g,...i?{alternativeType:i}:{},overrideHint:h,complexity:A,recommendedAgents:O[s]||["architect","builder"],securityRequired:w,costMultiplier:C[s]||{min:.8,max:1},matchedKeywords:y,symbols:t}}function Z(r){return De.has(r)}var ne={opus:{input:15,output:75},sonnet:{input:3,output:15},haiku:{input:.25,output:1.25}},se={architect:{input:8e3,output:4e3},security:{input:6e3,output:3e3},reviewer:{input:5e3,output:2e3},builder:{input:15e3,output:1e4},tester:{input:8e3,output:5e3}};function Me(r,e){let t=[],c=0,f=e.complexity==="high"?1.5:e.complexity==="low"?.6:1;for(let l of r.stages)for(let o of l.agents){let s=se[o.name]||{input:5e3,output:3e3},i=J[G[o.name]||"tier-2"]||"sonnet",b=ne[i],a=Math.round(s.input*f),g=Math.round(s.output*f),y=a+g,A=a/1e6*b.input+g/1e6*b.output;t.push({name:o.name,model:i,estimatedTokens:y,estimatedCost:Math.round(A*1e4)/1e4}),c+=A;}let p=0;for(let[l,o]of Object.entries(se)){let s=J[G[l]||"tier-2"]||"sonnet",i=ne[s];p+=o.input/1e6*i.input+o.output/1e6*i.output;}let n=p>0?c/p:1;return {agents:t,totalEstimatedCost:Math.round(c*1e4)/1e4,comparisonToBaseline:`${n.toFixed(2)}x`}}function Ie(r,e){let t=[],c=r.toLowerCase(),f=K(r);for(let[o,s]of Object.entries(e)){let i=[];for(let b of s.triggers||[]){if(b.type==="keyword"&&b.match)for(let a of b.match)c.includes(a.toLowerCase())&&i.push(`keyword:${a}`);if(b.type==="symbol"&&b.match)for(let a of b.match){let g=f.filter(y=>a.endsWith("*")?y.startsWith(a.slice(0,-1)):y===a);for(let y of g)i.push(`symbol:${y}`);}}if(i.length>0){let b=i.filter(w=>w.startsWith("keyword:")).length,a=i.filter(w=>w.startsWith("symbol:")).length,g=b>0&&a>0,y=i.length>=3||g?"high":i.length>=2?"medium":"low",A=s.role.split(`
+`)[0].trim(),T=A.length>50?A.slice(0,47)+"...":A;t.push({name:o,reason:T,confidence:y,triggers_matched:i});}}let p=new Set(t.map(o=>o.name)),n=[];for(let o of t){let s=e[o.name];if(s?.handoff_to)for(let i of s.handoff_to){if(p.has(i)||!e[i])continue;let b=e[i],a=[];for(let g of b.triggers||[]){if(g.type==="keyword"&&g.match)for(let y of g.match)c.includes(y.toLowerCase())&&a.push(`keyword:${y}`);if(g.type==="symbol"&&g.match)for(let y of g.match){let A=f.filter(T=>y.endsWith("*")?T.startsWith(y.slice(0,-1)):T===y);for(let T of A)a.push(`symbol:${T}`);}}if(a.length>0){p.add(i);let g=b.role.split(`
+`)[0].trim(),y=g.length>50?g.slice(0,47)+"...":g;n.push({name:i,reason:y,confidence:a.length>=2?"high":"medium",triggers_matched:[...a,`collaboration:handoff_from:${o.name}`]});}}}t.push(...n);let l={high:3,medium:2,low:1};return t.sort((o,s)=>l[s.confidence]-l[o.confidence])}function ue(r){let e=Y.join(r,".paradigm","agents.yaml");if(!D.existsSync(e))return null;try{let t=D.readFileSync(e,"utf-8");return H.load(t)}catch{return null}}async function Ne(r,e,t,c){let f=new Map,p;try{let{createTask:n,updateTask:l}=await import('./task-loader-EIXPKHA3.js');p=await n(r,{blurb:t,priority:"medium",tags:["orchestration","epic"],claimant:{kind:"archetype",ref:"orchestrator"},external_ref:{provider:"orchestration",ref:e}});try{await l(r,p,{status:"in-progress"});}catch(o){a.flow("$dag-emission").warn("Epic promote to in-progress failed",{orchestrationId:e,epicTaskId:p,error:o instanceof Error?o.message:String(o)});}for(let o of c.stages)for(let s of o.agents)try{let i=(s.dependsOn||[]).map(a=>f.get(a)).filter(a=>typeof a=="string"),b=await n(r,{blurb:s.task,priority:"medium",tags:["orchestration"],claimant:{kind:"archetype",ref:s.name},parentTaskId:p,stage:o.stage,...i.length>0?{dependsOn:i}:{},external_ref:{provider:"orchestration",ref:e}});f.set(s.name,b);}catch(i){a.flow("$dag-emission").warn("Stage-agent task emission failed",{orchestrationId:e,agent:s.name,stage:o.stage,error:i instanceof Error?i.message:String(i)});}a.flow("$dag-emission").info("Emitted orchestration task DAG",{orchestrationId:e,epicTaskId:p,stageAgents:f.size});}catch(n){a.flow("$dag-emission").warn("Task DAG emission failed; orchestration continues",{orchestrationId:e,error:n instanceof Error?n.message:String(n)});}return {epicTaskId:p,agentTaskIds:f}}function Ye(r,e,t,c){let f=Y.join(r,".paradigm","orchestrations");D.existsSync(f)||D.mkdirSync(f,{recursive:true});let p=Y.join(f,`${e}.yaml`),n={id:e,task:t,created:new Date().toISOString(),status:"pending",mode:c.mode,symbols:c.symbols,estimatedAgents:c.estimatedAgents,estimatedTokens:c.estimatedTokens,stages:c.stages};try{D.writeFileSync(p,H.dump(n));}catch{}}function $e(r){let e=r?.filePlan;if(!(!e||e.length===0))return [{group:"all",subPhase:0,files:e.map(t=>({path:t,description:""}))}]}function He(r){let e=$e(r);if(!e||e.length===0)return {hasFilePlan:false,stages:[{subPhase:0,builders:[{agent:"builder",group:"all",files:[],availableFiles:[]}]}],totalFiles:0,totalBuilders:1};let t=new Map;for(let o of e){let s=t.get(o.subPhase)||[];s.push(o),t.set(o.subPhase,s);}let c=[],f=[...t.keys()].sort((o,s)=>o-s),p=[],n=0,l=0;for(let o of f){let s=t.get(o),i=[];for(let b=0;b<s.length;b++){let a=s[b];l+=a.files.length,n++,i.push({agent:`builder-${o}-${b}`,group:a.group,files:a.files,availableFiles:[...p]});}c.push({subPhase:o,builders:i});for(let b of s)for(let a of b.files)p.push(a.path);}return {hasFilePlan:true,stages:c,totalFiles:l,totalBuilders:n}}export{ae as a,ee as b,Le as c,he as d,Be as e,Ge as f,Ue as g,de as h,Ie as i,ue as j,Ne as k,He as l};

package/dist/chunk-RPGSQQTS.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+function r(e){if(!e)return {labels:[]};switch(e.kind){case "human":return {assignee:e.ref,labels:[]};case "archetype":return {labels:[`paradigm:agent/${e.ref}`]};case "peer":return {labels:[`paradigm:peer/${e.ref}`]};default:return {labels:[]}}}export{r as a};

package/dist/chunk-RQHZUPLO.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import*as c from'fs';import*as p from'path';var y=8,g=".paradigm/events/estimate-actuals.jsonl",m=".paradigm/learned/token-estimates.json";function h(i,l){if(i.length===0)return 0;let n=[...i].sort((o,s)=>o-s);if(n.length===1)return n[0];let a=l*(n.length-1),e=Math.floor(a),t=Math.ceil(a);if(e===t)return n[e];let r=a-e;return n[e]+(n[t]-n[e])*r}function b(i){let l=new Map;for(let e of i){let t=e.trim();if(!t)continue;let r;try{r=JSON.parse(t);}catch{continue}let{archetype:o,taskType:s}=r,u=r.actualTokens?.total;if(typeof o!="string"||typeof s!="string"||typeof u!="number"||!Number.isFinite(u))continue;let d=`${o} ${s}`,f=l.get(d);f?f.push(u):l.set(d,[u]);}let n={},a=[];for(let[e,t]of l){let[r,o]=e.split(" "),s=t.length;if(s>=y){let u={min:Math.round(h(t,.1)),max:Math.round(h(t,.9)),n:s};n[r]||(n[r]={}),n[r][o]=u,a.push({archetype:r,taskType:o,n:s,learned:true,band:u});}else a.push({archetype:r,taskType:o,n:s,learned:false});}return a.sort((e,t)=>e.archetype===t.archetype?e.taskType.localeCompare(t.taskType):e.archetype.localeCompare(t.archetype)),{table:n,groups:a}}function k(i){try{let l=p.join(i,g);if(!c.existsSync(l))return null;let n=c.readFileSync(l,"utf8").split(`
+`),{table:a,groups:e}=b(n),t=p.join(i,p.dirname(m));return c.existsSync(t)||c.mkdirSync(t,{recursive:!0}),c.writeFileSync(p.join(i,m),JSON.stringify(a,null,2)+`
+`,"utf8"),{table:a,groups:e,samplesRead:e.reduce((r,o)=>r+o.n,0)}}catch{return null}}export{y as a,h as b,b as c,k as d};

package/dist/chunk-SD3KVW5Q.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import {b as b$1,a}from'./chunk-EK4ZRIFJ.js';import*as d from'fs';import*as g from'path';import*as h from'js-yaml';b$1();var T=".paradigm/tasks",y="entries",C="index.yaml";function I(e){if(e&&e.session_link&&!e.external_ref){let n=e.session_link,i=n.toLowerCase(),r;i.includes("github")?r="github":i.includes("session")?r="session":r="url",e.external_ref={provider:r,ref:n},delete e.session_link;}let t=e?.external_ref;return t&&t.kind!==void 0&&t.provider===void 0&&(t.provider=t.kind,delete t.kind),e}function D(e,t){let n=g.join(e,T,y,t);if(!d.existsSync(n))return `T-${t}-001`;let i=d.readdirSync(n).filter(o=>o.startsWith("T-")&&o.endsWith(".yaml")).map(o=>{let c=o.match(/T-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);return c?parseInt(c[1],10):0}),r=i.length>0?Math.max(...i)+1:1;return `T-${t}-${String(r).padStart(3,"0")}`}function A(e,t){return e===t?true:({open:["in-progress","done","shelved"],"in-progress":["done","open","shelved"],shelved:["open"],done:["open"]}[e]??[]).includes(t)}var O={high:0,medium:1,low:2},N=["open","in-progress"];function $(e,t){return t==="all"?true:t==="active"?N.includes(e.status):e.status===t}function R(e){let t=e.created?new Date(e.created).getTime():NaN;if(!Number.isNaN(t))return t;let n=e.id?.match(/^T-(\d{4}-\d{2}-\d{2})-/);if(n){let i=new Date(n[1]).getTime();if(!Number.isNaN(i))return i}return 0}function W(e,t){let n=e;if(t.status&&t.status!=="all"&&(n=n.filter(i=>$(i,t.status))),t.priority&&(n=n.filter(i=>i.priority===t.priority)),t.tag&&(n=n.filter(i=>i.tags.includes(t.tag))),t.claimant){let{kind:i,ref:r}=t.claimant;n=n.filter(o=>o.claimant!=null&&o.claimant.ref===r&&(i===void 0||o.claimant.kind===i));}return n.sort((i,r)=>{let o=(O[i.priority]??1)-(O[r.priority]??1);return o!==0?o:R(r)-R(i)}),t.limit&&(n=n.slice(0,t.limit)),n}async function b(e,t){let n=g.join(e,T,y);if(!d.existsSync(n))return [];let i={status:"open",limit:20,...t},r=[],o=d.readdirSync(n).filter(c=>/^\d{4}-\d{2}-\d{2}$/.test(c)).sort().reverse();for(let c of o){let k=g.join(n,c),u=d.readdirSync(k).filter(s=>s.endsWith(".yaml")).sort();for(let s of u)try{let a=d.readFileSync(g.join(k,s),"utf8"),f=I(h.load(a));r.push(f);}catch{}}return W(r,i)}async function V(e,t,n){return b(e,{claimant:t,status:n?.status??"active",limit:n?.limit??200})}async function K(e,t){let n=t.match(/^T-(\d{4}-\d{2}-\d{2})-/);if(n){let r=g.join(e,T,y,n[1],`${t}.yaml`);if(d.existsSync(r))try{return I(h.load(d.readFileSync(r,"utf8")))}catch{return null}}return (await b(e,{status:"all",limit:9999})).find(r=>r.id===t)||null}function L(e){let t=[],n=new Map;for(let s of e)s.id&&n.set(s.id,s);for(let s of e)if(s.id){s.parentTaskId===s.id?t.push({kind:"self-parent",taskId:s.id,detail:s.id}):s.parentTaskId&&!n.has(s.parentTaskId)&&t.push({kind:"dangling-parent",taskId:s.id,detail:s.parentTaskId});for(let a of s.dependsOn??[])a===s.id?t.push({kind:"self-parent",taskId:s.id,detail:`dependsOn:${a}`}):n.has(a)||t.push({kind:"dangling-dependency",taskId:s.id,detail:a});}let i=0,r=1,o=2,c=new Map;for(let s of n.keys())c.set(s,i);let k=s=>{let a=[];s.parentTaskId&&s.parentTaskId!==s.id&&n.has(s.parentTaskId)&&a.push(s.parentTaskId);for(let f of s.dependsOn??[])f!==s.id&&n.has(f)&&a.push(f);return a},u=new Set;for(let s of n.keys()){if(c.get(s)!==i)continue;let a=[{id:s,path:[s]}],f=new Set;for(;a.length;){let l=a[a.length-1];c.get(l.id)===i&&(c.set(l.id,r),f.add(l.id));let S=false;for(let p of k(n.get(l.id)))if(c.get(p)===r){let m=l.path.indexOf(p),w=m>=0?l.path.slice(m).concat(p):[l.id,p],P=[...w].sort().join("|");u.has(P)||(u.add(P),t.push({kind:"cycle",taskId:p,detail:w.join(" \u2192 ")}));}else if(c.get(p)===i){a.push({id:p,path:[...l.path,p]}),S=true;break}S||(c.set(l.id,o),f.delete(l.id),a.pop());}}return t}async function B(e,t){let n=new Date,i=n.toISOString().slice(0,10),r=g.join(e,T,y,i);d.mkdirSync(r,{recursive:true});let o=D(e,i),c={id:o,blurb:t.blurb,priority:t.priority||"medium",status:"open",tags:t.tags||[],created:n.toISOString(),related_lore:t.related_lore,claimant:t.claimant,parentTaskId:t.parentTaskId,dependsOn:t.dependsOn,stage:t.stage,external_ref:t.external_ref,session_link:t.session_link};return I(c),d.writeFileSync(g.join(r,`${o}.yaml`),h.dump(j(c),{lineWidth:-1,noRefs:true})),await F(e),o}async function v(e,t,n){let i=await K(e,t);if(!i)return  false;let r=i.created.slice(0,10),o=g.join(e,T,y,r,`${t}.yaml`);if(!d.existsSync(o))return  false;let{id:c,created:k,...u}=n;if(u.status!==void 0&&u.status!==i.status){if(!A(i.status,u.status))return a.component("#task-loader").warn("Illegal task status transition rejected",{taskId:t,from:i.status,to:u.status}),false;u.status==="in-progress"&&!i.started_at&&u.started_at===void 0&&(u.started_at=new Date().toISOString()),i.status==="done"&&u.status==="open"&&(u.completed=void 0,u.settledAt=void 0,u.crashed_at=void 0,u.crash_reason=void 0);}let s={...i,...u};if(d.writeFileSync(o,h.dump(j(s),{lineWidth:-1,noRefs:true})),await F(e),_(s.status)&&s.parentTaskId)try{let{settleParentIfComplete:a}=await import('./task-settlement-A2T6EACG.js');await a(e,s.parentTaskId,s.id);}catch(a$1){a.component("#task-loader").warn("Settlement after updateTask failed (non-fatal)",{taskId:t,parentTaskId:s.parentTaskId,error:a$1 instanceof Error?a$1.message:String(a$1)});}if(_(s.status))try{let a$1=await b(e,{status:"all",limit:9999}),f=new Map(a$1.map(l=>[l.id,l]));for(let l of a$1){if(!l.blocked_on||!l.dependsOn?.includes(s.id))continue;(l.dependsOn??[]).every(p=>{let m=f.get(p);return m!=null&&_(m.status)})&&(await v(e,l.id,{blocked_on:void 0}),a.component("#task-loader").info("Auto-cleared blocked_on (all deps terminal)",{taskId:l.id,resolvedBy:s.id}));}}catch(a$1){a.component("#task-loader").warn("blocked_on auto-clear failed (non-fatal)",{taskId:t,error:a$1 instanceof Error?a$1.message:String(a$1)});}return  true}function _(e){return e==="done"||e==="shelved"}async function U(e,t){return v(e,t,{status:"done",completed:new Date().toISOString()})}async function Y(e,t){return v(e,t,{status:"shelved",shelved:new Date().toISOString()})}async function F(e){let t=g.join(e,T,y),n=g.join(e,T),i=0,r=0,o=0,c=0,k=0,u=[];if(d.existsSync(t)){let a=d.readdirSync(t).filter(f=>/^\d{4}-\d{2}-\d{2}$/.test(f));for(let f of a){let l=g.join(t,f),S=d.readdirSync(l).filter(p=>p.endsWith(".yaml"));for(let p of S)try{let m=I(h.load(d.readFileSync(g.join(l,p),"utf8")));i++,m.status==="open"?r++:m.status==="in-progress"?o++:m.status==="done"?c++:m.status==="shelved"&&k++,!m.parentTaskId&&m.id&&u.push(m.id);}catch{}}}let s={version:"1.1",total:i,open:r,in_progress:o,done:c,shelved:k,roots:u,last_updated:new Date().toISOString()};return d.mkdirSync(n,{recursive:true}),d.writeFileSync(g.join(n,C),h.dump(s,{lineWidth:-1,noRefs:true})),s}function j(e){let t={};for(let[n,i]of Object.entries(e))i!==void 0&&(t[n]=i);return t}export{I as a,D as b,A as c,b as d,V as e,K as f,L as g,B as h,v as i,U as j,Y as k,F as l};