opencode-matrixx-v2 1.2.1 → 1.2.2

package/dist/config/schema/matrixx-config.d.ts

@@ -18,15 +18,15 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
     default_run_agent: z.ZodOptional<z.ZodString>;
     disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disabled_agents: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        trinity: "trinity";
-        operator: "operator";
-        merovingian: "merovingian";
-        seraph: "seraph";
-        smith: "smith";
-        construct: "construct";
         morpheus: "morpheus";
         keymaker: "keymaker";
         oracle: "oracle";
+        merovingian: "merovingian";
+        operator: "operator";
+        trinity: "trinity";
+        construct: "construct";
+        seraph: "seraph";
+        smith: "smith";
         niobe: "niobe";
         cipher: "cipher";
         sentinel: "sentinel";
@@ -35,10 +35,11 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
     disabled_skills: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         playwright: "playwright";
         "agent-browser": "agent-browser";
-        "dev-browser": "dev-browser";
+        "playwright-cli": "playwright-cli";
         "frontend-ui-ux": "frontend-ui-ux";
-        "git-master": "git-master";
         "docker-master": "docker-master";
+        "git-master": "git-master";
+        "dev-browser": "dev-browser";
         "dsl-core": "dsl-core";
         "dsl-grammar": "dsl-grammar";
         "dsl-codegen": "dsl-codegen";
@@ -50,12 +51,25 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "dsl-testing": "dsl-testing";
         "dsl-validation": "dsl-validation";
         "dsl-composition": "dsl-composition";
+        "frontend-a11y": "frontend-a11y";
+        "bdd-backend": "bdd-backend";
+        "bdd-contract": "bdd-contract";
+        "bdd-frontend": "bdd-frontend";
+        "bdd-tests": "bdd-tests";
+        "frontend-build-tooling": "frontend-build-tooling";
+        "frontend-perf": "frontend-perf";
+        "frontend-state-data": "frontend-state-data";
+        "frontend-testing": "frontend-testing";
+        "react-nextjs-patterns": "react-nextjs-patterns";
+        "svelte-sveltekit-patterns": "svelte-sveltekit-patterns";
+        "document-reader": "document-reader";
         "security-core": "security-core";
         "security-secrets": "security-secrets";
         "security-sast": "security-sast";
         "security-dast": "security-dast";
         "security-dependencies": "security-dependencies";
         "security-api": "security-api";
+        "security-audit": "security-audit";
         "security-crypto": "security-crypto";
         "security-infra": "security-infra";
         "security-review": "security-review";
@@ -66,10 +80,13 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "matrixx-self-config": "matrixx-self-config";
         "ulw-research": "ulw-research";
         "remove-ai-slops": "remove-ai-slops";
-        "bdd-backend": "bdd-backend";
-        "bdd-contract": "bdd-contract";
-        "bdd-frontend": "bdd-frontend";
-        "bdd-tests": "bdd-tests";
+        "zeromq-core": "zeromq-core";
+        "zeromq-sockets-patterns": "zeromq-sockets-patterns";
+        "zeromq-advanced-reqrep": "zeromq-advanced-reqrep";
+        "zeromq-reliability": "zeromq-reliability";
+        "zeromq-pubsub": "zeromq-pubsub";
+        "zeromq-architecture": "zeromq-architecture";
+        "zeromq-frameworks": "zeromq-frameworks";
         "python-asyncio": "python-asyncio";
         "ccxt-rest": "ccxt-rest";
         "ccxt-pro-websockets": "ccxt-pro-websockets";
@@ -82,8 +99,9 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "grafana-dashboards": "grafana-dashboards";
         "telegram-bot": "telegram-bot";
         "resilience-error-taxonomy": "resilience-error-taxonomy";
-        "silent-failure-detection": "silent-failure-detection";
         "resilience-failure-hunting": "resilience-failure-hunting";
+        "silent-failure-detection": "silent-failure-detection";
+        "systematic-debugging": "systematic-debugging";
         "data-quality-observability": "data-quality-observability";
     }>>>;
     disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
@@ -92,7 +110,6 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "matrix-loop": "matrix-loop";
         "start-work": "start-work";
         "evolution-watcher": "evolution-watcher";
-        "task-continuation-enforcer": "task-continuation-enforcer";
         "context-window-monitor": "context-window-monitor";
         "session-recovery": "session-recovery";
         "session-notification": "session-notification";
@@ -153,7 +170,7 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "task-notepad-writer": "task-notepad-writer";
         "session-memory": "session-memory";
         "subagent-block": "subagent-block";
