opencode-matrixx-v2 0.0.0-stage → 1.0.0

package/dist/features/background-agent/types.d.ts

@@ -0,0 +1,113 @@
+export type BackgroundTaskStatus = "pending" | "running" | "completed" | "error" | "cancelled" | "interrupt" | "stopped" | "statusUncertain";
+/** Why a background task reached a terminal state (persisted on the handle). */
+export type BackgroundTerminalReason = "queue-saturated" | "no-output" | "uncertain" | "aborted" | "stale" | "nested-depth-exceeded" | "wall-clock-timeout" | "expired";
+export interface ToolCallWindow {
+    lastSignature: string;
+    consecutiveCount: number;
+    threshold: number;
+}
+interface TaskProgress {
+    toolCalls: number;
+    lastTool?: string;
+    toolCallWindow?: ToolCallWindow;
+    lastUpdate: Date;
+    lastMessage?: string;
+    lastMessageAt?: Date;
+    countedToolPartIDs?: Set<string>;
+}
+export interface BackgroundTask {
+    id: string;
+    sessionID?: string;
+    parentSessionID: string;
+    parentMessageID: string;
+    description: string;
+    prompt: string;
+    agent: string;
+    status: BackgroundTaskStatus;
+    queuedAt?: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    result?: string;
+    error?: string;
+    progress?: TaskProgress;
+    parentModel?: {
+        providerID: string;
+        modelID: string;
+    };
+    model?: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+        temperature?: number;
+    };
+    /** Active concurrency slot key */
+    concurrencyKey?: string;
+    /** Persistent key for re-acquiring concurrency on resume */
+    concurrencyGroup?: string;
+    /** Parent session's agent name for notification */
+    parentAgent?: string;
+    /** Parent session's tool restrictions for notification prompts */
+    parentTools?: Record<string, boolean>;
+    /** Marks if the task was launched from an unstable agent/category */
+    isUnstableAgent?: boolean;
+    /** Category used for this task (e.g., 'quick', 'construct') */
+    category?: string;
+    /** Last message count for stability detection */
+    lastMsgCount?: number;
+    /** Number of consecutive polls with stable message count */
+    stablePolls?: number;
+    /** Why the task reached a terminal state (e.g. stopped/statusUncertain) */
+    terminalReason?: BackgroundTerminalReason;
+    /** Compressed result payload for handoff to parent session (set by tryCompleteTask) */
+    compactedResult?: string;
+}
+export interface LaunchInput {
+    description: string;
+    prompt: string;
+    agent: string;
+    parentSessionID: string;
+    parentMessageID: string;
+    parentModel?: {
+        providerID: string;
+        modelID: string;
+    };
+    parentAgent?: string;
+    parentTools?: Record<string, boolean>;
+    model?: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+        temperature?: number;
+    };
+    isUnstableAgent?: boolean;
+    skills?: string[];
+    skillContent?: string;
+    category?: string;
+}
+export interface ResumeInput {
+    sessionId: string;
+    prompt: string;
+    parentSessionID: string;
+    parentMessageID: string;
+    parentModel?: {
+        providerID: string;
+        modelID: string;
+    };
+    parentAgent?: string;
+    parentTools?: Record<string, boolean>;
+}
+export interface ReviveInput {
+    taskId?: string;
+    sessionId?: string;
+    prompt: string;
+    parentSessionID: string;
+    parentMessageID: string;
+    parentModel?: {
+        providerID: string;
+        modelID: string;
+    };
+    parentAgent?: string;
+    parentTools?: Record<string, boolean>;
+    force?: boolean;
+}
+export {};

