opencode-matrixx 2.2.0 → 2.3.0

package/dist/features/bdd/schema.d.ts

@@ -0,0 +1,434 @@
+import { z } from "zod";
+export declare const StepKeywordSchema: z.ZodEnum<{
+    Given: "Given";
+    When: "When";
+    Then: "Then";
+    And: "And";
+    But: "But";
+}>;
+export declare const StepSchema: z.ZodObject<{
+    keyword: z.ZodEnum<{
+        Given: "Given";
+        When: "When";
+        Then: "Then";
+        And: "And";
+        But: "But";
+    }>;
+    text: z.ZodString;
+    dataTable: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    docString: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ExampleRowSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export declare const ScenarioSchema: z.ZodObject<{
+    name: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        keyword: z.ZodEnum<{
+            Given: "Given";
+            When: "When";
+            Then: "Then";
+            And: "And";
+            But: "But";
+        }>;
+        text: z.ZodString;
+        dataTable: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        docString: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strip>;
+export declare const BackgroundSchema: z.ZodObject<{
+    steps: z.ZodArray<z.ZodObject<{
+        keyword: z.ZodEnum<{
+            Given: "Given";
+            When: "When";
+            Then: "Then";
+            And: "And";
+            But: "But";
+        }>;
+        text: z.ZodString;
+        dataTable: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        docString: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const RuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            keyword: z.ZodEnum<{
+                Given: "Given";
+                When: "When";
+                Then: "Then";
+                And: "And";
+                But: "But";
+            }>;
+            text: z.ZodString;
+            dataTable: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            docString: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const KebabCaseSchema: z.ZodString;
+export declare const CamelCaseSchema: z.ZodString;
+export declare const DottedKebabSchema: z.ZodString;
+export declare const UrlPathSchema: z.ZodString;
+export declare const HttpMethodSchema: z.ZodEnum<{
+    HEAD: "HEAD";
+    DELETE: "DELETE";
+    GET: "GET";
+    OPTIONS: "OPTIONS";
+    PATCH: "PATCH";
+    POST: "POST";
+    PUT: "PUT";
+}>;
+export declare const ResponseFormatSchema: z.ZodEnum<{
+    binary: "binary";
+    json: "json";
+    text: "text";
+    html: "html";
+    xml: "xml";
+}>;
+export declare const VarTypeSchema: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    object: "object";
+    null: "null";
+    array: "array";
+}>;
+export declare const ApiEndpointSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        HEAD: "HEAD";
+        DELETE: "DELETE";
+        GET: "GET";
+        OPTIONS: "OPTIONS";
+        PATCH: "PATCH";
+        POST: "POST";
+        PUT: "PUT";
+    }>;
+    path: z.ZodString;
+    request: z.ZodOptional<z.ZodString>;
+    response: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ApiResponseSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    format: z.ZodEnum<{
+        binary: "binary";
+        json: "json";
+        text: "text";
+        html: "html";
+        xml: "xml";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const UiRouteSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strict>;
+export declare const UiTestIdSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strict>;
+export declare const UiStringSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strict>;
+export declare const StateVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        null: "null";
+        array: "array";
+    }>;
+    default: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const StateTransitionSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    trigger: z.ZodString;
+}, z.core.$strict>;
+export declare const ApiAnnotationsSchema: z.ZodObject<{
+    endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        method: z.ZodEnum<{
+            HEAD: "HEAD";
+            DELETE: "DELETE";
+            GET: "GET";
+            OPTIONS: "OPTIONS";
+            PATCH: "PATCH";
+            POST: "POST";
+            PUT: "PUT";
+        }>;
+        path: z.ZodString;
+        request: z.ZodOptional<z.ZodString>;
+        response: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    responses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        status: z.ZodNumber;
+        format: z.ZodEnum<{
+            binary: "binary";
+            json: "json";
+            text: "text";
+            html: "html";
+            xml: "xml";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const UiAnnotationsSchema: z.ZodObject<{
+    routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>>;
+    testIds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>>;
+    strings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const StateAnnotationsSchema: z.ZodObject<{
+    variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            null: "null";
+            array: "array";
+        }>;
+        default: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>>;
+    transitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        trigger: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const ContractAnnotationsSchema: z.ZodObject<{
+    api: z.ZodOptional<z.ZodObject<{
+        endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            method: z.ZodEnum<{
+                HEAD: "HEAD";
+                DELETE: "DELETE";
+                GET: "GET";
+                OPTIONS: "OPTIONS";
+                PATCH: "PATCH";
+                POST: "POST";
+                PUT: "PUT";
+            }>;
+            path: z.ZodString;
+            request: z.ZodOptional<z.ZodString>;
+            response: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        responses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            status: z.ZodNumber;
+            format: z.ZodEnum<{
+                binary: "binary";
+                json: "json";
+                text: "text";
+                html: "html";
+                xml: "xml";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    ui: z.ZodOptional<z.ZodObject<{
+        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>>;
+        testIds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+        strings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    state: z.ZodOptional<z.ZodObject<{
+        variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                null: "null";
+                array: "array";
+            }>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>>>;
+        transitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            trigger: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    assumptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const FeatureSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const ContractSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    generatedAt: z.ZodString;
+    sourceFile: z.ZodString;
+    feature: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    scenarios: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            keyword: z.ZodEnum<{
+                Given: "Given";
+                When: "When";
+                Then: "Then";
+                And: "And";
+                But: "But";
+            }>;
+            text: z.ZodString;
+            dataTable: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            docString: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$strip>>;
+    background: z.ZodOptional<z.ZodObject<{
+        steps: z.ZodArray<z.ZodObject<{
+            keyword: z.ZodEnum<{
+                Given: "Given";
+                When: "When";
+                Then: "Then";
+                And: "And";
+                But: "But";
+            }>;
+            text: z.ZodString;
+            dataTable: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            docString: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        scenarios: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            tags: z.ZodArray<z.ZodString>;
+            steps: z.ZodArray<z.ZodObject<{
+                keyword: z.ZodEnum<{
+                    Given: "Given";
+                    When: "When";
+                    Then: "Then";
+                    And: "And";
+                    But: "But";
+                }>;
+                text: z.ZodString;
+                dataTable: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+                docString: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            examples: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    annotations: z.ZodObject<{
+        api: z.ZodOptional<z.ZodObject<{
+            endpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                method: z.ZodEnum<{
+                    HEAD: "HEAD";
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    OPTIONS: "OPTIONS";
+                    PATCH: "PATCH";
+                    POST: "POST";
+                    PUT: "PUT";
+                }>;
+                path: z.ZodString;
+                request: z.ZodOptional<z.ZodString>;
+                response: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            responses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                status: z.ZodNumber;
+                format: z.ZodEnum<{
+                    binary: "binary";
+                    json: "json";
+                    text: "text";
+                    html: "html";
+                    xml: "xml";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        ui: z.ZodOptional<z.ZodObject<{
+            routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>>>;
+            testIds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+            strings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        state: z.ZodOptional<z.ZodObject<{
+            variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                }>;
+                default: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strict>>>;
+            transitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                trigger: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        assumptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type Step = z.infer<typeof StepSchema>;
+export type StepKeyword = z.infer<typeof StepKeywordSchema>;
+export type ExampleRow = z.infer<typeof ExampleRowSchema>;
+export type Scenario = z.infer<typeof ScenarioSchema>;
+export type Background = z.infer<typeof BackgroundSchema>;
+export type Rule = z.infer<typeof RuleSchema>;
+export type HttpMethod = z.infer<typeof HttpMethodSchema>;
+export type ResponseFormat = z.infer<typeof ResponseFormatSchema>;
+export type VarType = z.infer<typeof VarTypeSchema>;
+export type ApiEndpoint = z.infer<typeof ApiEndpointSchema>;
+export type ApiResponse = z.infer<typeof ApiResponseSchema>;
+export type UiRoute = z.infer<typeof UiRouteSchema>;
+export type UiTestId = z.infer<typeof UiTestIdSchema>;
+export type UiString = z.infer<typeof UiStringSchema>;
+export type StateVariable = z.infer<typeof StateVariableSchema>;
+export type StateTransition = z.infer<typeof StateTransitionSchema>;
+export type ApiAnnotations = z.infer<typeof ApiAnnotationsSchema>;
+export type UiAnnotations = z.infer<typeof UiAnnotationsSchema>;
+export type StateAnnotations = z.infer<typeof StateAnnotationsSchema>;
+export type ContractAnnotations = z.infer<typeof ContractAnnotationsSchema>;
+export type Feature = z.infer<typeof FeatureSchema>;
+export type Contract = z.infer<typeof ContractSchema>;

package/dist/features/bdd/types.d.ts

@@ -0,0 +1,2 @@
+export type { ApiAnnotations, ApiEndpoint, ApiResponse, Background, Contract, ContractAnnotations, ExampleRow, Feature, HttpMethod, ResponseFormat, Rule, Scenario, StateAnnotations, StateTransition, StateVariable, Step, StepKeyword, UiAnnotations, UiRoute, UiString, UiTestId, VarType, } from "./schema";
+export { ApiAnnotationsSchema, ApiEndpointSchema, ApiResponseSchema, CamelCaseSchema, ContractAnnotationsSchema, ContractSchema, DottedKebabSchema, FeatureSchema, HttpMethodSchema, KebabCaseSchema, ResponseFormatSchema, ScenarioSchema, StateAnnotationsSchema, StateTransitionSchema, StateVariableSchema, StepSchema, UiAnnotationsSchema, UiRouteSchema, UiStringSchema, UiTestIdSchema, UrlPathSchema, VarTypeSchema, } from "./schema";

package/dist/features/builtin-commands/templates/bdd-backend.d.ts

@@ -0,0 +1 @@
+export declare const BDD_BACKEND_TEMPLATE = "# /bdd-backend\n\nGenerate typed API services from one or more BDD Contract JSON files.\n\n## Usage\n\nSingle file:\n```\n/bdd-backend <contract.json> --out <out-dir>\n```\n\nBatch (directory or glob):\n```\n/bdd-backend <dir> --out <out-dir>\n/bdd-backend \"<dir>/**/*.contract.json\" --out <out-dir>\n```\n\n## Workflow\n\nSingle file:\n1. Read the Contract JSON\n2. Extract @api:endpoint and @api:response annotations\n3. Generate typed service files with Zod request/response schemas\n4. One service function per endpoint\n5. Report generated file paths\n\nBatch input (directory or glob):\n1. Expand the input into a list of .contract.json files\n2. For each contract, run the single-file workflow above\n3. Use background subagents (`task(run_in_background=true)`) to run each in parallel (up to 5 concurrent)\n4. Wait for all to finish, then collect results and report a summary\n\n## Output\n\nSingle file: TypeScript service files (.ts) with Zod validation schemas for each API endpoint.\n\nBatch: per-feature service subdirectory tree under `<out-dir>/<feature>/backend/`.\n\n## Git Actions (HARD RULE)\nNEVER run `git commit`, `git add`, `git push`, `git rebase`, `git reset`, `git tag`, or any other git command in this command context. The pipeline runner is responsible for version control. You may only create/edit the generated files in the target output directory.\n";

package/dist/features/builtin-commands/templates/bdd-contract.d.ts

@@ -0,0 +1 @@
+export declare const BDD_CONTRACT_TEMPLATE = "# /bdd-contract\n\nGenerate BDD Contract JSON from one or more Gherkin .feature files. The .feature file must be 100% pure Gherkin (no '# @annotation' comments). The bdd-contract agent infers all annotations (api/ui/state/assumptions) via LLM reasoning from feature content.\n\n## Usage\n\nSingle file:\n```\n/bdd-contract <feature-path> [--force]\n```\n\nBatch (directory or glob):\n```\n/bdd-contract <dir> [--force]\n/bdd-contract \"<dir>/**/*.feature\" [--force]\n```\n\n## Workflow\n\nSingle file:\n1. Parse the .feature file using bdd_parse_gherkin tool (deterministic AST)\n2. Create initial Contract JSON using bdd_create_contract tool (deterministic, empty annotations)\n3. ENRICH the Contract: the bdd-contract agent infers annotations (api/ui/state/assumptions) via LLM reasoning from feature content and edits the Contract JSON file in place\n4. **VALIDATE**: call bdd_validate_contract on the file -- if it returns errors, fix the contract and re-validate. The contract must conform to the strict ContractSchema (all annotation field names must match the required naming conventions: kebab-case for routes/testIds, camelCase for state variables, dotted kebab-case for string keys).\n5. Report the Contract file path, key features identified, and annotations inferred\n\nBatch input (directory or glob):\n1. Expand the input into a list of .feature files\n2. For each .feature file, run the single-file workflow above\n3. Report a summary of all generated contracts (count, paths, any failures)\n\n## Output\n\nSingle file: a `<file>.contract.json` alongside the source .feature file, conforming to ContractSchema v1 with schemaVersion: 1, scenarios, and LLM-inferred annotations.\n\nBatch: one contract file per source .feature, written next to each source file.\n\n## Git Actions (HARD RULE)\nNEVER run `git commit`, `git add`, `git push`, `git rebase`, `git reset`, `git tag`, or any other git command in this command context. The pipeline runner is responsible for version control. You may only create/edit the generated contract JSON.\n";

package/dist/features/builtin-commands/templates/bdd-frontend.d.ts

@@ -0,0 +1 @@
+export declare const BDD_FRONTEND_TEMPLATE = "# /bdd-frontend\n\nGenerate React components and a dev preview server from one or more BDD Contract JSON files.\n\n## Usage\n\nSingle file:\n```\n/bdd-frontend <contract.json>\n```\n\nBatch (directory or glob):\n```\n/bdd-frontend <dir> --out <out-dir>\n/bdd-frontend \"<dir>/**/*.contract.json\" --out <out-dir>\n```\n\n## Workflow\n\nSingle file:\n1. Read the Contract JSON\n2. Extract @ui:* annotations (routes, testIds, strings)\n3. Generate React components for each route/feature\n4. Implement form fields from state variables\n5. Apply test IDs and accessibility attributes\n6. Generate a preview-server.ts for visual review\n\nBatch input (directory or glob):\n1. Expand the input into a list of .contract.json files\n2. For each contract, run the single-file workflow above\n3. Use background subagents (`task(run_in_background=true)`) to run each in parallel (up to 5 concurrent)\n4. Wait for all to finish, then collect results and report a summary\n\n## Output\n\nSingle file: React component files (.tsx) with TypeScript props, design tokens, data-testid attributes, and a preview-server.ts for visual review.\n\nBatch: per-feature component subdirectory tree under `<out-dir>/<feature>/components/`, with one preview-server.ts per feature.\n\n## Git Actions (HARD RULE)\nNEVER run `git commit`, `git add`, `git push`, `git rebase`, `git reset`, `git tag`, or any other git command in this command context. The pipeline runner is responsible for version control. You may only create/edit the generated files in the target output directory.\n";

package/dist/features/builtin-commands/templates/bdd-pipeline.d.ts

@@ -0,0 +1 @@
+export declare const BDD_PIPELINE_TEMPLATE = "# /bdd-pipeline\n\nFull BDD pipeline: parse one or more .feature files, generate a Contract, run\nthe 3 parallel subagents (tests, frontend, backend), and write a per-feature\nANALYSIS.md. The pipeline is implemented as a tool \u2014 same input produces the\nsame task shape every run.\n\n## Usage\n\n```\n/bdd-pipeline <feature-path|dir|glob> --out <out-dir> [--force]\n```\n\nExamples:\n- Single file: `/bdd-pipeline features/auth/login.feature --out ./generated`\n- Directory: `/bdd-pipeline features/auth --out ./generated`\n- Glob: `/bdd-pipeline \"features/**/*.feature\" --out ./generated`\n\n## What to do\n\n1. Call the `bdd_pipeline_run` tool with the resolved inputs:\n\n   ```json\n   {\n     \"featurePaths\": [\"<absolute path(s) or glob(s)>\"],\n     \"outDir\": \"<absolute output dir>\",\n     \"force\": false\n   }\n   ```\n\n   The tool returns `{ success, count, passed, failed, results[] }`. Each\n   `result` contains `status`, per-stage `tests_passed`/`tests_failed`,\n   `filesCreated`, `missingOutputs`, and `error`.\n\n2. Report the aggregated result. PASS means every feature has `status: \"PASS\"`\n   (all 3 subagent stages completed + the file-existence gate passed). FAIL\n   otherwise \u2014 list the failing features, failing stages, and missing outputs.\n\n3. Do NOT spawn subagents, parse .feature files, generate components, or write\n   ANALYSIS.md yourself \u2014 the tool does all of that.\n\n4. Do NOT run any git commands (commit, add, push, rebase, etc.).\n";

package/dist/features/builtin-commands/templates/bdd-tests.d.ts

@@ -0,0 +1 @@
+export declare const BDD_TESTS_TEMPLATE = "# /bdd-tests\n\nGenerate Cucumber step definitions and page objects from one or more BDD Contract JSON files.\n\n## Usage\n\nSingle file:\n```\n/bdd-tests <contract.json> --out <out-dir>\n```\n\nBatch (directory or glob):\n```\n/bdd-tests <dir> --out <out-dir>\n/bdd-tests \"<dir>/**/*.contract.json\" --out <out-dir>\n```\n\n## Workflow\n\nSingle file:\n1. Read the Contract JSON file\n2. Extract feature scenarios and their steps\n3. Generate Cucumber step definition files (Given/When/Then/And/But)\n4. Generate page object classes for UI interactions\n5. Generate `cucumber.cjs` (CommonJS, NOT `cucumber.js`) + a per-feature `Dockerfile` + `run-tests.sh` so the tests are runnable in CI and locally\n6. Verify with `npx cucumber-js` via bash (use the generated `run-tests.sh` if it exists, else invoke cucumber directly)\n\nBatch input (directory or glob):\n1. Expand the input into a list of .contract.json files\n2. For each contract, run the single-file workflow above (including the per-feature Dockerfile + run-tests.sh generation)\n3. Use background subagents (`task(run_in_background=true)`) to run each in parallel (up to 5 concurrent)\n4. Wait for all to finish and collect results\n5. AFTER all per-feature runs finish, generate TWO parent-shared files at the input directory root:\n   - `<input-dir>/Dockerfile` -- same base image as the per-feature one, CMD points to the parent run-tests.sh\n   - `<input-dir>/run-tests.sh` -- iterates every feature subdir that has a run-tests.sh and invokes it in sequence (with BDD_FEATURE filter support)\n6. Report a summary that lists the per-feature outputs AND the parent batch runner\n\n## Output\n\nSingle file: `<out-dir>/<feature>/` containing `cucumber.cjs`, `Dockerfile`, `run-tests.sh`, plus `tests/` (step definitions, page objects, world, hooks).\n\nBatch: per-feature subdirectory tree under `<input-dir>/<feature>/` with the same layout for each feature, PLUS parent-shared `<input-dir>/Dockerfile` and `<input-dir>/run-tests.sh` for running every feature in one go.\n\n## Git Actions (HARD RULE)\nNEVER run `git commit`, `git add`, `git push`, `git rebase`, `git reset`, `git tag`, or any other git command in this command context. The pipeline runner is responsible for version control. You may only create/edit the generated files in the target output directory.\n";

package/dist/features/builtin-commands/templates/dcp-profile.d.ts

@@ -0,0 +1 @@
+export declare const DCP_PROFILE_TEMPLATE = "You are switching the active DCP (Dynamic Context Pruning) profile tier.\n\nThis command is provided by the Matrixx plugin to call a user-managed shell script that swaps the active DCP configuration. The script lives in the user's home directory and is not part of the Matrixx codebase.\n\n## Step 1: Verify DCP is installed\n\nCheck whether the DCP plugin is installed at the standard OpenCode plugin location:\n\n```bash\nif [ ! -d \"$HOME/.config/opencode/node_modules/@tarquinen/opencode-dcp\" ]; then\n  echo \"DCP is not installed at the standard OpenCode plugin location.\" >&2\n  echo \"Install it with: npm install --prefix ~/.config/opencode @tarquinen/opencode-dcp\" >&2\n  exit 1\nfi\n```\n\nIf the directory does not exist, stop immediately and report the error to the user. Do not proceed.\n\n## Step 2: Resolve the switch script path\n\nThe switch script location is configurable via the `dcp.switch_script` key in the user's `matrixx.jsonc` (read from `~/.config/opencode/matrixx.jsonc` or the project-level file). If that key is absent, use the default:\n\n```\n~/.myopencode/dcp/switch-profile.sh\n```\n\nIf the resolved script does not exist or is not executable, stop and report the path to the user.\n\n## Step 3: Determine the target profile\n\nParse the arguments passed to this command. The user invoked `/dcp-profile <arguments>` where `<arguments>` is the first positional argument.\n\n- If the argument is a known profile name (one of: economy, balanced, performance, ultimate), use it directly.\n- If the argument is empty or missing, read `dcp.default_profile` from the user's config; if absent, default to `balanced`.\n- If the argument is not a recognized profile name, list the available profiles and stop. Do NOT guess or pass invalid names to the script.\n\n## Step 4: Execute the switch script\n\nRun the script via the bash tool. Capture both stdout and stderr. If the script exits with a non-zero status, show the captured stderr output to the user verbatim and stop. Do not swallow errors.\n\n```bash\n\"<resolved-switch-script>\" \"<profile-name>\"\n```\n\n## Step 5: Confirm and instruct\n\nAfter a successful switch:\n\n1. Report the script's stdout to the user.\n2. Tell the user that the new DCP configuration will take effect after they restart their OpenCode session (the active session has already loaded the previous config into memory).\n3. Do not attempt to reload DCP in-place; a session restart is required.\n\n## Important constraints\n\n- This command is a thin wrapper. All real logic lives in the user's switch script. Never bypass the script by writing to `dcp.jsonc` directly.\n- Do not install, upgrade, or modify the DCP plugin from this command. If the user needs to install or upgrade DCP, instruct them to run `opencode plugin @tarquinen/opencode-dcp@<version>` (or use `npm install --prefix ~/.config/opencode` for cached installs).\n- Do not edit any DCP config files (`dcp-base.jsonc`, `dcp-<profile>.jsonc`, `dcp-generated-*.jsonc`) as part of switching.";

package/dist/features/builtin-commands/types.d.ts

@@ -1,3 +1,3 @@
-import type { CommandDefinition } from "../claude-code-command-loader";
-export type BuiltinCommandName = "init-deep" | "matrix-loop" | "cancel-loop" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "pickup" | "remove-deadcode" | "profile" | "end-ultrawork" | "research" | "assembly" | "ultrawork";
+import type { CommandDefinition } from "../command-loader";
+export type BuiltinCommandName = "init-deep" | "matrix-loop" | "cancel-loop" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "pickup" | "remove-deadcode" | "profile" | "end-ultrawork" | "research" | "assembly" | "ultrawork" | "bdd-backend" | "bdd-contract" | "bdd-frontend" | "bdd-pipeline" | "bdd-tests" | "dcp-profile";
 export type BuiltinCommands = Record<string, CommandDefinition>;

package/dist/features/builtin-skills/lazy-skill-helper.d.ts

@@ -0,0 +1,17 @@
+import type { BuiltinSkill } from "./types";
+/**
+ * Wraps a skill factory into a BuiltinSkill with a lazy `template` getter.
+ *
+ * The factory is NOT called at construction time — only when `.template` is
+ * first accessed. Subsequent accesses return a cached value (self-destructing
+ * getter pattern replaces itself with a data property after first access).
+ * `description` is hydrated on every template access so the cache being
+ * populated by an earlier test does not leave subsequent instances empty.
+ *
+ * @param name - Skill name (used as cache key)
+ * @param skillFactory - Factory returning a full BuiltinSkill
+ * @returns BuiltinSkill with deferred template resolution
+ */
+export declare function createLazyTemplateSkill(name: string, skillFactory: () => BuiltinSkill): BuiltinSkill;
+/** Clears the internal skill cache (for testing). */
+export declare function clearLazyTemplateCache(): void;

package/dist/features/builtin-skills/skills/bdd-backend.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinSkill } from "../types";
+export declare const BDD_BACKEND_SKILL_NAME = "bdd-backend";
+export declare const bddBackendSkill: BuiltinSkill;

package/dist/features/builtin-skills/skills/bdd-contract.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinSkill } from "../types";
+export declare const BDD_CONTRACT_SKILL_NAME = "bdd-contract";
+export declare const bddContractSkill: BuiltinSkill;

package/dist/features/builtin-skills/skills/bdd-frontend.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinSkill } from "../types";
+export declare const BDD_FRONTEND_SKILL_NAME = "bdd-frontend";
+export declare const bddFrontendSkill: BuiltinSkill;

package/dist/features/builtin-skills/skills/bdd-tests.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinSkill } from "../types";
+export declare const BDD_TESTS_SKILL_NAME = "bdd-tests";
+export declare const bddTestsSkill: BuiltinSkill;

package/dist/features/builtin-skills/skills/docker-master.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinSkill } from "../types";
+export declare const dockerMasterSkill: BuiltinSkill;

package/dist/features/builtin-skills/skills/index.d.ts

@@ -1,4 +1,9 @@
+export { bddBackendSkill } from "./bdd-backend";
+export { bddContractSkill } from "./bdd-contract";
+export { bddFrontendSkill } from "./bdd-frontend";
+export { bddTestsSkill } from "./bdd-tests";
 export { devBrowserSkill } from "./dev-browser";
+export { dockerMasterSkill } from "./docker-master";
 export { documentReaderSkill } from "./document-reader";
 export { dslCodegenSkill } from "./dsl-codegen";
 export { dslCompositionSkill } from "./dsl-composition";

package/dist/features/{claude-code-command-loader → command-loader}/loader.d.ts

@@ -1,5 +1,3 @@
 import type { CommandDefinition } from "./types";
-export declare function loadUserCommands(): Promise<Record<string, CommandDefinition>>;
-export declare function loadProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>>;
 export declare function loadOpencodeGlobalCommands(): Promise<Record<string, CommandDefinition>>;
 export declare function loadOpencodeProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>>;

package/dist/features/mission-state/constants.d.ts

@@ -5,3 +5,13 @@ export declare const MISSION_DIR = ".matrixx";
 export declare const MISSION_FILE = "mission.json";
 /** Oracle planner plan directory pattern */
 export declare const ORACLE_PLANS_DIR = ".matrixx/plans";
+/**
+ * Plan Persistence Constants
+ */
+/** Relative path from project root to plans directory */
+export declare const PLANS_DIR = ".matrixx/plans";
+/** HTML comment marker for machine metadata at the end of a plan file */
+export declare const META_TAG_PREFIX = "<!-- plan-persister:";
+export declare const META_TAG_SUFFIX = "-->";
+/** Safety cap: max bytes for a single plan file read */
+export declare const MAX_PLAN_FILE_BYTES = 102400;

package/dist/features/mission-state/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./constants";
+export * from "./plan-storage";
+export * from "./rehydrate";
 export * from "./storage";
 export * from "./types";

package/dist/features/mission-state/plan-storage.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Plan Persistence Storage
+ *
+ * Atomic file operations for plan files.
+ * Reuses the write-temp-then-rename pattern from handoff/storage.ts.
+ */
+import type { PlanMeta } from "./types";
+/**
+ * Ensure the .matrixx/plans directory exists under the project root.
+ */
+export declare function ensurePlanDir(directory: string): boolean;
+/**
+ * Read a plan file's content.
+ * Returns null if the file does not exist, is too large, or cannot be read.
+ */
+export declare function readPlanFile(planPath: string): string | null;
+/**
+ * Atomic write: write to a .tmp.{pid} file, then rename over the target.
+ * Prevents partial/corrupt files on crash mid-write.
+ */
+export declare function atomicWrite(filePath: string, content: string): boolean;
+/**
+ * Write content to a plan file using atomic write.
+ * Ensures the plan directory exists first.
+ */
+export declare function writePlanFile(directory: string, planPath: string, content: string): boolean;
+/**
+ * Sync markdown checkbox status to match todos.
+ *
+ * For each `- [ ]` or `- [x]` line, finds the matching todo by content
+ * and marks it completed if the todo status is completed/cancelled.
+ * Lines without a matching todo keep their current state.
+ */
+export declare function syncCheckboxes(content: string, todos: Array<{
+    content: string;
+    status: string;
+}>): string;
+/**
+ * Append or replace the <!-- plan-persister: ... --> metadata comment.
+ *
+ * If a comment already exists at the end of the file, it is replaced in-place.
+ * Otherwise, the tag is appended after the last line.
+ */
+export declare function upsertMetadataComment(content: string, meta: PlanMeta): string;
+/**
+ * Extract PlanMeta from an HTML comment, or null if absent/malformed.
+ */
+export declare function parseMetadataComment(content: string): PlanMeta | null;

package/dist/features/mission-state/rehydrate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Plan Persistence Rehydration
+ *
+ * Builds rehydration context from mission state + plan file for injection
+ * after compaction or session start.
+ */
+import type { RehydrationContext } from "./types";
+/**
+ * Build a rehydration context from mission state + plan file.
+ *
+ * Returns null when:
+ * - No mission file exists
+ * - Mission has no active_plan
+ * - Plan file is missing
+ * - Plan is 100% complete (no point rehydrating a finished plan)
+ */
+export declare function buildRehydrationContext(directory: string): RehydrationContext | null;
+/**
+ * Find active plan path from mission state.
+ */
+export declare function findActivePlan(directory: string): string | null;