opencode-matrixx 2.6.10 → 2.6.12

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/features/plan-contract/appendix.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Plan Contract — Appendix Boundary
+ *
+ * Locates the designated appendix region of a plan. The region begins at the
+ * first H2 whose normalized text is exactly `Appendix` and extends to EOF.
+ * H2s at/after it are exempt from canonical-section and ordering checks.
+ *
+ * Pure content-level helper — accepts a string only, never touches the file system.
+ */
+/**
+ * Return the ZERO-BASED line index of the first `## Appendix` H2, or `-1` when
+ * the plan has no appendix. "Normalized" means the heading text is trimmed.
+ */
+export declare function findAppendixStart(content: string): number;

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

@@ -0,0 +1,16 @@
+/**
+ * Plan Contract Constants
+ *
+ * Canonical structure of an Oracle work plan: the ordered H2 sections and the
+ * required per-task grammar. Checkbox regexes are the single source of truth in
+ * mission-state — re-exported here, never re-declared.
+ */
+export { NUMBERED_CHECKED_RE, NUMBERED_UNCHECKED_RE, TOP_CHECKED_RE, TOP_UNCHECKED_RE, } from "../../features/mission-state/constants";
+/** Ordered H2 section titles, exactly as emitted by the Oracle plan template. */
+export declare const CANONICAL_SECTIONS: readonly ["TL;DR", "Context", "Work Objectives", "Verification Strategy (MANDATORY)", "Execution Strategy", "TODOs", "Commit Strategy", "Success Criteria"];
+/** Ordered labels that every TODO task block must declare. */
+export declare const REQUIRED_TASK_SUBFIELDS: readonly ["What to do", "Must NOT do", "Recommended Agent Profile", "Parallelization", "References", "Acceptance Criteria", "Agent-Executed QA Scenarios"];
+/** Canonical section title union derived from {@link CANONICAL_SECTIONS}. */
+export type PlanSection = (typeof CANONICAL_SECTIONS)[number];
+/** Canonical task subfield label union derived from {@link REQUIRED_TASK_SUBFIELDS}. */
+export type PlanTaskSubfield = (typeof REQUIRED_TASK_SUBFIELDS)[number];

package/dist/features/plan-contract/front-matter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Plan Front-Matter
+ *
+ * Structured YAML front-matter (a leading `---` fenced block) for Oracle plan
+ * files, parsed with `js-yaml`.
+ *
+ * PRECEDENCE: when a front-matter block is present it is authoritative for
+ * `status` and `revision`. The legacy `<!-- plan-persister: {...} -->` comment
+ * (see mission-state `plan-storage.ts`) remains authoritative for `todoTotal`,
+ * `todoCompleted`, `updatedAt` and `sessionId`, and is NEVER removed. Front-matter
+ * is ADDITIVE over that comment, not a replacement.
+ *
+ * Serialization is IDEMPOTENT: `parse(serialize(parse(content)))` equals
+ * `parse(content)`, and `serialize(parse(serialize(fm)))` equals
+ * `serialize(fm)`. On disagreement `status` comes from the front-matter while
+ * the legacy comment is left untouched.
+ */
+import type { PlanFrontMatter } from "./types";
+/**
+ * Parse the leading YAML front-matter block.
+ *
+ * Returns `null` when the block is absent, malformed, or fails the
+ * {@link PlanFrontMatter} shape (e.g. missing `status`/`revision` or an
+ * out-of-vocabulary status).
+ */
+export declare function parsePlanFrontMatter(content: string): PlanFrontMatter | null;
+/**
+ * Serialize front-matter to a `---` fenced YAML block.
+ *
+ * Optional fields are omitted when `undefined`; array fields are emitted even
+ * when empty. The returned block ends with a trailing newline so it can be
+ * prepended to plan content additively.
+ */
+export declare function serializePlanFrontMatter(fm: PlanFrontMatter): string;

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

