opencode-matrixx 2.6.5 → 2.6.6

package/dist/cli.js

@@ -16159,6 +16159,7 @@ var HookNameEnum = exports_external.enum([
   "preemptive-compaction",
   "rules-injector",
   "background-notification",
+  "background-task-blocker",
   "auto-update-checker",
   "startup-toast",
   "keyword-detector",
@@ -16233,11 +16234,14 @@ var ModelFallbackEntrySchema = exports_external.object({
   variant: exports_external.string().optional()
 });
 var complexityDowngradeValueSchema = exports_external.string().refine((s) => {
-  if (s.includes("/")) {
-    const parts = s.split("/");
-    return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
-  }
-  return false;
+  if (!s.includes("/"))
+    return false;
+  if (s.startsWith("/") || s.endsWith("/"))
+    return false;
+  if (s.includes("//"))
+    return false;
+  const parts = s.split("/");
+  return parts.length >= 2 && parts.every((p) => p.length > 0);
 }, { message: "Must be <provider>/<model>" });
 var ComplexityDowngradesSchema = exports_external.record(exports_external.string(), exports_external.record(exports_external.string(), complexityDowngradeValueSchema));
 var AgentModelRequirementsSchema = exports_external.object({
@@ -16263,8 +16267,12 @@ var ModelRequirementsSchema = exports_external.object({
 var providerModelSchema = exports_external.string().refine((s) => {
   if (!s.includes("/"))
     return false;
+  if (s.startsWith("/") || s.endsWith("/"))
+    return false;
+  if (s.includes("//"))
+    return false;
   const parts = s.split("/");
-  return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
+  return parts.length >= 2 && parts.every((p) => p.length > 0);
 }, { message: "Must be <provider>/<model>" });
 var ModelPresetEntrySchema = exports_external.object({
   model: providerModelSchema,

package/dist/config/schema/hooks.d.ts

@@ -20,6 +20,7 @@ export declare const HookNameSchema: z.ZodUnion<readonly [z.ZodEnum<{
     "preemptive-compaction": "preemptive-compaction";
     "rules-injector": "rules-injector";
     "background-notification": "background-notification";
+    "background-task-blocker": "background-task-blocker";
     "auto-update-checker": "auto-update-checker";
     "startup-toast": "startup-toast";
     "keyword-detector": "keyword-detector";

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

@@ -93,6 +93,7 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "preemptive-compaction": "preemptive-compaction";
         "rules-injector": "rules-injector";
         "background-notification": "background-notification";
+        "background-task-blocker": "background-task-blocker";
         "auto-update-checker": "auto-update-checker";
         "startup-toast": "startup-toast";
         "keyword-detector": "keyword-detector";

package/dist/create-hooks.d.ts

@@ -33,6 +33,7 @@ export declare function createHooks(args: {
     thinkingBlockValidator: ReturnType<typeof import("./hooks").createThinkingBlockValidatorHook> | null;
     toolPairValidator: ReturnType<typeof import("./hooks").createToolPairValidatorHook> | null;
     designIntentPreserver: ReturnType<typeof import("./hooks").createDesignIntentPreserverHook> | null;
+    backgroundTaskBlocker: ReturnType<typeof import("./hooks").createBackgroundTaskBlockerHook> | null;
     commentChecker: ReturnType<typeof import("./hooks").createCommentCheckerHooks> | null;
     toolOutputTruncator: ReturnType<typeof import("./hooks").createToolOutputTruncatorHook> | null;
     directoryAgentsInjector: ReturnType<typeof import("./hooks").createDirectoryAgentsInjectorHook> | null;

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

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { BackgroundTask } from "./types";
+/**
+ * File-backed handle index for background tasks.
+ *
+ * Mirrors the `task-storage` pattern: one file per handle under a
+ * project-scoped `.matrixx/bg-handles/` directory, written atomically via
+ * `tmp + renameSync`. Only a lightweight index is persisted — prompts,
+ * progress, results, errors and tool-call windows stay ephemeral.
+ *
+ * This lets a freshly-created `BackgroundManager` recover previously-created
+ * `bg_*` handles after a plugin/process restart.
+ */
+export declare const BG_HANDLE_DIR_NAME = "bg-handles";
+export declare const BG_HANDLE_FILE_PREFIX = "bg_";
+export declare const BgHandleSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    parentSessionID: z.ZodString;
+    parentMessageID: z.ZodString;
+    description: z.ZodString;
+    agent: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        cancelled: "cancelled";
+        interrupt: "interrupt";
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+    }>;
+    model: z.ZodOptional<z.ZodObject<{
+        providerID: z.ZodString;
+        modelID: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    category: z.ZodOptional<z.ZodString>;
+    concurrencyGroup: z.ZodOptional<z.ZodString>;
+    queuedAt: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type BgHandle = z.infer<typeof BgHandleSchema>;
+/** Project-scoped handle directory: `<project>/.matrixx/bg-handles`. */
+export declare function getBgHandleDir(directory: string): string;
+/** One file per handle id: `<project>/.matrixx/bg-handles/<taskId>.json`. */
+export declare function getHandlePath(directory: string, taskId: string): string;
+/** Project a full task onto the lightweight, persistable handle index. */
+export declare function toHandle(task: BackgroundTask): BgHandle;
+/**
+ * Atomically persist a handle: write to a temp file then rename into place.
+ * Throws on write failure; callers decide how to surface it.
+ */
+export declare function writeHandle(directory: string, task: BackgroundTask): void;
+/** Read and validate every persisted handle. Invalid/corrupt files are skipped. */
+export declare function readHandles(directory: string): BgHandle[];
+/** Remove the handle file for a task id. Returns true when a file was deleted. */
+export declare function deleteHandleFile(directory: string, taskId: string): boolean;
+/**
+ * Bounded TTL sweep: delete handle files whose most recent timestamp is older
+ * than `ttlMs` (default 30 min). Corrupt/unreadable files are swept too so the
+ * directory cannot grow without bound. Returns the number of files removed.
+ */
+export declare function sweepStaleHandles(directory: string, ttlMs?: number, now?: number): number;

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,4 +1,5 @@
 export { ConcurrencyManager } from "./concurrency";
+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";
 export { TaskHistory, type TaskHistoryEntry } from "./task-history";

package/dist/features/background-agent/manager-handles.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -51,6 +51,18 @@ export declare class BackgroundManager {
         onShutdown?: () => void;
         enableParentSessionNotifications?: boolean;
     });
+    /**
+     * Persist a lightweight handle for the given task. Called on running and
+     * terminal transitions only — never on intermediate progress updates (C8).
+     * Best-effort: write failures are logged and never break task lifecycle.
+     */
+    private persistHandle;
+    /**
+     * Recover handles persisted by a previous manager/process. Sweeps stale
+     * handles first, then loads the remainder into memory. Running handles are
+     * marked `"interrupt"` (C6) and no concurrency is re-acquired (C7).
+     */
+    restoreHandles(): Promise<void>;
     launch(input: LaunchInput): Promise<BackgroundTask>;
     private processKey;
     private startTask;

package/dist/hooks/background-task-blocker/hook.d.ts

@@ -0,0 +1,10 @@
+export declare function createBackgroundTaskBlockerHook(): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, _output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+};

package/dist/hooks/background-task-blocker/index.d.ts

@@ -0,0 +1 @@
+export { createBackgroundTaskBlockerHook } from "./hook";

package/dist/hooks/index.d.ts

@@ -3,6 +3,7 @@ export { createArchitectHook } from "./architect";
 export { createAutoSlashCommandHook } from "./auto-slash-command";
 export { createAutoUpdateCheckerHook } from "./auto-update-checker";
 export { createBackgroundNotificationHook } from "./background-notification";
+export { createBackgroundTaskBlockerHook } from "./background-task-blocker";
 export { createBashFileReadGuardHook } from "./bash-file-read-guard";
 export { createCategorySkillReminderHook } from "./category-skill-reminder";
 export { createCommentCheckerHooks } from "./comment-checker";