opencode-matrixx 2.6.12 → 2.6.14

package/dist/hooks/session-notification-scheduler.d.ts

@@ -13,7 +13,7 @@ export declare function createIdleNotificationScheduler(options: {
     ctx: PluginInput;
     platform: Platform;
     config: SessionNotificationConfig;
-    hasIncompleteTodos: (ctx: PluginInput, sessionID: string) => Promise<boolean>;
+    hasIncompleteTaskWork: (ctx: PluginInput, sessionID: string) => Promise<boolean>;
     send: (ctx: PluginInput, platform: Platform, title: string, message: string) => Promise<void>;
     playSound: (ctx: PluginInput, platform: Platform, soundPath: string) => Promise<void>;
 }): {

package/dist/hooks/session-notification.d.ts

@@ -1,4 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { MatrixxConfig } from "../config/schema";
 interface SessionNotificationConfig {
     title?: string;
     message?: string;
@@ -6,12 +7,18 @@ interface SessionNotificationConfig {
     soundPath?: string;
     /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
     idleConfirmationDelay?: number;
-    /** Skip notification if there are incomplete todos (default: true) */
+    /** Skip notification if the session (or one of its subagents) still has pending work in the file-backed task store (default: true) */
     skipIfIncompleteTodos?: boolean;
     /** Maximum number of sessions to track before cleanup (default: 100) */
     maxTrackedSessions?: number;
 }
-export declare function createSessionNotification(ctx: PluginInput, config?: SessionNotificationConfig): ({ event }: {
+export declare function createSessionNotification(ctx: PluginInput, config?: SessionNotificationConfig, 
+/**
+ * The plugin config is a separate parameter, not part of `SessionNotificationConfig`:
+ * only `tasks.*` is read here, and widening the hook-local config would blur a
+ * presentation-only shape into a carrier for task-storage settings.
+ */
+pluginConfig?: Partial<MatrixxConfig>): ({ event }: {
     event: {
         type: string;
         properties?: unknown;

package/dist/hooks/task-continuation-enforcer/handler.d.ts

@@ -15,4 +15,3 @@ export declare function createTaskContinuationHandler(args: {
         properties?: unknown;
     };
 }) => Promise<void>;
-export declare const createTodoContinuationHandler: typeof createTaskContinuationHandler;

package/dist/hooks/task-continuation-enforcer/index.d.ts

@@ -3,4 +3,3 @@ import type { TaskContinuationEnforcer, TaskContinuationEnforcerOptions } from "
 export { createTaskContinuationHandler } from "./handler";
 export type { TaskContinuationEnforcer, TaskContinuationEnforcerOptions } from "./types";
 export declare function createTaskContinuationEnforcer(ctx: PluginInput, options?: TaskContinuationEnforcerOptions): TaskContinuationEnforcer;
-export declare const createTodoContinuationEnforcer: typeof createTaskContinuationEnforcer;

package/dist/hooks/task-continuation-enforcer/staleness.d.ts

@@ -1,12 +1,22 @@
 import type { MatrixxConfig } from "../../config/schema";
 import type { Task } from "../../features/task-storage/types";
 export declare const DEFAULT_STALE_AFTER_HOURS = 24;
+export { DEFAULT_BACKGROUND_STALE_AFTER_HOURS } from "../../shared/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
  * task file has had no write activity for longer than this is "stale".
  */
 export declare function getStaleAfterMs(config?: Partial<MatrixxConfig>): number;
+/**
+ * Resolve the background completion-gate threshold (ms) from plugin config.
+ * `tasks.background_stale_after_hours` (default 2h, canonical only) — the same
+ * 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.
+ */
+export declare function getBackgroundStaleAfterMs(config?: Partial<MatrixxConfig>): number;
 /**
  * Age of a task file in ms since last write (mtime). Returns null when the
  * file cannot be stat'ed (missing/unreadable) — callers treat null as "not stale".

package/dist/hooks/task-continuation-enforcer/todo.d.ts

@@ -20,9 +20,10 @@ export declare function dropSubtasksWithResolvedParent(tasks: Task[]): Task[];
 /**
  * Filter tasks by session scope.
  * - When sessionScoped=false: all tasks pass through (opt-out / legacy behavior)
- * - Pre-migration tasks (no threadID) are always included for backward compatibility
  * - Current session's tasks (threadID === sessionID) are included
  * - Subagent session tasks (threadID in subagentIDs) are included
+ * - Tasks with no threadID are excluded: threadID is required by TaskObjectSchema, so
+ *   an unattributed task cannot be attributed and is not claimed by any session
  * - All other tasks are excluded
  */
 export declare function filterTasksBySession(tasks: Task[], options: SessionFilterOptions): Task[];

package/dist/hooks/task-continuation-enforcer/types.d.ts

@@ -20,14 +20,6 @@ export interface TaskContinuationEnforcer {
     cancelAllCountdowns: () => void;
     isAwaitingUser: (sessionID: string) => boolean;
 }
-export type TodoContinuationEnforcerOptions = TaskContinuationEnforcerOptions;
-export type TodoContinuationEnforcer = TaskContinuationEnforcer;
-export interface Todo {
-    content: string;
-    status: string;
-    priority: string;
-    id?: string;
-}
 export interface SessionState {
     countdownTimer?: ReturnType<typeof setTimeout>;
     countdownInterval?: ReturnType<typeof setInterval>;

package/dist/hooks/task-notepad-writer/constants.d.ts

@@ -0,0 +1,42 @@
+export declare const HOOK_NAME = "task-notepad-writer";
+export declare const MATRIXX_DIR_NAME = ".matrixx";
+export declare const PLANS_SUBDIR = "plans";
+export declare const NOTEPADS_SUBDIR = "notepads";
+export declare const PLAN_EXTENSION = ".md";
+export declare const NOTEPAD_EXTENSION = ".md";
+export declare const ADHOC_BUCKET = "adhoc";
+export declare const TASK_CREATE_TOOL = "task_create";
+export declare const TASK_UPDATE_TOOL = "task_update";
+export declare const COMPLETED_STATUS = "completed";
+export declare const DEFAULT_PRIORITY = "medium";
+export declare const COMPLETION_SECTION_TITLE = "## Completion";
+export declare const PLAN_NAME_METADATA_KEY = "planName";
+export declare const SLUG_MAX_LENGTH = 60;
+export declare const NOTEPAD_SECTIONS: readonly [{
+    readonly heading: "## Findings";
+    readonly body: "(Record what you learn about this code as you work — patterns, conventions, gotchas, useful references.)";
+}, {
+    readonly heading: "## Blockers";
+    readonly body: "(Anything blocking progress. Be specific: file path, line, error, workaround if any.)";
+}, {
+    readonly heading: "## Questions";
+    readonly body: "(Open questions to revisit later. Don't lose them when context compacts.)";
+}, {
+    readonly heading: "## Results";
+    readonly body: "(Summary on completion. What changed, what was verified, what remains.)";
+}];
+/**
+ * The header's `**Task ID**: <id>` line is the durable idempotency marker: it
+ * lives inside the file, so a lookup finds the same notepad across process
+ * restarts, with no in-memory bookkeeping to lose.
+ */
+export declare function taskIdMarkerLine(taskId: string): string;
+export declare function taskIdMarkerPresent(content: string, taskId: string): boolean;
+export declare function renderNotepad(input: {
+    subject: string;
+    taskId: string;
+    priority?: string | undefined;
+    status?: string | undefined;
+    startedAt: string;
+}): string;
+export declare function renderCompletionStamp(completedAt: string): string;

package/dist/hooks/task-notepad-writer/hook.d.ts

@@ -0,0 +1,14 @@
+import { type TaskNotepadWriterContext } from "./notepad-path";
+export interface ToolAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+export interface ToolAfterOutput {
+    title: string;
+    output: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function createTaskNotepadWriterHook(ctx: TaskNotepadWriterContext): {
+    "tool.execute.after": (input: ToolAfterInput, output: ToolAfterOutput | undefined) => Promise<void>;
+};

package/dist/hooks/task-notepad-writer/index.d.ts

@@ -0,0 +1,2 @@
+export { createTaskNotepadWriterHook, type ToolAfterInput, type ToolAfterOutput } from "./hook";
+export type { TaskNotepadWriterContext } from "./notepad-path";

package/dist/hooks/task-notepad-writer/notepad-path.d.ts

@@ -0,0 +1,36 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { MatrixxConfig } from "../../config/schema";
+export type TaskNotepadWriterContext = PluginInput & {
+    config?: Partial<MatrixxConfig>;
+};
+export interface NotepadTask {
+    id: string;
+    subject: string;
+    metadata?: Record<string, unknown> | undefined;
+    status?: string | undefined;
+    priority?: string | undefined;
+}
+export type BucketReason = "plan-file-exists" | "no-plan-name" | "plan-file-missing";
+export interface NotepadResolution {
+    bucketDir: string;
+    filePath: string;
+    reason: BucketReason;
+}
+export declare function notepadsRootFor(directory: string): string;
+export declare function extractPlanName(task: NotepadTask): string | null;
+export declare function slugifySubject(subject: string, fallback: string): string;
+export declare function countNotepadFiles(bucketDir: string): number;
+export declare function resolveNotepadPath(input: {
+    ctx: TaskNotepadWriterContext;
+    task: NotepadTask;
+    notepadRoot: string;
+}): NotepadResolution;
+export declare function findExistingNotepadForTask(bucketDir: string, taskId: string): string | null;
+export declare function findNotepadForTask(input: {
+    ctx: TaskNotepadWriterContext;
+    task: NotepadTask;
+    notepadRoot: string;
+}): {
+    filePath: string;
+    bucketDir: string;
+} | null;