@@ -0,0 +1,14 @@
+/**
+ * Plan Contract — barrel
+ *
+ * Foundation module for the plan contract: canonical sections, task grammar,
+ * and the Zod schema for the structured plan view.
+ */
+export { findAppendixStart } from "./appendix";
+export { CANONICAL_SECTIONS, NUMBERED_CHECKED_RE, NUMBERED_UNCHECKED_RE, type PlanSection, type PlanTaskSubfield, REQUIRED_TASK_SUBFIELDS, TOP_CHECKED_RE, TOP_UNCHECKED_RE, } from "./constants";
+export { parsePlanFrontMatter, serializePlanFrontMatter } from "./front-matter";
+export { isGrandfathered, shouldMigrate } from "./migration";
+export { type PlanContract, PlanContractSchema } from "./schema";
+export { renderPlanSkeleton } from "./skeleton";
+export type { PlanContractResult, PlanContractWarning, PlanFrontMatter, PlanStatus, PlanTask, } from "./types";
+export { parsePlanContract, parsePlanTasks, validatePlanContract } from "./validate";

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

@@ -0,0 +1,36 @@
+/**
+ * Plan Front-Matter Migration & Grandfathering
+ *
+ * Front-matter is ADDITIVE over the legacy `<!-- plan-persister: {...} -->`
+ * comment (`mission-state/plan-storage.ts`) — it does not replace it. Migration
+ * is apply-on-next-edit ONLY: no `plan_migrate` tool is shipped and no plan is
+ * rewritten automatically.
+ *
+ * Grandfathering protects the pre-existing plan corpus from retro-breaking: a
+ * plan that lacks front-matter is only exempt when its id is on the frozen
+ * {@link GRANDFATHER_ALLOWLIST}. A brand-new plan lacking front-matter is NOT
+ * grandfathered.
+ */
+/**
+ * Frozen allowlist of plan ids (filename without `.md`) that predate the
+ * front-matter requirement — captured from the live `.matrixx/plans` corpus
+ * (23 files) at planning time.
+ *
+ * Grandfathered plans never emit a front-matter warning and are exempt from any
+ * future FAIL-mode front-matter requirement. The exemption clears as soon as
+ * the plan gains a front-matter block.
+ */
+export declare const GRANDFATHER_ALLOWLIST: readonly string[];
+/**
+ * True IFF the plan has no front-matter AND its id is on the frozen allowlist.
+ *
+ * This is deliberately narrower than "any plan lacking front-matter": a new
+ * non-allowlisted plan returns `false`.
+ */
+export declare function isGrandfathered(filePath: string, content: string): boolean;
+/**
+ * True IFF front-matter is absent, for ANY plan (grandfathered included),
+ * because injection is additive. Idempotent: once front-matter is present this
+ * returns `false`.
+ */
+export declare function shouldMigrate(content: string): boolean;

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

@@ -0,0 +1,32 @@
+/**
+ * Plan Contract Schema
+ *
+ * Zod v4 schema for the STRUCTURED view of an Oracle plan. The Markdown grammar
+ * itself is parsed elsewhere; this validates the parsed shape.
+ */
+import { z } from "zod";
+export declare const PlanContractSchema: z.ZodObject<{
+    frontMatter: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            in_progress: "in_progress";
+        }>;
+        revision: z.ZodNumber;
+        phase: z.ZodOptional<z.ZodString>;
+        wave: z.ZodOptional<z.ZodString>;
+        deps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        blockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    sections: z.ZodArray<z.ZodString>;
+    tasks: z.ZodArray<z.ZodObject<{
+        n: z.ZodNumber;
+        title: z.ZodString;
+        checked: z.ZodBoolean;
+        line: z.ZodNumber;
+        anchor: z.ZodString;
+    }, z.core.$strip>>;
+    dod: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** Parsed, validated structured view of a plan. */
+export type PlanContract = z.infer<typeof PlanContractSchema>;

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

@@ -0,0 +1,5 @@
+/**
+ * Render the full canonical Oracle plan markdown skeleton — the content between
+ * the `\`\`\`markdown` fences of {@link ORACLE_PLAN_TEMPLATE}.
+ */
+export declare function renderPlanSkeleton(): string;

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