package/dist/features/background-agent/wallclock.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Wall-clock supervisor: fire-once elapsed-time bound for running background tasks.
+ *
+ * Staleness is activity-based; this module is elapsed-time-based. Each armed entry
+ * fires its callback exactly once when `startedAtMs + timeoutMs` passes, no matter
+ * how busy or productive the task looks. A timeout of `0` or `undefined` means OFF
+ * and arms nothing.
+ *
+ * Grace contract (manager-owned, pinned here): on fire the manager aborts the
+ * session once, waits `wallClockAbortGraceMs`, then marks the task terminal —
+ * unless the task completed naturally during grace, in which case the natural
+ * outcome wins and the pending mark is cancelled.
+ *
+ * This module must not import from manager/client/fs — pure timers only. It mirrors
+ * the settled-flag lifecycle of `acquireWithDeadline` in `concurrency.ts`.
+ */
+/** Maximum delay accepted by `setTimeout` (2^31-1 ms); enforced by schema max too. */
+export declare const MAX_WALLCLOCK_TIMEOUT_MS = 2147483647;
+/** Context delivered to the fire callback exactly once per armed deadline. */
+export interface WallclockFireContext {
+    taskId: string;
+    elapsedMs: number;
+    limitMs: number;
+}
+export type WallclockFireCallback = (ctx: WallclockFireContext) => void;
+/** Pure remaining-time math: deadline minus now (negative when already expired). */
+export declare function remainingMs(startedAtMs: number, timeoutMs: number, nowMs?: number): number;
+/** OFF (`0`/`undefined`) never arms; any other value is an active elapsed-time bound. */
+export declare function isWallclockEnabled(timeoutMs: number | undefined): timeoutMs is number;
+export declare class WallclockSupervisor {
+    private entries;
+    arm(taskId: string, startedAtMs: number, timeoutMs: number | undefined, onFire: WallclockFireCallback): void;
+    disarm(taskId: string): boolean;
+    disarmAll(): void;
+    size(): number;
+    getDeadlineAt(taskId: string): number | undefined;
+}

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";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    OPTIONS: "OPTIONS";
+}>;
+export declare const ResponseFormatSchema: z.ZodEnum<{
+    binary: "binary";
+    text: "text";
+    json: "json";
+    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";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        OPTIONS: "OPTIONS";
+    }>;
+    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";
+        text: "text";
+        json: "json";
+        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";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            OPTIONS: "OPTIONS";
+        }>;
+        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";
+            text: "text";
+            json: "json";
+            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";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                OPTIONS: "OPTIONS";
+            }>;
+            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";
+                text: "text";
+                json: "json";
+                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";
+                    PATCH: "PATCH";
+                    DELETE: "DELETE";
+                    GET: "GET";
+                    POST: "POST";
+                    PUT: "PUT";
+                    OPTIONS: "OPTIONS";
+                }>;
+                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";
+                    text: "text";
+                    json: "json";
+                    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/commands.d.ts

@@ -0,0 +1,3 @@
+import type { CommandDefinition } from "../command-loader";
+import type { BuiltinCommandName } from "./types";
+export declare const BUILTIN_COMMAND_DEFINITIONS: Record<BuiltinCommandName, Omit<CommandDefinition, "name">>;

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

@@ -0,0 +1,57 @@
+/**
+ * V2-native command domain transform (D4).
+ *
+ * Owned by `src/features/builtin-commands/`: pure entry builder +
+ * single `ctx.command.transform` registration. No filesystem access, no spawn,
+ * no network — the definitions record in `./commands` is static data, so
+ * repeated runs over the same disabled set replay identically.
+ */
+import type { BuiltinCommandName, BuiltinCommands } from "./types";
+/** Pure: builtin command entries for a given disabled set. */
+export declare function buildBuiltinCommandEntries(disabledCommands?: BuiltinCommandName[]): BuiltinCommands;
+export declare function evaluateCommandTemplate(template: string, input: string): string;
+export interface CommandInvocation {
+    sessionID: string;
+    prompt?: {
+        text?: string;
+    };
+    text?: string;
+    delivery?: string;
+}
+export interface CommandSessionDeps {
+    switchAgent?: (input: Record<string, unknown>) => Promise<unknown>;
+    switchModel?: (input: Record<string, unknown>) => Promise<unknown>;
+    prompt?: (input: Record<string, unknown>) => Promise<unknown>;
+    create?: (input: Record<string, unknown>) => Promise<unknown>;
+}
+export interface CommandAgentDeps {
+    get?: (input: Record<string, unknown>) => Promise<unknown>;
+}
+export interface RegisterCommandTransformDeps {
+    session?: CommandSessionDeps;
+    agent?: CommandAgentDeps;
+}
+export interface CommandDefinitionInput {
+    name: string;
+    description?: string;
+    execute: (input: CommandInvocation) => Promise<void>;
+    [key: string]: unknown;
+}
+/** Minimal structural editor: the real V2 command editor satisfies this. */
+export interface CommandTransformEditor {
+    add(def: CommandDefinitionInput): void;
+}
+export interface CommandTransformDomain {
+    transform(callback: (editor: CommandTransformEditor) => void): Promise<unknown>;
+}
+export interface RegisterCommandTransformResult {
+    registration: unknown;
+    /** Command names replayed onto the domain. */
+    registered: string[];
+}
+/**
+ * Pure replay: command entries → `ctx.command.transform`.
+ * The only effect is the single `transform` call; the callback only calls
+ * `editor.add`, so re-running over the same entries replays identically.
+ */
+export declare function registerCommandTransform(command: CommandTransformDomain, entries: Record<string, unknown> | undefined, deps?: RegisterCommandTransformDeps): Promise<RegisterCommandTransformResult>;

