astrocode-workflow 0.4.0 → 0.4.1

package/dist/index.js

@@ -9,6 +9,7 @@ import { createInjectProvider } from "./hooks/inject-provider";
 import { createToastManager } from "./ui/toasts";
 import { createAstroAgents } from "./agents/registry";
 import { info, warn } from "./shared/log";
+import { acquireRepoLock } from "./state/repo-lock";
 // Safe config cloning with structuredClone preference (fallback for older Node versions)
 // CONTRACT: Config is guaranteed JSON-serializable (enforced by loadAstrocodeConfig validation)
 const cloneConfig = (v) => {
@@ -37,6 +38,9 @@ const Astrocode = async (ctx) => {
         throw new Error("Astrocode requires ctx.directory to be a string repo root.");
     }
     const repoRoot = ctx.directory;
+    // Acquire exclusive repo lock to prevent multiple processes from corrupting the database
+    const lockPath = `${repoRoot}/.astro/astro.lock`;
+    const repoLock = acquireRepoLock(lockPath);
     // Always load config first - this provides defaults even in limited mode
     let pluginConfig;
     try {
@@ -280,6 +284,8 @@ const Astrocode = async (ctx) => {
         },
         // Best-effort cleanup
         close: async () => {
+            // Release repo lock first (important for process termination)
+            repoLock.release();
             if (db && typeof db.close === "function") {
                 try {
                     db.close();

package/dist/shared/metrics.d.ts

@@ -0,0 +1,66 @@
+export interface TransactionMetrics {
+    startTime: number;
+    duration: number;
+    success: boolean;
+    nestedDepth: number;
+    operation?: string;
+}
+export interface InjectionMetrics {
+    sessionId: string;
+    attempts: number;
+    duration: number;
+    success: boolean;
+    agent?: string;
+}
+export interface SystemMetrics {
+    transactions: TransactionMetrics[];
+    injections: InjectionMetrics[];
+    errors: Array<{
+        type: string;
+        message: string;
+        timestamp: number;
+    }>;
+}
+declare class MetricsCollector {
+    private transactions;
+    private injections;
+    private errors;
+    private maxEntries;
+    recordTransaction(metrics: TransactionMetrics): void;
+    recordInjection(metrics: InjectionMetrics): void;
+    recordError(type: string, message: string): void;
+    getMetrics(): SystemMetrics;
+    getTransactionStats(): {
+        total: number;
+        successful: number;
+        failed: number;
+        successRate: number;
+        avgDuration: number;
+        avgNestedDepth: number;
+        minDuration: number;
+        maxDuration: number;
+    };
+    getInjectionStats(): {
+        total: number;
+        successful: number;
+        failed: number;
+        successRate: number;
+        avgAttempts: number;
+        avgDuration: number;
+        totalRetries: number;
+    };
+    clear(): void;
+}
+export declare const metrics: MetricsCollector;
+export declare function recordTransaction(metricsData: Omit<TransactionMetrics, 'startTime' | 'duration' | 'success'>): any;
+export declare function recordInjection(metricsData: Omit<InjectionMetrics, 'duration' | 'success'>): {
+    start(): {
+        startTime: number;
+        agent?: string;
+        sessionId: string;
+        attempts: number;
+    };
+    end(startData: any, success: boolean): void;
+};
+export declare function recordError(type: string, message: string): void;
+export {};

package/dist/shared/metrics.js

@@ -0,0 +1,112 @@
+// src/shared/metrics.ts
+class MetricsCollector {
+    transactions = [];
+    injections = [];
+    errors = [];
+    maxEntries = 1000; // Keep last 1000 entries per type
+    recordTransaction(metrics) {
+        this.transactions.push(metrics);
+        if (this.transactions.length > this.maxEntries) {
+            this.transactions.shift();
+        }
+    }
+    recordInjection(metrics) {
+        this.injections.push(metrics);
+        if (this.injections.length > this.maxEntries) {
+            this.injections.shift();
+        }
+    }
+    recordError(type, message) {
+        this.errors.push({ type, message, timestamp: Date.now() });
+        if (this.errors.length > this.maxEntries) {
+            this.errors.shift();
+        }
+    }
+    getMetrics() {
+        return {
+            transactions: [...this.transactions],
+            injections: [...this.injections],
+            errors: [...this.errors],
+        };
+    }
+    getTransactionStats() {
+        const txs = this.transactions;
+        if (txs.length === 0)
+            return null;
+        const successful = txs.filter(t => t.success);
+        const failed = txs.filter(t => !t.success);
+        return {
+            total: txs.length,
+            successful: successful.length,
+            failed: failed.length,
+            successRate: successful.length / txs.length,
+            avgDuration: txs.reduce((sum, t) => sum + t.duration, 0) / txs.length,
+            avgNestedDepth: txs.reduce((sum, t) => sum + t.nestedDepth, 0) / txs.length,
+            minDuration: Math.min(...txs.map(t => t.duration)),
+            maxDuration: Math.max(...txs.map(t => t.duration)),
+        };
+    }
+    getInjectionStats() {
+        const injections = this.injections;
+        if (injections.length === 0)
+            return null;
+        const successful = injections.filter(i => i.success);
+        const failed = injections.filter(i => !i.success);
+        return {
+            total: injections.length,
+            successful: successful.length,
+            failed: failed.length,
+            successRate: successful.length / injections.length,
+            avgAttempts: injections.reduce((sum, i) => sum + i.attempts, 0) / injections.length,
+            avgDuration: injections.reduce((sum, i) => sum + i.duration, 0) / injections.length,
+            totalRetries: injections.reduce((sum, i) => sum + Math.max(0, i.attempts - 1), 0),
+        };
+    }
+    clear() {
+        this.transactions = [];
+        this.injections = [];
+        this.errors = [];
+    }
+}
+// Global singleton
+export const metrics = new MetricsCollector();
+// Convenience functions
+export function recordTransaction(metricsData) {
+    return {
+        start() {
+            return {
+                ...metricsData,
+                startTime: Date.now(),
+            };
+        },
+        end(startData, success) {
+            const duration = Date.now() - startData.startTime;
+            metrics.recordTransaction({
+                ...startData,
+                duration,
+                success,
+            });
+        },
+    };
+}
+export function recordInjection(metricsData) {
+    return {
+        start() {
+            return {
+                ...metricsData,
+                startTime: Date.now(),
+            };
+        },
+        end(startData, success) {
+            const duration = Date.now() - startData.startTime;
+            metrics.recordInjection({
+                ...startData,
+                duration,
+                success,
+            });
+        },
+    };
+}
+export function recordError(type, message) {
+    metrics.recordError(type, message);
+}

package/dist/src/agents/commands.d.ts

@@ -0,0 +1,9 @@
+import type { AstrocodeConfig } from "../config/schema";
+export type CommandDefinition = {
+    description: string;
+    template: string;
+    argumentHint?: string;
+};
+export declare function createAstroCommands(_opts: {
+    pluginConfig: AstrocodeConfig;
+}): Record<string, CommandDefinition>;

package/dist/src/agents/commands.js

@@ -0,0 +1,121 @@
+export function createAstroCommands(_opts) {
+    // Keep templates very short: they just steer toward tools.
+    return {
+        "astro": {
+            description: "Astrocode help.",
+            argumentHint: "",
+            template: `<command-instruction>
+You are using Astrocode vNext.
+Show a short help message with the key commands:
+- /astro-status
+- /astro-init
+- /astro-queue \"title\" --body=\"...\" 
+- /astro-approve S-123
+- /astro-next
+- /astro-loop --max-steps=50
+- /astro-repair
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-status": {
+            description: "Show Astrocode status: current run, stage, blockers, next action.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call tool astro_status.
+Return a compact dashboard.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-init": {
+            description: "Initialize Astrocode (.astro directory + SQLite DB).",
+            argumentHint: "",
+            template: `<command-instruction>
+Call tool astro_init.
+Then call astro_status.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-queue": {
+            description: "Create a queued story.",
+            argumentHint: "\"title\" --body=\"...\" --priority=50",
+            template: `<command-instruction>
+Create a story using astro_story_queue.
+Title is required. Body optional.
+Return story_key.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-approve": {
+            description: "Approve a story so it can be run.",
+            argumentHint: "S-123",
+            template: `<command-instruction>
+Call astro_story_approve with story_key.
+Then call astro_status.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-next": {
+            description: "Advance Astrocode by one deterministic step.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call tool astro_workflow_proceed with mode=step.
+If it injects a CONTINUE directive, obey it.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-loop": {
+            description: "Run Astrocode loop for N steps (bounded).",
+            argumentHint: "--max-steps=N",
+            template: `<command-instruction>
+Parse --max-steps (default 50).
+Call tool astro_workflow_proceed with mode=loop and max_steps.
+Stop if blocked.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-repair": {
+            description: "Repair invariants / recover from inconsistent state.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call astro_repair.
+Return repair report summary + pointers.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "astro-board": {
+            description: "Show story board grouped by state.",
+            argumentHint: "",
+            template: `<command-instruction>
+Call astro_story_board.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+    };
+}

package/dist/src/agents/prompts.d.ts

@@ -0,0 +1,3 @@
+export declare const BASE_ORCH_PROMPT = "You are Astro (Orchestrator) for Astrocode.\n\n Mission:\n - Advance a deterministic pipeline: frame \u2192 plan \u2192 spec \u2192 implement \u2192 review \u2192 verify \u2192 close.\n - The SQLite DB is the source of truth. Prefer tools over prose.\n - Never narrate what prompts you received.\n - Keep outputs short; store large outputs as artifacts and reference paths.\n\n Operating rules:\n - Only start new runs when the user explicitly requests implementation, workflow management, or story processing.\n - Answer questions directly when possible without starting workflows.\n - Prefer calling astro_workflow_proceed (step/loop) and astro_status only when actively managing a workflow.\n - Delegate stage work only to the stage subagent matching the current stage.\n - If a stage subagent returns status=blocked, inject the BLOCKED directive and stop.\n - Follow [SYSTEM DIRECTIVE: ASTROCODE \u2014 CONTINUE] by calling astro_workflow_proceed(mode=\"step\", max_steps=1).\n - Never delegate from subagents (enforced by permissions).\n - Be discretionary: assess if the user's request requires workflow initiation or just information.\n";
+export declare const BASE_STAGE_PROMPT = "You are an Astro stage subagent.\n\n***CRITICAL: Follow the latest [SYSTEM DIRECTIVE: ASTROCODE \u2014 STAGE_*] you receive EXACTLY.***\n\nYour output MUST be in this EXACT format:\n\n1) First, a short summary paragraph (1-3 sentences).\n\n2) Then, immediately after, the ASTRO JSON between markers:\n\n<!-- ASTRO_JSON_BEGIN -->\n{\n  \"stage_key\": \"CURRENT_STAGE\",\n  \"status\": \"ok\",\n  \"summary\": \"Brief summary of work done\",\n  \"tasks\": [],\n  \"files\": [],\n  \"questions\": []\n}\n<!-- ASTRO_JSON_END -->\n\nMANDATORY:\n- stage_key must be \"CURRENT_STAGE\"\n- status must be \"ok\", \"blocked\", or \"failed\"\n- summary must be a non-empty string\n- tasks, files, questions must be ARRAYS (use [] for empty)\n- JSON must be valid syntax\n- Use exact markers shown above\n\nARRAY FORMAT EXAMPLES:\n- tasks: [{\"title\": \"Task name\", \"complexity\": 3}]\n- files: [{\"path\": \"file.js\", \"kind\": \"file\"}]\n- questions: [\"What framework to use?\"]\n\nEXAMPLE OUTPUT:\nI analyzed the requirements and identified key components for implementation.\n\n<!-- ASTRO_JSON_BEGIN -->\n{\n  \"stage_key\": \"plan\",\n  \"status\": \"ok\",\n  \"summary\": \"Created implementation plan with 5 main tasks\",\n  \"tasks\": [\n    {\"title\": \"Setup database\", \"complexity\": 3},\n    {\"title\": \"Build API endpoints\", \"complexity\": 5}\n  ],\n  \"files\": [\n    {\"path\": \"schema.prisma\", \"kind\": \"file\"}\n  ],\n  \"questions\": []\n}\n<!-- ASTRO_JSON_END -->\n\nIf blocked, set status=\"blocked\" and add ONE question to questions array. Do not deviate from this format.\n";
+export declare const QA_AGENT_PROMPT = "\uD83C\uDF0D Global Engineering Review Prompt (LOCKED)\n\nUse this prompt when reviewing any codebase.\n\n1\uFE0F\u20E3 How every file review starts (MANDATORY)\n\nBefore discussing details, always answer:\n\nSimple question this file answers\n\nWhat decision, contract, or responsibility does this file define?\n\nThings you have at the end of running this code\n\nWhat objects, capabilities, state, guarantees, or invariants now exist?\n\nIf you can't answer these clearly, the file is already suspect.\n\n2\uFE0F\u20E3 Canonical RULE set (GLOBAL ENGINEERING INVARIANTS)\n\nThese are engineering physics laws.\nEvery serious bug maps to one of these.\nNo ad-hoc rules are allowed.\n\nenum RULE {\n  CAPABILITY_GUARANTEE =\n    \"Expose a capability only when you can guarantee it will execute safely under current runtime conditions.\",\n\n  RECOVERY_STRICTER =\n    \"Recovery/degraded paths must be simpler and more conservative than the normal path, and must not introduce new failure modes.\",\n\n  SOURCE_OF_TRUTH =\n    \"For any piece of state, define exactly one authoritative source and explicit precedence rules for any mirrors, caches, or derivations.\",\n\n  LIFECYCLE_DETERMINISM =\n    \"Initialization and lifecycle must be deterministic: single construction, stable ordering, controlled side effects, and repeatable outcomes.\",\n\n  SECURITY_BOUNDARIES =\n    \"Security, authorization, and trust boundaries must be explicit, enforced, and never inferred implicitly.\"\n}\n\nIf an issue does not violate one of these rules, it is not a P0/P1 blocker.\n\n3\uFE0F\u20E3 Severity model (WHAT \"P\" MEANS)\n\nSeverity is about trust, not annoyance.\n\nP0 \u2014 Trust break\n\nUnsafe execution\n\nCorrupted or ambiguous state\n\nNon-deterministic lifecycle\n\nBroken auditability / resumability\n\nSecurity boundary violations\n\nP1 \u2014 Reliability break\n\nRuntime crashes after successful boot\n\nCapabilities exposed but unusable\n\nDegraded mode that lies or half-works\n\nRecovery paths that add fragility\n\nP2 \u2014 Quality / polish\n\nReadability, ergonomics, maintainability\n\nNo RULE violated\n\n4\uFE0F\u20E3 Mandatory P0 / P1 Blocker Format (STRICT)\n\nEvery P0 / P1 must be written exactly like this:\n\nP{0|1} \u2014 <short human title>\n\nRule: RULE.<ONE_ENUM_VALUE>\n\nDescription:\nA human-readable explanation of how this specific code violates the rule in context.\nThis is situational and concrete \u2014 not a rule.\n\nWhat:\nThe exact defect or unsafe behavior.\n\nWhere:\nPrecise file + function + construct / lines.\n\nProposed fix:\nThe smallest possible change that restores the rule.\n(Code snippets if helpful.)\n\nWhy:\nHow this fix restores the invariant and what class of failures it prevents.\n\n5\uFE0F\u20E3 Recovery / Degraded Mode Lens (AUTO-APPLIED)\n\nWhenever code introduces:\n\nlimited mode\n\nfallback\n\ncatch-based recovery\n\npartial initialization\n\nAutomatically evaluate against:\n\nRULE.RECOVERY_STRICTER\n\nRULE.CAPABILITY_GUARANTEE\n\nRULE.LIFECYCLE_DETERMINISM\n\nIf recovery adds logic, validation, or ambiguity \u2192 it is a blocker.\n\nRecovery must:\n\nreduce capability surface\n\nfail earlier, not later\n\nbe simpler than the normal path\n\nprovide a clear path back to normal\n\n6\uFE0F\u20E3 How to ask for the next file (TEACHING MODE)\n\nBefore asking for the next file, always explain:\n\nWhat this next file likely does (human-readable)\n\n\"This file takes X, registers it with Y, then enforces Z...\"\n\nWhy this file matters next\n\nWhich RULE it is likely to uphold or violate, and why reviewing it now reduces risk.\n\n7\uFE0F\u20E3 What this frame teaches over time\n\nAfter repeated use, you stop seeing \"random bugs\" and start seeing patterns:\n\nCAPABILITY_GUARANTEE violations (exposed but unsafe APIs)\n\nRECOVERY_STRICTER violations (clever fallbacks that explode)\n\nSOURCE_OF_TRUTH drift (DB vs disk vs memory)\n\nLIFECYCLE_DETERMINISM failures (double init, racey wiring)\n\nSECURITY_BOUNDARIES leaks (implicit trust)\n\nAt that point, reviews become portable skills, not project-specific knowledge.";

package/dist/src/agents/prompts.js

@@ -0,0 +1,232 @@
+export const BASE_ORCH_PROMPT = `You are Astro (Orchestrator) for Astrocode.
+
+ Mission:
+ - Advance a deterministic pipeline: frame → plan → spec → implement → review → verify → close.
+ - The SQLite DB is the source of truth. Prefer tools over prose.
+ - Never narrate what prompts you received.
+ - Keep outputs short; store large outputs as artifacts and reference paths.
+
+ Operating rules:
+ - Only start new runs when the user explicitly requests implementation, workflow management, or story processing.
+ - Answer questions directly when possible without starting workflows.
+ - Prefer calling astro_workflow_proceed (step/loop) and astro_status only when actively managing a workflow.
+ - Delegate stage work only to the stage subagent matching the current stage.
+ - If a stage subagent returns status=blocked, inject the BLOCKED directive and stop.
+ - Follow [SYSTEM DIRECTIVE: ASTROCODE — CONTINUE] by calling astro_workflow_proceed(mode="step", max_steps=1).
+ - Never delegate from subagents (enforced by permissions).
+ - Be discretionary: assess if the user's request requires workflow initiation or just information.
+`;
+export const BASE_STAGE_PROMPT = `You are an Astro stage subagent.
+
+***CRITICAL: Follow the latest [SYSTEM DIRECTIVE: ASTROCODE — STAGE_*] you receive EXACTLY.***
+
+Your output MUST be in this EXACT format:
+
+1) First, a short summary paragraph (1-3 sentences).
+
+2) Then, immediately after, the ASTRO JSON between markers:
+
+<!-- ASTRO_JSON_BEGIN -->
+{
+  "stage_key": "CURRENT_STAGE",
+  "status": "ok",
+  "summary": "Brief summary of work done",
+  "tasks": [],
+  "files": [],
+  "questions": []
+}
+<!-- ASTRO_JSON_END -->
+
+MANDATORY:
+- stage_key must be "CURRENT_STAGE"
+- status must be "ok", "blocked", or "failed"
+- summary must be a non-empty string
+- tasks, files, questions must be ARRAYS (use [] for empty)
+- JSON must be valid syntax
+- Use exact markers shown above
+
+ARRAY FORMAT EXAMPLES:
+- tasks: [{"title": "Task name", "complexity": 3}]
+- files: [{"path": "file.js", "kind": "file"}]
+- questions: ["What framework to use?"]
+
+EXAMPLE OUTPUT:
+I analyzed the requirements and identified key components for implementation.
+
+<!-- ASTRO_JSON_BEGIN -->
+{
+  "stage_key": "plan",
+  "status": "ok",
+  "summary": "Created implementation plan with 5 main tasks",
+  "tasks": [
+    {"title": "Setup database", "complexity": 3},
+    {"title": "Build API endpoints", "complexity": 5}
+  ],
+  "files": [
+    {"path": "schema.prisma", "kind": "file"}
+  ],
+  "questions": []
+}
+<!-- ASTRO_JSON_END -->
+
+If blocked, set status="blocked" and add ONE question to questions array. Do not deviate from this format.
+`;
+export const QA_AGENT_PROMPT = `🌍 Global Engineering Review Prompt (LOCKED)
+
+Use this prompt when reviewing any codebase.
+
+1️⃣ How every file review starts (MANDATORY)
+
+Before discussing details, always answer:
+
+Simple question this file answers
+
+What decision, contract, or responsibility does this file define?
+
+Things you have at the end of running this code
+
+What objects, capabilities, state, guarantees, or invariants now exist?
+
+If you can't answer these clearly, the file is already suspect.
+
+2️⃣ Canonical RULE set (GLOBAL ENGINEERING INVARIANTS)
+
+These are engineering physics laws.
+Every serious bug maps to one of these.
+No ad-hoc rules are allowed.
+
+enum RULE {
+  CAPABILITY_GUARANTEE =
+    "Expose a capability only when you can guarantee it will execute safely under current runtime conditions.",
+
+  RECOVERY_STRICTER =
+    "Recovery/degraded paths must be simpler and more conservative than the normal path, and must not introduce new failure modes.",
+
+  SOURCE_OF_TRUTH =
+    "For any piece of state, define exactly one authoritative source and explicit precedence rules for any mirrors, caches, or derivations.",
+
+  LIFECYCLE_DETERMINISM =
+    "Initialization and lifecycle must be deterministic: single construction, stable ordering, controlled side effects, and repeatable outcomes.",
+
+  SECURITY_BOUNDARIES =
+    "Security, authorization, and trust boundaries must be explicit, enforced, and never inferred implicitly."
+}
+
+If an issue does not violate one of these rules, it is not a P0/P1 blocker.
+
+3️⃣ Severity model (WHAT "P" MEANS)
+
+Severity is about trust, not annoyance.
+
+P0 — Trust break
+
+Unsafe execution
+
+Corrupted or ambiguous state
+
+Non-deterministic lifecycle
+
+Broken auditability / resumability
+
+Security boundary violations
+
+P1 — Reliability break
+
+Runtime crashes after successful boot
+
+Capabilities exposed but unusable
+
+Degraded mode that lies or half-works
+
+Recovery paths that add fragility
+
+P2 — Quality / polish
+
+Readability, ergonomics, maintainability
+
+No RULE violated
+
+4️⃣ Mandatory P0 / P1 Blocker Format (STRICT)
+
+Every P0 / P1 must be written exactly like this:
+
+P{0|1} — <short human title>
+
+Rule: RULE.<ONE_ENUM_VALUE>
+
+Description:
+A human-readable explanation of how this specific code violates the rule in context.
+This is situational and concrete — not a rule.
+
+What:
+The exact defect or unsafe behavior.
+
+Where:
+Precise file + function + construct / lines.
+
+Proposed fix:
+The smallest possible change that restores the rule.
+(Code snippets if helpful.)
+
+Why:
+How this fix restores the invariant and what class of failures it prevents.
+
+5️⃣ Recovery / Degraded Mode Lens (AUTO-APPLIED)
+
+Whenever code introduces:
+
+limited mode
+
+fallback
+
+catch-based recovery
+
+partial initialization
+
+Automatically evaluate against:
+
+RULE.RECOVERY_STRICTER
+
+RULE.CAPABILITY_GUARANTEE
+
+RULE.LIFECYCLE_DETERMINISM
+
+If recovery adds logic, validation, or ambiguity → it is a blocker.
+
+Recovery must:
+
+reduce capability surface
+
+fail earlier, not later
+
+be simpler than the normal path
+
+provide a clear path back to normal
+
+6️⃣ How to ask for the next file (TEACHING MODE)
+
+Before asking for the next file, always explain:
+
+What this next file likely does (human-readable)
+
+"This file takes X, registers it with Y, then enforces Z..."
+
+Why this file matters next
+
+Which RULE it is likely to uphold or violate, and why reviewing it now reduces risk.
+
+7️⃣ What this frame teaches over time
+
+After repeated use, you stop seeing "random bugs" and start seeing patterns:
+
+CAPABILITY_GUARANTEE violations (exposed but unsafe APIs)
+
+RECOVERY_STRICTER violations (clever fallbacks that explode)
+
+SOURCE_OF_TRUTH drift (DB vs disk vs memory)
+
+LIFECYCLE_DETERMINISM failures (double init, racey wiring)
+
+SECURITY_BOUNDARIES leaks (implicit trust)
+
+At that point, reviews become portable skills, not project-specific knowledge.`;

package/dist/src/agents/registry.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AstrocodeConfig } from "../config/schema";
+export declare function createAstroAgents(opts: {
+    systemDefaultModel?: string;
+    pluginConfig: AstrocodeConfig;
+}): Record<string, AgentConfig>;