@@ -0,0 +1,56 @@
+/**
+ * Plan Contract Types
+ *
+ * Structured view of an Oracle work plan: parsed sections, numbered tasks,
+ * definition-of-done lines, and optional YAML front-matter.
+ */
+import type { PlanSection } from "./constants";
+export type { PlanSection };
+/** A single numbered TODO task parsed from a plan. */
+export interface PlanTask {
+    /** Task number as written in the plan (e.g. `1` in `- [ ] 1. ...`). */
+    n: number;
+    /** Task title text following the number. */
+    title: string;
+    /** Whether the task checkbox is checked. */
+    checked: boolean;
+    /** 1-based line number of the task within the plan file. */
+    line: number;
+    /** Stable LINE#ID anchor for hashline-scoped edits. */
+    anchor: string;
+}
+/** Severity-neutral diagnostic emitted while validating a plan contract. */
+export interface PlanContractWarning {
+    /** Machine-readable warning code. */
+    code: string;
+    /** Human-readable explanation. */
+    message: string;
+    /** 1-based line the warning refers to, when known. */
+    line?: number;
+}
+/** Outcome of validating a plan against the contract. */
+export interface PlanContractResult {
+    /** True when no errors were produced (warnings may still be present). */
+    ok: boolean;
+    /** Non-fatal contract deviations. */
+    warnings: PlanContractWarning[];
+    /** Fatal contract violations. */
+    errors: string[];
+}
+/** Lifecycle status carried by a plan's YAML front-matter. */
+export type PlanStatus = "pending" | "in_progress" | "completed";
+/** Structured YAML front-matter block parsed from a plan file. */
+export interface PlanFrontMatter {
+    /** Current plan lifecycle status. */
+    status: PlanStatus;
+    /** Monotonic revision counter. */
+    revision: number;
+    /** Execution phase label, when present. */
+    phase?: string;
+    /** Execution wave label, when present. */
+    wave?: string;
+    /** Task ids this plan depends on. */
+    deps?: string[];
+    /** Task ids blocked by this plan. */
+    blockedBy?: string[];
+}

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

@@ -0,0 +1,9 @@
+import type { PlanContract } from "./schema";
+import type { PlanContractResult, PlanTask } from "./types";
+/** Optional caller-supplied LINE#ID anchors keyed by 1-based line number. */
+export type HashlineAnchors = ReadonlyMap<number, string> | Readonly<Record<number, string>>;
+export declare function parsePlanTasks(content: string, hashlineAnchors?: HashlineAnchors): PlanTask[];
+export declare function parsePlanContract(content: string): PlanContract;
+export declare function validatePlanContract(content: string, options?: {
+    mode?: "warn" | "fail";
+}): PlanContractResult;

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

@@ -28,14 +28,3 @@ export declare function setSessionAgent(sessionID: string, agent: string): void;
 export declare function updateSessionAgent(sessionID: string, agent: string): void;
 export declare function getSessionAgent(sessionID: string): string | undefined;
 export declare function clearSessionAgent(sessionID: string): void;
-export declare function incFailureCounter(sessionID: string): number;
-export declare function resetFailureCounter(sessionID: string): void;
-export declare function getFailureCount(sessionID: string): number;
-export declare function getFailureState(sessionID: string): {
-    count: number;
-    lastFailedAt: number;
-} | undefined;
-export declare function clearFailureCounter(sessionID: string): void;
-/** @internal For testing only */
-export declare function _resetFailureCountersForTesting(): void;
-export declare function isThresholdReached(sessionID: string, threshold: number): boolean;

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/evolution-compressor/host-llm-call.d.ts

@@ -0,0 +1,17 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+import type { LlmUsage } from "../../features/evolution/compressor/interface";
+type Client = ReturnType<typeof createOpencodeClient>;
+export declare function parseModelOverride(model: string | undefined): {
+    providerID: string;
+    modelID: string;
+} | undefined;
+export declare function createHostLlmCall(options: {
+    client: Client;
+    directory: string;
+    agent?: string;
+    model?: string;
+}): (prompt: string, model?: string) => Promise<{
+    text: string;
+    usage?: LlmUsage;
+}>;
+export {};

package/dist/hooks/index.d.ts

@@ -24,13 +24,14 @@ export { createEvolutionCompressorHook } from "./evolution-compressor";
 export { createEvolutionHitlHook } from "./evolution-hitl";
 export { passesQualityGate } from "./evolution-quality-gate";
 export { createEvolutionWatcherHook } from "./evolution-watcher";
-export { createFailureCounterHook } from "./failure-counter";
-export { createHashlineEditDiffEnhancerHook } from "./hashline-edit-diff-enhancer";
 export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
 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";