-    }>, z.ZodPipe<z.ZodLiteral<"anthropic-context-window-limit-recovery">, z.ZodTransform<"context-window-limit-recovery", "anthropic-context-window-limit-recovery">>, z.ZodLiteral<"todo-continuation-enforcer">, z.ZodLiteral<"compaction-todo-preserver">, z.ZodLiteral<"tasks-todowrite-disabler">, z.ZodLiteral<"task-notepad">, z.ZodLiteral<"preemptive-compaction">, z.ZodLiteral<"evolution-compressor">]>>>;
+    }>, z.ZodPipe<z.ZodLiteral<"anthropic-context-window-limit-recovery">, z.ZodTransform<"context-window-limit-recovery", "anthropic-context-window-limit-recovery">>, z.ZodLiteral<"todo-continuation-enforcer">, z.ZodLiteral<"compaction-todo-preserver">, z.ZodLiteral<"tasks-todowrite-disabler">, z.ZodLiteral<"task-notepad">, z.ZodLiteral<"task-continuation-enforcer">, z.ZodLiteral<"preemptive-compaction">, z.ZodLiteral<"evolution-compressor">]>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "init-deep": "init-deep";
         "matrix-loop": "matrix-loop";
@@ -1033,8 +1050,8 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         provider: z.ZodDefault<z.ZodEnum<{
             playwright: "playwright";
             "agent-browser": "agent-browser";
-            "dev-browser": "dev-browser";
             "playwright-cli": "playwright-cli";
+            "dev-browser": "dev-browser";
         }>>;
     }, z.core.$strip>>;
     tmux: z.ZodOptional<z.ZodObject<{
@@ -1142,12 +1159,12 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         enforce: z.ZodDefault<z.ZodBoolean>;
         blocked_tools: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            read: "read";
             grep: "grep";
             glob: "glob";
             webfetch: "webfetch";
             bash: "bash";
             shell: "shell";
+            read: "read";
         }>>>;
     }, z.core.$strip>>;
     memory: z.ZodOptional<z.ZodObject<{

package/dist/features/background-agent/handle-index.d.ts

@@ -22,11 +22,11 @@ export declare const BgHandleSchema: z.ZodObject<{
     agent: z.ZodString;
     status: z.ZodEnum<{
         error: "error";
-        cancelled: "cancelled";
-        interrupt: "interrupt";
+        completed: "completed";
         pending: "pending";
         running: "running";
-        completed: "completed";
+        cancelled: "cancelled";
+        interrupt: "interrupt";
         stopped: "stopped";
         statusUncertain: "statusUncertain";
     }>;

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

@@ -1,3 +1,9 @@
+/** Background-execution cross-link (separate layers, not moved in Phase 4):
+ * - `features/background-agent/` owns agent handle files and lifecycle management.
+ * - `hooks/background-notification/` observes session events and emits notifications.
+ * - `hooks/background-task-blocker/` guards tool execution while background tasks run.
+ * - `tools/background-task/` exposes agent-callable task controls (cancel/output/revive).
+ */
 export { BG_HANDLE_FILE_PREFIX, type BgHandle, BgHandleSchema, deleteHandleFile, getBgHandleDir, getHandlePath, readHandles, sweepStaleHandles, toHandle, writeHandle, } from "./handle-index";
 export { BackgroundManager, type OnSubagentSessionCreated, type SubagentSessionCreatedEvent } from "./manager";
 export { TaskStateManager } from "./state";

package/dist/features/background-agent/manager/index.d.ts

@@ -0,0 +1,5 @@
+export type { EventProperties, OnSubagentSessionCreated, SubagentSessionCreatedEvent, } from "./manager";
+export { BackgroundManager } from "./manager";
+export { _resetPruneThrottleForTesting, listKnownSessions, resolveAny, } from "./reconcile";
+export { ManagerStore } from "./store";
+export type { ManagerRuntime, NativeDescendant, ResolveAnyResult } from "./types";

package/dist/features/background-agent/manager/lifecycle.d.ts

@@ -0,0 +1,29 @@
+import type { NativeDomains } from "../../../shared/session/session-context-source";
+import type { BackgroundTask, LaunchInput, ResumeInput } from "../types";
+import type { ManagerRuntime } from "./types";
+/**
+ * Task lifecycle: restore, launch, track, resume, prompt.
+ *
+ * Each function takes the shared `ManagerRuntime` explicitly instead of a
+ * `BackgroundManager` receiver — same statements, no `this`. Thin
+ * delegating methods on `BackgroundManager` preserve the public API.
+ */
+export declare function restoreHandles(rt: ManagerRuntime): Promise<void>;
+export declare function launchTask(rt: ManagerRuntime, input: LaunchInput & {
+    sessionId?: string;
+    sessionID?: string;
+    messageId?: string;
+    messageID?: string;
+}): Promise<BackgroundTask>;
+export declare function trackTask(rt: ManagerRuntime, input: {
+    taskId: string;
+    sessionID: string;
+    parentSessionID: string;
+    description: string;
+    agent?: string;
+    parentAgent?: string;
+    concurrencyKey?: string;
+}): Promise<BackgroundTask>;
+export declare function resumeTask(rt: ManagerRuntime, input: ResumeInput): Promise<BackgroundTask>;
+export declare function abortSessionQuietly(native: NativeDomains, sessionID: string, context?: string): void;
+export declare function firePrompt(native: NativeDomains, task: BackgroundTask, prompt: string, skillContent?: string): Promise<void>;

package/dist/features/background-agent/{manager.d.ts → manager/manager.d.ts}

@@ -1,3 +1,13 @@
+import type { BackgroundTaskConfig, MatrixxConfig } from "../../../config/schema";
+import type { V2Event } from "../../../plugin/tool/context";
+import type { NativeDomains, NativePluginContext } from "../../../shared/session/session-context-source";
+import type { EventProperties, OnSubagentSessionCreated, SubagentSessionCreatedEvent } from "../constants";
+import { TaskHistory } from "../task-history";
+import type { BackgroundTask, LaunchInput, ResumeInput, ReviveInput } from "../types";
+import { listRevivable } from "./reconcile";
+import { ManagerStore } from "./store";
+import type { ManagerRuntime } from "./types";
+export type { EventProperties, OnSubagentSessionCreated, SubagentSessionCreatedEvent, };
 /**
  * Native v2 background-task shim (D5).
  *
@@ -20,35 +30,17 @@
  * (pure eligibility logic), `task-history.ts` (compaction context),
  * `types.ts` / `constants.ts` (shapes). The interactive-bash tool and the
  * doctor `tmux-integration` check keep their own tmux binary usage.
- */
-import type { BackgroundTaskConfig, MatrixxConfig } from "../../config/schema";
-import type { V2Event } from "../../plugin/context";
-import type { NativePluginContext } from "../../shared/session-context-source";
-import type { EventProperties, OnSubagentSessionCreated, SubagentSessionCreatedEvent } from "./constants";
-import { TaskHistory } from "./task-history";
-import type { BackgroundTask, LaunchInput, ResumeInput, ReviveInput } from "./types";
-export type { EventProperties, OnSubagentSessionCreated, SubagentSessionCreatedEvent, };
-/**
- * Ephemeral native session descriptor (T1 unified-bg-native-tracking).
  *
- * Read-only view over the session-state registry — NOT a persisted bg_
- * handle. Uses the lightweight `subagentSessions`/`subagentParentMap`
- * registry (getSubagentSessionIDs + getParentSessionID) rather than the
- * heavier storage.ts SDK read path (getMainSessions/getAllSessions),
- * which requires directory-scoped sqlite/JSON access.
+ * The class below is the composing control surface: it owns the
+ * `ManagerStore` and delegates lifecycle work to `lifecycle.ts` and
+ * event-driven consistency to `reconcile.ts`. Method bodies there are the
+ * original statements with the receiver spelled `rt` instead of `this`.
  */
-export interface NativeDescendant {
-    sessionId: string;
-    parentSessionId: string;
-    isChild: boolean;
-}
-export declare class BackgroundManager {
-    private tasks;
-    private knownSessions;
-    private nativeDescCache;
-    private native;
-    private directory;
-    private config?;
+export declare class BackgroundManager implements ManagerRuntime {
+    readonly store: ManagerStore;
+    readonly native: NativeDomains;
+    readonly directory: string;
+    readonly config?: BackgroundTaskConfig;
     readonly taskHistory: TaskHistory;
     constructor(ctx: NativePluginContext, config?: BackgroundTaskConfig, options?: {
         /** @deprecated Native session events own display; ignored. */
@@ -57,6 +49,12 @@ export declare class BackgroundManager {
         /** Full plugin config — supplies the `tasks.*` store location. */
         pluginConfig?: Partial<MatrixxConfig>;
     });
+    /**
+     * Legacy direct-state access: the live task registry.
+     * Tests and benches reach into `manager.tasks`; the getter keeps that
+     * working while the store owns the map.
+     */
+    get tasks(): Map<string, BackgroundTask>;
     /**
      * Reload persisted handles for restart visibility. Persisted
      * `running|pending` handles are NOT probed against the host (no reconcile
@@ -91,39 +89,18 @@ export declare class BackgroundManager {
     resume(input: ResumeInput): Promise<BackgroundTask>;
     /** Revive a terminal task with a new prompt via native `session.prompt`. */
     revive(input: ReviveInput): Promise<BackgroundTask>;
-    listRevivable(parentSessionID?: string): Array<{
-        taskId: string;
-        description: string;
-        agent: string;
-        status: string;
-        sessionID: string;
-        terminalReason?: string;
-    }>;
+    listRevivable(parentSessionID?: string): ReturnType<typeof listRevivable>;
     /**
      * Native event routing (wired by the background-notification hook).
      * Completion is detected from native session lifecycle events only —
      * no polling, no reconcile probes.
      */
-    /**
-     * Normalize a raw session ID: trim surrounding whitespace and strip
-     * query/hash suffixes so mismatched shapes still hit the same task.
-     */
-    private static normalizeSessionID;
     handleEvent(event: V2Event): void;
     getKnownSessionIds(): Set<string>;
     getTask(id: string): BackgroundTask | undefined;
     getTasksByParentSession(sessionID: string): BackgroundTask[];
     getAllDescendantTasks(sessionID: string): BackgroundTask[];
-    /**
-     * Read-only native descendants of a session (T1).
-     *
-     * Walks the ephemeral session-state registry: a native ses_ session
-     * counts as a descendant when its ancestor chain (via getParentSessionID)
-     * includes `sessionId`. Returns ephemeral descriptors only — no handle
-     * writes, no persistence. Cycle-guarded with a visited set (the older
-     * getAllDescendantTasks lacks one). Returns [] for unknown sessions.
-     */
-    getNativeDescendants(sessionId: string): NativeDescendant[];
+    getNativeDescendants(sessionId: string): ReturnType<ManagerStore["getNativeDescendants"]>;
     findBySession(sessionID: string): BackgroundTask | undefined;
     findDiskTaskBySession(sessionID: string): BackgroundTask | undefined;
     cancelTask(taskId: string, options?: {
@@ -149,51 +126,4 @@ export declare class BackgroundManager {
         }>;
     }>;
     shutdown(): void;
-    private taskTtlMs;
-    private persistHandle;
-    private abortSessionQuietly;
-    /** Fire-and-forget native prompt with the task's agent/model/tool scope. */
-    private firePrompt;
 }
-/**
- * Resolve any task/session id to a unified payload (unified output/wait_all).
- *
- * - bg_ prefix: registry map lookup (origin bg). Covers bg tasks only.
- * - ses_ prefix: findBySession first (covering bg task); else read-only live
- *   lookup via the native client session.messages/session.get (no registry
- *   write, no handle persist). Origin is ses when the session answers live,
- *   foreign when only visible via bounded session.list backfill sweep.
- * - task_id vs session_id ambiguity: a bg_ id that is also a session id is
- *   treated as a bg_ task first (registry wins); tools surface ambiguity.
- * - unknown: typed { error: not_found, id }.
- */
-export type ResolveAnyResult = {
-    origin: "bg";
-    task: import("./types").BackgroundTask;
-} | {
-    origin: "ses" | "foreign";
-    sessionId: string;
-    output: unknown;
-    messages?: unknown;
-} | {
-    error: "not_found";
-    id: string;
-};
-export declare function resolveAny(manager: BackgroundManager, id: string): Promise<ResolveAnyResult>;
-/**
- * Sessions covered by wait_all: pending/running bg_ tasks plus known live
- * ses_* ids (knownSessions + bounded list backfill). Wired into
- * waitForAllDescendants via uncoveredNatives; documented here so the
- * coverage contract lives next to the query.
- */
-export declare function listKnownSessions(manager: BackgroundManager): {
-    bgPending: string[];
-    liveSes: string[];
-};
-/**
- * Test-only reset hook (D5 native migration): the pre-migration in-memory
- * prune throttle was removed — stale-handle expiry is now the throttle-free TTL sweep in
- * `handle-index.ts` (`sweepStaleHandles`, invoked per operation). Kept as a
- * no-op so `tests/test-setup.ts` and older prune-throttle tests keep loading.
- */
-export declare function _resetPruneThrottleForTesting(): void;

package/dist/features/background-agent/manager/reconcile.d.ts

@@ -0,0 +1,20 @@
+import type { V2Event } from "../../../plugin/tool/context";
+import type { BackgroundTask, ReviveInput } from "../types";
+import type { BackgroundManager } from "./manager";
+import type { ManagerRuntime, ResolveAnyResult } from "./types";
+export declare function reviveTask(rt: ManagerRuntime, input: ReviveInput): Promise<BackgroundTask>;
+export declare function listRevivable(rt: ManagerRuntime, parentSessionID?: string): Array<{
+    taskId: string;
+    description: string;
+    agent: string;
+    status: string;
+    sessionID: string;
+    terminalReason?: string;
+}>;
+export declare function handleManagerEvent(rt: ManagerRuntime, event: V2Event): void;
+export declare function resolveAny(manager: BackgroundManager, id: string): Promise<ResolveAnyResult>;
+export declare function listKnownSessions(manager: BackgroundManager): {
+    bgPending: string[];
+    liveSes: string[];
+};
+export declare function _resetPruneThrottleForTesting(): void;

package/dist/features/background-agent/manager/store.d.ts

@@ -0,0 +1,33 @@
+import type { BackgroundTaskConfig } from "../../../config/schema";
+import type { BackgroundTask } from "../types";
+import type { NativeDescendant } from "./types";
+/**
+ * In-memory task registry behind `BackgroundManager`.
+ *
+ * Owns the task map, the known-session set, and the native-descendant
+ * cache plus every pure state query over them (getters, finders, handle
+ * persistence). Lifecycle (launch/track/resume) and reconcile
+ * (revive/events/resolve) live in their own modules and operate on this
+ * store through `ManagerRuntime` — they never touch `BackgroundManager`.
+ */
+export declare class ManagerStore {
+    readonly tasks: Map<string, BackgroundTask>;
+    readonly knownSessions: Set<string>;
+    readonly nativeDescCache: Map<string, {
+        at: number;
+        rows: NativeDescendant[];
+    }>;
+    directory: string;
+    config?: BackgroundTaskConfig;
+    constructor(directory: string, config?: BackgroundTaskConfig);
+    static normalizeSessionID(raw: string): string;
+    getKnownSessionIds(): Set<string>;
+    getTask(id: string): BackgroundTask | undefined;
+    getTasksByParentSession(sessionID: string): BackgroundTask[];
+    getAllDescendantTasks(sessionID: string): BackgroundTask[];
+    getNativeDescendants(sessionId: string): NativeDescendant[];
+    findBySession(sessionID: string): BackgroundTask | undefined;
+    findDiskTaskBySession(sessionID: string): BackgroundTask | undefined;
+    taskTtlMs(): number;
+    persistHandle(task: BackgroundTask): void;
+}

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

@@ -0,0 +1,42 @@
+import type { BackgroundTaskConfig } from "../../../config/schema";
+import type { NativeDomains } from "../../../shared/session/session-context-source";
+import type { TaskHistory } from "../task-history";
+import type { ManagerStore } from "./store";
+/**
+ * Shared runtime handed to the lifecycle/reconcile function modules.
+ * `BackgroundManager` satisfies this structurally; the function modules
+ * never reach back into the class itself (no import cycle at runtime).
+ */
+export interface ManagerRuntime {
+    readonly store: ManagerStore;
+    readonly native: NativeDomains;
+    readonly directory: string;
+    readonly config?: BackgroundTaskConfig;
+    readonly taskHistory: TaskHistory;
+}
+/**
+ * Ephemeral native session descriptor (T1 unified-bg-native-tracking).
+ *
+ * Read-only view over the session-state registry — NOT a persisted bg_
+ * handle. Uses the lightweight `subagentSessions`/`subagentParentMap`
+ * registry (getSubagentSessionIDs + getParentSessionID) rather than the
+ * heavier storage.ts SDK read path (getMainSessions/getAllSessions),
+ * which requires directory-scoped sqlite/JSON access.
+ */
+export interface NativeDescendant {
+    sessionId: string;
+    parentSessionId: string;
+    isChild: boolean;
+}
+export type ResolveAnyResult = {
+    origin: "bg";
+    task: import("../types").BackgroundTask;
+} | {
+    origin: "ses" | "foreign";
+    sessionId: string;
+    output: unknown;
+    messages?: unknown;
+} | {
+    error: "not_found";
+    id: string;
+};

package/dist/features/background-agent/message-dir.d.ts

@@ -1,4 +1,4 @@
-import { type StoredMessage } from "../hook-message-injector";
+import { type StoredMessage } from "../context-injection/hook-bridge";
 export declare function getMessageDir(sessionID: string): string | null;
 export declare function _resetMessageDirCacheForTesting(): void;
 export declare function isCompactionAgent(agent: string | undefined): boolean;

package/dist/features/background-agent/notification-builder.d.ts

@@ -1,4 +1,4 @@
-import type { SessionContextCarrier } from "../../shared/session-context-source";
+import type { SessionContextCarrier } from "../../shared/session/session-context-source";
 import type { BackgroundTask } from "./types";
 export declare function buildCompletionNotification(task: Pick<BackgroundTask, "id" | "description" | "error" | "status">, allComplete: boolean, completedTasks: Pick<BackgroundTask, "id" | "description">[], remainingCount: number, duration: string, errorInfo: string): string;
 export declare function resolveAgentAndModel(client: SessionContextCarrier, task: Pick<BackgroundTask, "parentSessionID" | "parentAgent">, enableParentSessionNotifications: boolean): Promise<{

package/dist/features/background-agent/session-output.d.ts

@@ -1,5 +1,5 @@
-import type { SessionContextCarrier } from "../../shared/session-context-source";
-import type { SessionMessage } from "../../shared/session-message";
+import type { SessionContextCarrier } from "../../shared/session/session-context-source";
+import type { SessionMessage } from "../../shared/session/session-message";
 export type SessionOutputClient = SessionContextCarrier;
 export type { SessionMessage };
 /**

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

@@ -0,0 +1,2 @@
+/** bdd barrel: explicit named re-exports of local modules only. */
+export { type ApiAnnotations, ApiAnnotationsSchema, type ApiEndpoint, ApiEndpointSchema, type ApiResponse, ApiResponseSchema, type Background, BackgroundSchema, CamelCaseSchema, type Contract, type ContractAnnotations, ContractAnnotationsSchema, ContractSchema, DottedKebabSchema, type ExampleRow, ExampleRowSchema, type Feature, FeatureSchema, type HttpMethod, HttpMethodSchema, KebabCaseSchema, type ResponseFormat, ResponseFormatSchema, type Rule, RuleSchema, type Scenario, ScenarioSchema, type StateAnnotations, StateAnnotationsSchema, type StateTransition, StateTransitionSchema, type StateVariable, StateVariableSchema, type Step, type StepKeyword, StepKeywordSchema, StepSchema, type UiAnnotations, UiAnnotationsSchema, type UiRoute, UiRouteSchema, type UiString, UiStringSchema, type UiTestId, UiTestIdSchema, UrlPathSchema, type VarType, VarTypeSchema, } from "./schema";

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

@@ -0,0 +1,4 @@
+/** builtin-commands barrel: explicit named re-exports of local modules only. */
+export { BUILTIN_COMMAND_DEFINITIONS, } from "./commands";
+export { buildBuiltinCommandEntries, type CommandAgentDeps, type CommandDefinitionInput, type CommandInvocation, type CommandSessionDeps, type CommandTransformDomain, type CommandTransformEditor, evaluateCommandTemplate, type RegisterCommandTransformDeps, type RegisterCommandTransformResult, registerCommandTransform, } from "./commands.transform";
+export type { BuiltinCommandName, BuiltinCommands, } from "./types";

package/dist/features/builtin-commands/templates/stop-continuation.d.ts

@@ -1 +1 @@
-export declare const STOP_CONTINUATION_TEMPLATE = "Stop all continuation mechanisms for the current session.\n\nThis command will:\n1. Stop the task-continuation-enforcer from automatically continuing incomplete tasks\n2. Cancel any active Matrix Loop\n3. Clear the mission state for the current project\n\nAfter running this command:\n- The session will not auto-continue when idle\n- You can manually continue work when ready\n- The stop state is per-session and clears when the session ends\n\nUse this when you need to pause automated continuation and take manual control.";
+export declare const STOP_CONTINUATION_TEMPLATE = "Stop all continuation mechanisms for the current session.\n\nThis command will:\n1. Stop automatic continuation of incomplete tasks\n2. Cancel any active Matrix Loop\n3. Clear the mission state for the current project\n\nAfter running this command:\n- The session will not auto-continue when idle\n- You can manually continue work when ready\n- The stop state is per-session and clears when the session ends\n\nUse this when you need to pause automated continuation and take manual control.";

package/dist/features/{hook-message-injector → context-injection/hook-bridge}/constants.d.ts

@@ -1 +1 @@
-export { MESSAGE_STORAGE, OPENCODE_STORAGE, PART_STORAGE } from "../../shared";
+export { MESSAGE_STORAGE, OPENCODE_STORAGE, PART_STORAGE } from "../../../shared";

package/dist/features/{hook-message-injector → context-injection/hook-bridge}/index.d.ts

@@ -1,5 +1,5 @@
 export { MESSAGE_STORAGE } from "./constants";
 export type { StoredMessage } from "./injector";
 export { findFirstMessageWithAgent, findFirstMessageWithAgentFromSDK, findNearestMessageWithFields, findNearestMessageWithFieldsFromSDK, injectHookMessage, resolveMessageContext, } from "./injector";
-export { invalidateSdkMessageCache } from "./sdk-message-cache";
+export { _resetSdkMessageCache, invalidateSdkMessageCache } from "./sdk-message-cache";
 export type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types";

package/dist/features/{hook-message-injector → context-injection/hook-bridge}/injector.d.ts

@@ -1,4 +1,4 @@
-import type { SessionContextCarrier } from "../../shared/session-context-source";
+import type { SessionContextCarrier } from "../../../shared/session/session-context-source";
 import type { OriginalMessageContext, ToolPermission } from "./types";
 export interface StoredMessage {
     agent?: string;

package/dist/features/context-injection/index.d.ts

@@ -0,0 +1,6 @@
+/** context-injection barrel: explicit named re-exports of local submodules only. */
+export type { MessageMeta, OriginalMessageContext, StoredMessage, TextPart, ToolPermission, } from "./hook-bridge";
+export { findFirstMessageWithAgent, findFirstMessageWithAgentFromSDK, findNearestMessageWithFields, findNearestMessageWithFieldsFromSDK, injectHookMessage, invalidateSdkMessageCache, MESSAGE_STORAGE, resolveMessageContext, } from "./hook-bridge";
+export type { ContextEntry, ContextPriority, ContextSourceType, InjectionStrategy, MessageContext, OutputParts, PendingContext, RegisterContextOptions, } from "./injector";
+export { ContextCollector, contextCollector, createContextInjectorMessagesTransformHook, MAX_MERGED_CHARS, MAX_PER_SOURCE_CHARS, } from "./injector";
+export { buildContextModeRoutingBlock, buildFallbackRoutingBlock, CONTEXT_MODE_INJECTOR_ID, CONTEXT_MODE_NOTICE_MESSAGE, CONTEXT_MODE_NOTICE_TITLE, containsContextModeMarker, createContextModeSystemTransformHook, HOOK_NAME, hashInjectionContent, MATRIXX_CONTEXT_MODE_MARKER, } from "./routing";

package/dist/features/context-injection/routing/index.d.ts

@@ -0,0 +1,3 @@
+/** context-mode-routing barrel: explicit named re-exports of local modules only. */
+export { buildContextModeRoutingBlock, buildFallbackRoutingBlock, containsContextModeMarker, MATRIXX_CONTEXT_MODE_MARKER, } from "./routing-block";
+export { CONTEXT_MODE_INJECTOR_ID, CONTEXT_MODE_NOTICE_MESSAGE, CONTEXT_MODE_NOTICE_TITLE, createContextModeSystemTransformHook, HOOK_NAME, hashInjectionContent, } from "./system-transform";

package/dist/features/{context-mode-routing → context-injection/routing}/system-transform.d.ts

@@ -1,6 +1,6 @@
-import type { MatrixxConfig } from "../../config";
-import type { MatrixxContext } from "../../plugin/context";
-import type { Hooks } from "../../plugin/legacy-hooks";
+import type { MatrixxConfig } from "../../../config";
+import type { MatrixxContext } from "../../../plugin/tool/context";
+import type { Hooks } from "../../../plugin/tool/legacy-hooks";
 export declare const HOOK_NAME = "context-mode-routing";
 /** Stable injector id for injection-notifier dedupe. */
 export declare const CONTEXT_MODE_INJECTOR_ID = "context-mode-routing";

package/dist/features/evolution/index.d.ts

@@ -1,3 +1,9 @@
+/** Evolution layer cross-link (orchestration vs triggers vs actions):
+ * - Orchestration: this module (`features/evolution/`) owns the pipeline, store, and writer.
+ * - Triggers: `hooks/evolution-hitl`, `hooks/evolution-watcher`, `hooks/evolution-compressor`,
+ *   `hooks/evolution-quality-gate` observe session/tool events and feed the pipeline.
+ * - Actions: `tools/evolution` exposes agent-callable tools (propose/approve/query) on the store.
+ */
 export { createCompressor } from "./compressor";
 export { LlmCompressor } from "./compressor/llm";
 export * from "./evaluator";

package/dist/features/plan-contract/schema.d.ts

@@ -29,8 +29,8 @@ import { z } from "zod";
 export declare const PlanContractSchema: z.ZodObject<{
     frontMatter: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            pending: "pending";
             completed: "completed";
+            pending: "pending";
             in_progress: "in_progress";
         }>;
         revision: z.ZodNumber;

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

@@ -0,0 +1,2 @@
+/** preset-state barrel: explicit named re-exports of local modules only. */
+export { _resetPresetStateForTesting, clearSessionPreset, getSessionPreset, setSessionPreset, } from "./manager";

package/dist/features/rtk-routing/index.d.ts

@@ -0,0 +1,3 @@
+/** rtk-routing barrel: explicit named re-exports of local modules only. */
+export { buildRtkRoutingBlock, containsRtkMarker, MATRIXX_RTK_MARKER, } from "./routing-block";
+export { createRtkSystemTransformHook, HOOK_NAME, hashRtkInjectionContent, RTK_INJECTOR_ID, RTK_NOTICE_MESSAGE, RTK_NOTICE_TITLE, type RtkSystemTransformOptions, } from "./system-transform";

package/dist/features/rtk-routing/system-transform.d.ts

@@ -1,6 +1,6 @@
 import type { MatrixxConfig } from "../../config";
-import type { MatrixxContext } from "../../plugin/context";
-import type { Hooks } from "../../plugin/legacy-hooks";
+import type { MatrixxContext } from "../../plugin/tool/context";
+import type { Hooks } from "../../plugin/tool/legacy-hooks";
 export declare const HOOK_NAME = "rtk-routing";
 /** Stable injector id for injection-notifier dedupe. */
 export declare const RTK_INJECTOR_ID = "rtk-routing";

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

@@ -0,0 +1,2 @@
+/** session-state barrel: explicit named re-exports of local modules only. */
+export { _resetForTesting, clearSessionAgent, clearSessionModel, getMainSessionID, getParentSessionID, getSessionAgent, getSessionModel, getSubagentSessionIDs, isMainSessionCandidate, registerSubagentSession, releaseSubagentSession, setMainSession, setSessionAgent, setSessionModel, subagentSessions, unregisterSubagentSession, updateSessionAgent, } from "./state";

package/dist/{hooks/task-continuation-enforcer → features/task-session-scope}/staleness.d.ts

@@ -1,7 +1,7 @@
 import type { MatrixxConfig } from "../../config/schema";
-import type { Task } from "../../features/task-storage/types";
+import type { Task } from "../task-storage/types";
 export declare const DEFAULT_STALE_AFTER_HOURS = 24;
-export { DEFAULT_BACKGROUND_STALE_AFTER_HOURS } from "../../shared/task-system-gating";
+export { DEFAULT_BACKGROUND_STALE_AFTER_HOURS } from "../../shared/config/task-system-gating";
 /**
  * Resolve the stale threshold (ms) from plugin config.
  * `tasks.stale_after_hours` (default 24h, legacy `morpheus.tasks.stale_after_hours`) — a pending task whose
@@ -14,7 +14,7 @@ export declare function getStaleAfterMs(config?: Partial<MatrixxConfig>): number
  * mtime basis as `getStaleAfterMs`, but a much shorter window because a task
  * held `pending`/`in_progress` with no file activity is a far stronger signal
  * when it is blocking a background handle than when it is merely delaying a
- * continuation nudge. The enforcer's 24h default deliberately stays at 24.
+ * continuation nudge. The 24h default deliberately stays at 24.
  */
 export declare function getBackgroundStaleAfterMs(config?: Partial<MatrixxConfig>): number;
 /**

package/dist/{hooks/task-continuation-enforcer → features/task-session-scope}/todo.d.ts

@@ -1,4 +1,4 @@
-import type { Task } from "../../features/task-storage/types";
+import type { Task } from "../task-storage/types";
 export declare function getIncompleteCount(todos: {
     status: string;
 }[]): number;

package/dist/features/task-storage/index.d.ts

@@ -0,0 +1,3 @@
+/** task-storage barrel: explicit named re-exports of local modules only. */
+export { acquireLock, acquireLockWithRetry, generateTaskId, getProjectTaskDir, getTaskDir, listTaskFiles, migrateLegacyTasksIfNeeded, readJsonSafe, resolveTaskListId, sanitizePathSegment, writeJsonAtomic, } from "./storage";
+export { type Task, TaskSchema, type TaskStatus, TaskStatusSchema, } from "./types";