opencode-matrixx 2.6.10 → 2.6.11

package/dist/config/schema/tool-gating.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+/** Startup-token tool auto-gating — defer rarely-needed LLM tools until auto-detect or opt-in */
+export declare const ToolGatingConfigSchema: z.ZodObject<{
+    bdd_tools: z.ZodOptional<z.ZodBoolean>;
+    pdf_figures: z.ZodOptional<z.ZodBoolean>;
+    look_at: z.ZodOptional<z.ZodBoolean>;
+    preset_tools: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ToolGatingConfig = z.infer<typeof ToolGatingConfigSchema>;

package/dist/config/schema.d.ts

@@ -16,6 +16,7 @@ export * from "./schema/experimental";
 export * from "./schema/failure-counter";
 export * from "./schema/headroom";
 export * from "./schema/hooks";
+export * from "./schema/knowledge";
 export * from "./schema/matrix-loop";
 export * from "./schema/matrixx-config";
 export * from "./schema/matrixx-self-config";
@@ -32,4 +33,5 @@ export * from "./schema/task";
 export * from "./schema/tasks";
 export * from "./schema/tdd-enforcer";
 export * from "./schema/tmux";
+export * from "./schema/tool-gating";
 export * from "./schema/websearch";

package/dist/create-hooks.d.ts

@@ -29,6 +29,7 @@ export declare function createHooks(args: {
     inputSecretGuard: ReturnType<typeof import("./hooks").createInputSecretGuardHook> | null;
     keywordDetector: ReturnType<typeof import("./hooks").createKeywordDetectorHook> | null;
     contextInjectorMessagesTransform: ReturnType<typeof import("./features/context-injector").createContextInjectorMessagesTransformHook>;
+    knowledgeHubInjector: ReturnType<typeof import("./hooks").createKnowledgeHubInjectorHook> | null;
     envContextInjector: ReturnType<typeof import("./hooks").createEnvContextInjectorHook> | null;
     thinkingBlockValidator: ReturnType<typeof import("./hooks").createThinkingBlockValidatorHook> | null;
     toolPairValidator: ReturnType<typeof import("./hooks").createToolPairValidatorHook> | null;
@@ -54,6 +55,8 @@ export declare function createHooks(args: {
     taskNotepad: ReturnType<typeof import("./hooks").createTaskNotepadHook> | null;
     taskEditGuard: ReturnType<typeof import("./hooks").createTaskEditGuardHook> | null;
     documentReaderGuard: ReturnType<typeof import("./hooks").createDocumentReaderGuardHook> | null;
+    knowledgeHubGuard: ReturnType<typeof import("./hooks").createKnowledgeHubGuardHook> | null;
+    knowledgeHubSearchNudge: ReturnType<typeof import("./hooks").createKnowledgeHubSearchNudgeHook> | null;
     evolutionWatcher: ReturnType<typeof import("./hooks").createEvolutionWatcherHook> | null;
     contextWindowMonitor: ReturnType<typeof import("./hooks").createContextWindowMonitorHook> | null;
     preemptiveCompaction: ReturnType<typeof import("./hooks").createPreemptiveCompactionHook> | null;

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

@@ -184,6 +184,25 @@ export declare class BackgroundManager {
      * Returns the number of tasks cancelled.
      */
     cancelAllForSession(parentSessionID: string): number;
+    /**
+     * Wait for all descendant tasks (running/pending) to reach a terminal state.
+     * Polls every `pollIntervalMs` until all tasks are terminal or `timeoutMs` elapses.
+     * Returns per-task results: completed tasks and timed-out (still running) tasks.
+     */
+    waitForAllDescendants(sessionID: string, timeoutMs?: number, pollIntervalMs?: number): Promise<{
+        completed: Array<{
+            id: string;
+            description: string;
+            agent: string;
+            status: string;
+        }>;
+        timedOut: Array<{
+            id: string;
+            description: string;
+            agent: string;
+            status: string;
+        }>;
+    }>;
     private startPolling;
     private stopPolling;
     private registerProcessCleanup;

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

@@ -86,8 +86,8 @@ export declare const HttpMethodSchema: z.ZodEnum<{
 }>;
 export declare const ResponseFormatSchema: z.ZodEnum<{
     binary: "binary";
-    text: "text";
     json: "json";
+    text: "text";
     html: "html";
     xml: "xml";
 }>;
@@ -118,8 +118,8 @@ export declare const ApiResponseSchema: z.ZodObject<{
     status: z.ZodNumber;
     format: z.ZodEnum<{
         binary: "binary";
-        text: "text";
         json: "json";
+        text: "text";
         html: "html";
         xml: "xml";
     }>;
@@ -174,8 +174,8 @@ export declare const ApiAnnotationsSchema: z.ZodObject<{
         status: z.ZodNumber;
         format: z.ZodEnum<{
             binary: "binary";
-            text: "text";
             json: "json";
+            text: "text";
             html: "html";
             xml: "xml";
         }>;
@@ -236,8 +236,8 @@ export declare const ContractAnnotationsSchema: z.ZodObject<{
             status: z.ZodNumber;
             format: z.ZodEnum<{
                 binary: "binary";
-                text: "text";
                 json: "json";
+                text: "text";
                 html: "html";
                 xml: "xml";
             }>;
@@ -366,8 +366,8 @@ export declare const ContractSchema: z.ZodObject<{
                 status: z.ZodNumber;
                 format: z.ZodEnum<{
                     binary: "binary";
-                    text: "text";
                     json: "json";
+                    text: "text";
                     html: "html";
                     xml: "xml";
                 }>;

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

@@ -1,3 +1,3 @@
 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" | "preset" | "end-ultrawork" | "research" | "assembly" | "ultrawork" | "bdd-backend" | "bdd-contract" | "bdd-frontend" | "bdd-pipeline" | "bdd-tests" | "dcp-profile" | "evolution" | "cleanup-tasks" | "task-list";
+export type BuiltinCommandName = "init-deep" | "matrix-loop" | "cancel-loop" | "ulw-loop" | "refactor" | "start-work" | "stop-continuation" | "handoff" | "pickup" | "remove-deadcode" | "preset" | "end-ultrawork" | "research" | "assembly" | "ultrawork" | "bdd-pipeline" | "evolution" | "cleanup-tasks" | "task-list";
 export type BuiltinCommands = Record<string, CommandDefinition>;

package/dist/features/knowledge-hub/index.d.ts

@@ -0,0 +1,3 @@
+export type { LoadedHub } from "./loader";
+export { expandHubPath, loadKnowledgeHubs } from "./loader";
+export { resolveKnowledgeFile } from "./resolver";

package/dist/features/knowledge-hub/loader.d.ts

@@ -0,0 +1,11 @@
+import { type KnowledgeConfig, type KnowledgeHub } from "../../config/schema/knowledge";
+export interface LoadedHub {
+    name: string;
+    root: string;
+    indexPath: string;
+    scope: KnowledgeHub["scope"];
+    mode: KnowledgeHub["mode"];
+    exclude: string[];
+}
+export declare function expandHubPath(rawPath: string, projectDir?: string): string;
+export declare function loadKnowledgeHubs(config: KnowledgeConfig | KnowledgeHub[], projectDir?: string): LoadedHub[];

package/dist/features/knowledge-hub/loader.test.d.ts

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

package/dist/features/knowledge-hub/resolver.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedHub } from "./loader";
+export declare function resolveKnowledgeFile(hubs: LoadedHub[], ref: string): string | null;

package/dist/features/knowledge-hub/resolver.test.d.ts

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

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

@@ -10,8 +10,28 @@ export declare const ORACLE_PLANS_DIR = ".matrixx/plans";
  */
 /** Relative path from project root to plans directory */
 export declare const PLANS_DIR = ".matrixx/plans";
+/** Subdir of PLANS_DIR holding archived stale plans; excluded from listings. */
+export declare const PLANS_ARCHIVE_DIR_NAME = "_archive";
+/** Default staleness window (hours) shared by task + plan archival. */
+export declare const DEFAULT_STALE_AFTER_HOURS = 24;
 /** 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;
+/**
+ * Plan Checkbox Patterns
+ *
+ * Single source of truth for plan progress counting (see getPlanProgress).
+ * All patterns are anchored to column 0: indented sub-checkboxes
+ * (acceptance criteria, Definition-of-Done nests) never count.
+ * Do NOT inline checkbox regexes elsewhere — import these instead.
+ */
+/** Top-level unchecked box: `- [ ]` or `* [ ]` */
+export declare const TOP_UNCHECKED_RE: RegExp;
+/** Top-level checked box: `- [x]` / `- [X]` (case-insensitive) */
+export declare const TOP_CHECKED_RE: RegExp;
+/** Numbered unchecked task (Oracle format): `- [ ] 1. Task` */
+export declare const NUMBERED_UNCHECKED_RE: RegExp;
+/** Numbered checked task (Oracle format): `- [x] 2. Task` */
+export declare const NUMBERED_CHECKED_RE: RegExp;

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

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

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

@@ -25,13 +25,39 @@ export declare function atomicWrite(filePath: string, content: string): boolean;
  */
 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.
- * Checked boxes are never unchecked — sync only transitions [ ] → [x].
+ * Verification-style guard: boxes matching verify/verification/checklist/
+ * definition-of-done/final check with zero task overlap are never
+ * force-completed — state kept, line reported via `flaggedVerification`.
+ */
+export declare const VERIFICATION_STYLE_RE: RegExp;
+/** Lowercase, strip punctuation/numbers, split tokens, drop stop-words. */
+export declare function normalizeCheckboxText(text: string): string[];
+export declare const isVerificationStyle: (text: string) => boolean;
+/**
+ * Token overlap: match on >= 2 shared content tokens, or on shorter-side
+ * ratio >= 0.5 with normalized-set equality (equality keeps exact matches
+ * like "Task A"; without it one generic word cross-matches every sibling,
+ * e.g. "Task D" would flip on completed "Task A").
+ */
+export declare function checkboxOverlap(a: string, b: string): {
+    shared: number;
+    score: number;
+    matched: boolean;
+};
+export interface SyncCheckboxesResult {
+    content: string;
+    flaggedVerification: string[];
+}
+/**
+ * Sync checkboxes to todos by token overlap (indented lines sync too, though
+ * Task 2 counting ignores them). Best overlap wins, ties go first. Checked
+ * boxes never uncheck ([ ] → [x] only); unmatched lines keep state.
  */
+export declare function syncCheckboxesDetailed(content: string, todos: Array<{
+    content: string;
+    status: string;
+}>): SyncCheckboxesResult;
+/** String-only wrapper (backward compatible with plan-persister hook). */
 export declare function syncCheckboxes(content: string, todos: Array<{
     content: string;
     status: string;

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

@@ -0,0 +1,75 @@
+/**
+ * Plan reconciliation + stale-plan archival policy.
+ *
+ * The reconciler re-runs the Tasks 3-4 linkage pass (checkboxOverlap +
+ * verification guard from plan-storage) with a confidence gate: only
+ * high-confidence token overlap auto-checks, the rest is reported for
+ * manual plan_update. Runs are idempotent — a converged plan yields no writes.
+ *
+ * Archival moves stale orphans to .matrixx/plans/_archive/ (never deletes).
+ */
+import type { MatrixxConfig } from "../../config/schema";
+export interface ReconcileTodo {
+    content: string;
+    status: string;
+}
+export interface ReconcileResult {
+    content: string;
+    checked: string[];
+    lowConfidence: string[];
+    flaggedVerification: string[];
+    changed: boolean;
+}
+export interface ReconcileFileResult extends ReconcileResult {
+    wrote: boolean;
+}
+/**
+ * High-confidence gate: token overlap matched (Task 3 thresholds) AND the
+ * box is not verification-flagged. Verification-style boxes with genuine
+ * overlap still flip (overlap wins); zero-overlap verification boxes land
+ * in flaggedVerification and never auto-check.
+ */
+export declare function isHighConfidence(boxText: string, todoContent: string, flaggedVerification?: string[]): boolean;
+/** Reconcile plan content against runtime todos; pure, no disk writes. */
+export declare function reconcilePlanContent(content: string, todos: ReconcileTodo[]): ReconcileResult;
+/** Reconcile one plan file; writes only when content changed (idempotent). */
+export declare function reconcilePlanFile(planPath: string, todos: ReconcileTodo[]): ReconcileFileResult;
+/** Invocation point for start-work: reconcile only when plans compete (>1). */
+export declare function shouldReconcileOnStartWork(incompleteCount: number): boolean;
+export interface ActiveTaskSubjects {
+    subjects: string[];
+    unknownTaskFiles: string[];
+}
+/**
+ * Subjects of active (pending/in_progress) tasks. Strict-schema drops
+ * (readJsonSafe -> null) are counted + logged as unknown — never treated
+ * as completed, never silently ignored.
+ */
+export declare function readActiveTaskSubjects(directory: string, config?: Partial<MatrixxConfig>): ActiveTaskSubjects;
+/** A plan whose file cannot be stat'ed is treated as fresh (not stale). */
+export declare function isStaleByMtime(planPath: string, staleAfterHours?: number): boolean;
+export type ArchiveDecision = "active-plan" | "linked-active-tasks" | "fresh" | "unreadable" | "stale-orphan";
+/** Archive candidacy: stale mtime AND zero linked active tasks AND not active. */
+export declare function isArchiveCandidate(planPath: string, content: string | null, subjects: string[], staleAfterHours: number, activePlan?: string | null): {
+    candidate: boolean;
+    reason: ArchiveDecision;
+};
+export interface ArchiveScanOptions {
+    staleAfterHours?: number;
+    activePlan?: string | null;
+    activeTaskSubjects?: string[];
+    config?: Partial<MatrixxConfig>;
+    dryRun?: boolean;
+}
+export interface ArchiveResult {
+    candidates: string[];
+    moved: string[];
+    unknownTaskFiles: string[];
+    before: number;
+    after: number;
+}
+/**
+ * Move stale orphans to _archive/ preserving bytes (incl. plan-persister
+ * meta). Dry-run reports candidates with zero moves. Never deletes.
+ */
+export declare function archiveStalePlans(directory: string, opts?: ArchiveScanOptions): ArchiveResult;

package/dist/features/mission-state/reconcile.test.d.ts

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

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

@@ -5,6 +5,23 @@
  */
 import type { MissionState, PlanProgress } from "./types";
 export declare function readMissionState(directory: string): MissionState | null;
+/**
+ * Normalize a parsed mission.json value in memory (no disk rewrite).
+ * Legacy files used a singular `session_id` string; modern files use
+ * `session_ids[]`. Missing or non-array values become `[]` unless a
+ * legacy `session_id` string is present, which becomes `[session_id]`.
+ */
+export declare function normalizeMissionState(parsed: unknown): MissionState | null;
+/**
+ * Rotate the mission when its active plan is complete: clear mission.json
+ * so the next start-work run auto-selects instead of zombie-resuming.
+ * Returns `{ rotated: true, state: null }` after clearing, otherwise the
+ * preserved state. Never rewrites an incomplete or missing mission.
+ */
+export declare function rotateMissionIfComplete(directory: string): {
+    rotated: boolean;
+    state: MissionState | null;
+};
 export declare function writeMissionState(directory: string, state: MissionState): boolean;
 export declare function appendSessionId(directory: string, sessionId: string): MissionState | null;
 export declare function clearMissionState(directory: string): boolean;
@@ -13,6 +30,15 @@ export declare function clearMissionState(directory: string): boolean;
  * Oracle stores plans at: {project}/.matrixx/plans/{name}.md
  */
 export declare function findOraclePlans(directory: string): string[];
+/**
+ * Count checkbox progress from plan content.
+ *
+ * Single content-level implementation behind getPlanProgress: numbered
+ * task lines (Oracle format) win when present, otherwise all top-level
+ * checkboxes count. Indented boxes never count. Do NOT inline checkbox
+ * regexes elsewhere — import the Task 2 constants instead.
+ */
+export declare function countPlanProgressFromContent(content: string): PlanProgress;
 /**
  * Parse a plan file and count checkbox progress.
  */

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

@@ -23,6 +23,12 @@ export interface PlanProgress {
     completed: number;
     /** Whether all tasks are done */
     isComplete: boolean;
+    /**
+     * True when total is 0 (empty, prose-only, or missing plan).
+     * isComplete stays true by vacuity; callers should log/warn and
+     * route these plans to human triage instead of treating them as done.
+     */
+    needsTriage?: boolean;
 }
 /**
  * Plan Persistence Types

package/dist/hooks/auto-slash-command/executor.d.ts

@@ -1,11 +1,19 @@
-import type { createOpencodeClient } from "@opencode-ai/sdk";
 import type { BuiltinSkill } from "../../features/builtin-skills";
 import type { ParsedSlashCommand } from "./types";
 export interface ExecutorOptions {
     skills?: BuiltinSkill[];
-    /** OpenCode SDK client for discovering plugin-registered commands */
-    client?: ReturnType<typeof createOpencodeClient>;
 }
+/**
+ * Ownership rule: the hook expands only matrixx-owned scopes (builtin,
+ * markdown command dirs, skills). Plugin-scope commands belong to other
+ * plugins and must fall through so the owning plugin handles them natively —
+ * claiming them renders instruction-less blocks (e.g. /dcp-compress). Empty
+ * templates are declined in every scope for the same reason.
+ */
+export declare function isHookOwnedCommand(cmd: {
+    scope: string;
+    content?: string;
+}): boolean;
 interface ExecuteResult {
     success: boolean;
     replacementText?: string;

package/dist/hooks/auto-slash-command/hook.d.ts

@@ -2,8 +2,6 @@ import type { BuiltinSkill } from "../../features/builtin-skills";
 import type { AutoSlashCommandHookInput, AutoSlashCommandHookOutput, CommandExecuteBeforeInput, CommandExecuteBeforeOutput } from "./types";
 export interface AutoSlashCommandHookOptions {
     skills?: BuiltinSkill[];
-    /** OpenCode SDK client for discovering plugin-registered commands */
-    client?: ReturnType<typeof import("@opencode-ai/sdk").createOpencodeClient>;
 }
 export declare function createAutoSlashCommandHook(options?: AutoSlashCommandHookOptions): {
     "chat.message": (input: AutoSlashCommandHookInput, output: AutoSlashCommandHookOutput) => Promise<void>;

package/dist/hooks/index.d.ts

@@ -31,6 +31,9 @@ export { createInputSecretGuardHook } from "./input-secret-guard";
 export { createInteractiveBashSessionHook } from "./interactive-bash-session";
 export { createJsonErrorRecoveryHook } from "./json-error-recovery";
 export { createKeywordDetectorHook } from "./keyword-detector";
+export { createKnowledgeHubGuardHook } from "./knowledge-hub-guard";
+export { createKnowledgeHubInjectorHook } from "./knowledge-hub-injector";
+export { createKnowledgeHubSearchNudgeHook } from "./knowledge-hub-search-nudge";
 export { createMatrixLoopHook, type MatrixLoopHook } from "./matrix-loop";
 export { createMouseNotepadHook } from "./mouse-notepad";
 export { createNonInteractiveEnvHook } from "./non-interactive-env";

package/dist/hooks/knowledge-hub-guard/approvals.d.ts

@@ -0,0 +1,5 @@
+export declare const HUB_WRITE_APPROVAL_TTL_MS: number;
+export declare function normalizeApprovedPath(absPath: string): string;
+export declare function approveHubWrite(sessionID: string, absPath: string, ttlMs?: number): string;
+export declare function isHubWriteApproved(sessionID: string, absPath: string): boolean;
+export declare function clearHubWriteApprovals(): void;

package/dist/hooks/knowledge-hub-guard/hook.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedHub } from "../../features/knowledge-hub/loader";
+export interface KnowledgeHubGuardOptions {
+    hubs?: LoadedHub[];
+    getHubs?: () => LoadedHub[];
+}
+export declare function createKnowledgeHubGuardHook(ctx: PluginInput, options?: KnowledgeHubGuardOptions): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+};

package/dist/hooks/knowledge-hub-guard/hook.test.d.ts

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

package/dist/hooks/knowledge-hub-guard/index.d.ts

@@ -0,0 +1,3 @@
+export { approveHubWrite, clearHubWriteApprovals, HUB_WRITE_APPROVAL_TTL_MS, isHubWriteApproved } from "./approvals";
+export type { KnowledgeHubGuardOptions } from "./hook";
+export { createKnowledgeHubGuardHook } from "./hook";

package/dist/hooks/knowledge-hub-injector/hook.d.ts

@@ -0,0 +1,26 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Message, Part } from "@opencode-ai/sdk";
+import type { KnowledgeHub } from "../../config/schema/knowledge";
+import { type ContextCollector } from "../../features/context-injector";
+export interface KnowledgeHubInjectorOptions {
+    hubs?: KnowledgeHub[];
+    getHubs?: () => KnowledgeHub[];
+    pinnedFiles?: string[];
+    collector?: ContextCollector;
+}
+interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+export declare function createKnowledgeHubInjectorHook(ctx: PluginInput, options?: KnowledgeHubInjectorOptions): {
+    "experimental.chat.messages.transform": (_input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/knowledge-hub-injector/hook.test.d.ts

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

package/dist/hooks/knowledge-hub-injector/index.d.ts

@@ -0,0 +1,2 @@
+export type { KnowledgeHubInjectorOptions } from "./hook";
+export { createKnowledgeHubInjectorHook } from "./hook";

package/dist/hooks/knowledge-hub-search-nudge/hook.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedHub } from "../../features/knowledge-hub/loader";
+export interface KnowledgeHubSearchNudgeOptions {
+    hubs?: LoadedHub[];
+    getHubs?: () => LoadedHub[];
+}
+export declare function createKnowledgeHubSearchNudgeHook(ctx: PluginInput, options?: KnowledgeHubSearchNudgeOptions): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+};

package/dist/hooks/knowledge-hub-search-nudge/hook.test.d.ts

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

package/dist/hooks/knowledge-hub-search-nudge/index.d.ts

@@ -0,0 +1,2 @@
+export type { KnowledgeHubSearchNudgeOptions } from "./hook";
+export { createKnowledgeHubSearchNudgeHook } from "./hook";

package/dist/hooks/plan-persister/index.d.ts

@@ -1,2 +1,6 @@
 export type { PlanPersister } from "./hook";
 export { createPlanPersister } from "./hook";
+export type { LinkageDecision, LinkageOptions, LinkedTodos } from "./task-link";
+export { collectLinkedTodos, isTaskLinkedToMission, isTerminalTaskStatus } from "./task-link";
+export type { FilteredSyncInput, FilteredSyncResult, MatchedBox, SyncTriggerInput, SyncTriggerResult, } from "./task-sync";
+export { applyFilteredSync, maybeSyncTaskToPlans } from "./task-sync";

package/dist/hooks/plan-persister/task-link.d.ts

@@ -0,0 +1,31 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { MissionState } from "../../features/mission-state/types";
+import type { TaskObject } from "../../tools/task/types";
+export declare function isTerminalTaskStatus(status: string): boolean;
+export interface LinkageOptions {
+    directory: string;
+    sessionScoped: boolean;
+    resolveParent?: (parentID: string) => TaskObject | null;
+}
+export interface LinkageDecision {
+    linked: boolean;
+    reason: string;
+}
+export declare function isTaskLinkedToMission(task: TaskObject, mission: MissionState, opts: LinkageOptions, depth?: number, seen?: ReadonlySet<string>): LinkageDecision;
+export interface LinkedTodos {
+    todos: Array<{
+        content: string;
+        status: string;
+    }>;
+    unknown: number;
+    skipped: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+/**
+ * Filtered replacement for the old unfiltered union read: strict-parse every
+ * task file (null = log + count as unknown, never a vote), drop stale files,
+ * and admit only mission-linked tasks.
+ */
+export declare function collectLinkedTodos(directory: string, mission: MissionState, config?: Partial<MatrixxConfig>): LinkedTodos;

package/dist/hooks/plan-persister/task-sync.d.ts

@@ -0,0 +1,39 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { MissionState } from "../../features/mission-state/types";
+import type { TaskObject } from "../../tools/task/types";
+import { collectLinkedTodos } from "./task-link";
+export interface FilteredSyncInput {
+    directory: string;
+    mission: MissionState;
+    planPath: string;
+    todos: Array<{
+        content: string;
+        status: string;
+    }>;
+    actorSessionId: string;
+    matchSubject?: string;
+}
+export interface MatchedBox {
+    line: string;
+    shared: number;
+    score: number;
+}
+export interface FilteredSyncResult {
+    ok: boolean;
+    skippedReason?: string;
+    total: number;
+    completed: number;
+    flaggedVerification: string[];
+    matched?: MatchedBox;
+}
+export declare function applyFilteredSync(input: FilteredSyncInput): Promise<FilteredSyncResult>;
+export interface SyncTriggerInput {
+    directory: string;
+    task: TaskObject;
+    config?: Partial<MatrixxConfig>;
+}
+export interface SyncTriggerResult extends FilteredSyncResult {
+    linked: boolean;
+}
+export declare function maybeSyncTaskToPlans(input: SyncTriggerInput): Promise<SyncTriggerResult>;
+export { collectLinkedTodos };

package/dist/hooks/plan-persister/task-sync.test.d.ts

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

package/dist/hooks/start-work/index.d.ts

@@ -1 +1,2 @@
+export * from "./plan-filter";
 export { createStartWorkHook, HOOK_NAME } from "./start-work-hook";