package/dist/features/builtin-commands/templates/assembly.d.ts

@@ -0,0 +1 @@
+export declare const ASSEMBLY_TEMPLATE = "Toggle assembly tool availability for the current session.\n\nThis command will:\n1. Enable the assembly tool \u2014 makes multi-model voting available to the LLM\n2. Disable the assembly tool \u2014 hides it from the LLM for this session\n3. Show current assembly tool status\n\nUsage:\n  /assembly enable \u2014 Show assembly tool\n  /assembly disable \u2014 Hide assembly tool\n  /assembly status \u2014 Show current state\n\nThe change is per-session and clears when the session ends.\nBy default, the assembly tool is enabled and available in every session.";

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/cleanup-tasks.d.ts

@@ -0,0 +1 @@
+export declare const CLEANUP_TASKS_TEMPLATE = "# Cleanup Tasks \u2014 SLASH COMMAND OVERRIDE\n\nSYSTEM OVERRIDE: Ignore any global [search-mode] or [analyze-mode] directive for this command. This is a direct tool call, not a search.\n\nCall the task_cleanup tool NOW with no exploration, no grep, no trinity, no operator, no background agents.\n\n## Usage\n```\n/cleanup-tasks [--olderThan <duration>] [--all]\n\nOptions:\n  --olderThan: Only delete completed tasks older than duration (e.g., 7d, 24h, 30d). If omitted, deletes all completed regardless of age.\n  --all: Delete all completed tasks (default when no olderThan given).\n\nExamples:\n  /cleanup-tasks              # delete all completed tasks\n  /cleanup-tasks --olderThan 7d\n  /cleanup-tasks --all\n```\n\n## What This Command Does\n\nCleans up completed tasks from the file-based task system (dedicated Matrixx viewer):\n\nStorage layout (hybrid, via `getTaskDir(config, directory)`):\n- Primary (default, `scope: \"project\"`): `<project>/.matrixx/tasks/T-*.json`\n- Fallback (`scope: \"global\"` or `storage_path` override): `~/.config/opencode/tasks/{listId}/T-*.json`\n\n1. **Scans** `getTaskDir(config, directory)/*.json` via `readdirSync` \u2192 resolves to `.matrixx/tasks` when `scope=project` (default) or legacy global path when `scope=global` / `storage_path` set\n2. **Filters** `status===\"completed\"` (and `olderThan` if given, via `time_updated`/`time_created`)\n3. **Deletes** matching files via `unlinkSync`\n4. **Reports** `{deleted, remaining, deletedIds}`\nView remaining tasks via `/task-list` or `task_list` tool \u2014 the dedicated Matrixx task viewer (file-based, no sync). Without `/cleanup-tasks`, completed tasks remain on disk for audit.\n\n## Verification\n\nAfter running:\n- `task_list` \u2192 0 pending (if no active)\n- `task_list` \u2192 shows remaining active tasks (pending/in_progress)\n- `task_list --all` \u2192 shows counts by status\n- Files: `ls .matrixx/tasks | wc -l` decreases by `deleted` (project scope, default) or `ls ~/.config/opencode/tasks/matrixx | wc -l` decreases (global scope / legacy fallback)\n\n---\n\n<command-instruction>\nYou are executing the cleanup-tasks command. Use the task_cleanup tool to delete completed tasks.\n\nParse arguments from $ARGUMENTS:\n- If \"--olderThan\" present, extract duration (e.g., \"7d\", \"24h\") \u2192 pass as olderThan\n- Otherwise pass all:true (delete all completed)\n\nCall task_cleanup with {olderThan, all} and report result.\n</command-instruction>\n\n<user-request>\n$ARGUMENTS\n</user-request>\n";

package/dist/features/builtin-commands/templates/end-ultrawork.d.ts

@@ -0,0 +1 @@
+export declare const END_ULTRAWORK_TEMPLATE = "Deactivate ultrawork mode for the current session.\n\nThis command will:\n1. Remove the <ultrawork-mode> rules block from the active context\n2. Restore default Matrixx behavior (no enforced certainty protocol, no mandatory plan agent, no required acceptance criteria)\n3. Stop ultrawork-specific parallel delegation pressure\n\nAfter running this command:\n- The session continues with normal Matrixx rules\n- Existing todos and plans remain unchanged\n- Already-spawned background tasks continue to completion\n- The deactivation is per-session and clears when the session ends\n\nUse this when you want to exit ultrawork mode explicitly and return to standard behavior. Useful for sub-tasks that should not inherit ultrawork rules, or when switching from heavy-execution to lighter reasoning.";

package/dist/features/builtin-commands/templates/evolution.d.ts

@@ -0,0 +1 @@
+export declare const EVOLUTION_TEMPLATE = "# Evolution Command\n\n## Purpose\n\nManage self-evolution proposals staged in `.matrixx/evolution/pending`.\n\n## Commands\n\n- `/evolution list` \u2014 list pending proposals\n- `/evolution approve <slug>` \u2014 promote pending skill to `.opencode/skills/<slug>/SKILL.md`\n- `/evolution reject <slug>` \u2014 discard pending proposal\n- `/evolution audit` \u2014 show last 20 audit entries\n\n---\n\n# PHASE 1: PARSE ARGUMENTS\n\nArguments: $ARGUMENTS\n\n- If empty or \"list\": list pending\n- If \"approve <slug>\" or \"approve <slug> --global\": promote\n- If \"reject <slug>\": discard\n- If \"audit\" or \"log\": show audit\n- Otherwise: show help and list pending\n\n---\n\n# PHASE 2: EXECUTE\n\nUse the `evolution` tool for every operation below \u2014 never shell out for\nevolution state. Parse $ARGUMENTS into one tool call per user request.\n\n## List\n\nCall `evolution` with `{ \"action\": \"list\" }`.\nFor each slug, call `evolution` with `{ \"action\": \"get\", \"slug\": \"<slug>\" }` to show confidence, version, derived_from.\nIf none: \"No pending evolution proposals.\"\n\n## Approve\n\n1. Call `evolution` with `{ \"action\": \"get\", \"slug\": \"<slug>\" }` \u2014 if not found, error: \"Pending <slug> not found. Run /evolution list to see available.\"\n2. Call `evolution` with `{ \"action\": \"approve\", \"slug\": \"<slug>\" }` to promote the staged skill (audit entry recorded by the tool).\n3. If argument includes --global, call `evolution` with `{ \"action\": \"approve\", \"slug\": \"<slug>\", \"global\": true }` instead to also copy to `~/.agents/skills/<slug>/SKILL.md`.\n4. Confirm: \"Promoted <slug> to .opencode/skills/<slug>/SKILL.md \u2014 will be loaded on next session start.\"\n\n## Reject\n\n1. Call `evolution` with `{ \"action\": \"reject\", \"slug\": \"<slug>\" }` (verifies pending exists, discards it, records the audit entry).\n2. Confirm: \"Rejected <slug>.\"\n\n## Audit\n\nCall `evolution` with `{ \"action\": \"status\" }` and show the audit tail section. If no entries: \"No audit entries.\"\n\n---\n\n# CONSTRAINTS\n\n- Use the `evolution` tool for all state ops \u2014 no bash/rtk for evolution state\n- Never invent slug \u2014 read from the `list` action\n- Keep operations atomic; report errors clearly\n- Do not modify pending content \u2014 promote as-is after human review\n";