opencode-matrixx 2.6.11 → 2.6.12

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import type { KnowledgeKind } from "./types";
+/**
+ * D5 typed knowledge kinds — DATA schemas (not config knobs).
+ *
+ * The `KnowledgeKind` union lives in `./types` (single source); this module
+ * owns the Zod runtime schema plus the fail-open normalizer used on every
+ * read path (LLM output, stored JSON, legacy meta.json without `kind`).
+ */
+export declare const KNOWLEDGE_KINDS: readonly ["workflow", "correction", "debugging_pattern", "gotcha", "convention"];
+export declare const KnowledgeKindSchema: z.ZodEnum<{
+    workflow: "workflow";
+    correction: "correction";
+    debugging_pattern: "debugging_pattern";
+    gotcha: "gotcha";
+    convention: "convention";
+}>;
+export declare const DEFAULT_KNOWLEDGE_KIND: KnowledgeKind;
+/**
+ * Fail-open normalizer: valid kinds pass through, missing/unknown values
+ * become `convention` instead of throwing (back-compat for stored JSON).
+ */
+export declare function normalizeKnowledgeKind(value: unknown): KnowledgeKind;
+/** Data-shape schema for distilled knowledge (stored/LLM JSON, not config). */
+export declare const DistilledKnowledgeDataSchema: z.ZodObject<{
+    title: z.ZodString;
+    summary: z.ZodString;
+    patterns: z.ZodArray<z.ZodString>;
+    pitfalls: z.ZodArray<z.ZodString>;
+    prerequisites: z.ZodArray<z.ZodString>;
+    skillDraft: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    sourceSessionIDs: z.ZodArray<z.ZodString>;
+    kind: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        workflow: "workflow";
+        correction: "correction";
+        debugging_pattern: "debugging_pattern";
+        gotcha: "gotcha";
+        convention: "convention";
+    }>>>;
+    projectId: z.ZodOptional<z.ZodString>;
+    sourceTraceIDs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    distilledAt: z.ZodOptional<z.ZodString>;
+    superseded_by: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DistilledKnowledgeData = z.infer<typeof DistilledKnowledgeDataSchema>;

package/dist/features/evolution/store/budget-ledger.d.ts

@@ -0,0 +1,46 @@
+import type { CompressionUsage } from "../types";
+export declare const BUDGET_FILE = ".matrixx/evolution/budget.json";
+/** Typed capacity breach for the writer's pending queue. */
+export declare class MaxPendingError extends Error {
+    readonly pending: number;
+    readonly maxPending: number;
+    constructor(pending: number, maxPending: number);
+}
+/** One recorded compression charge. */
+export type BudgetEvent = {
+    at: string;
+    inputTokens: number;
+    outputTokens: number;
+    costCents: number;
+};
+/** Persisted per-day ledger shape for `.matrixx/evolution/budget.json`. */
+export type BudgetLedger = {
+    day: string;
+    spendCents: number;
+    events: BudgetEvent[];
+};
+/** UTC calendar-day key (`YYYY-MM-DD`) for an instant. Pure. */
+export declare function utcDayKey(at: Date): string;
+/** Absolute ledger path for an evolution dir. */
+export declare function budgetPath(evolutionDir: string): string;
+export declare function emptyLedger(day: string): BudgetLedger;
+/** Reset a ledger when the UTC day rolls over. Pure. */
+export declare function rollLedger(ledger: BudgetLedger, day: string): BudgetLedger;
+/** Include-inclusive cap check for one more charge. Pure. */
+export declare function withinDailyCap(ledger: BudgetLedger, usage: CompressionUsage, maxCostCentsPerDay: number): boolean;
+/** Append a charge to the ledger, rolling the day first. Pure (caller persists). */
+export declare function recordUsage(ledger: BudgetLedger, usage: CompressionUsage, at: Date): BudgetLedger;
+/** True once recorded spend meets or exceeds the daily cap. */
+export declare function isOverDailyCap(ledger: BudgetLedger, maxCostCentsPerDay: number): boolean;
+/** Throw MaxPendingError when the pending queue is full. */
+export declare function checkPendingCapacity(pendingCount: number, maxPending: number): void;
+/** Read the persisted ledger, rolling to `now`'s UTC day; fail-open on any error. */
+export declare function loadLedger(evolutionDir: string, now?: Date): BudgetLedger;
+/** Persist the ledger atomically (tmp + rename), mirroring the repo convention. */
+export declare function saveLedger(evolutionDir: string, ledger: BudgetLedger): void;
+/**
+ * Load-modify-write a charge. Not locked across processes: concurrent writers
+ * follow last-write-wins (a lost charge is acceptable for a single-process
+ * plugin). Sequential callers accumulate correctly.
+ */
+export declare function recordUsageToDisk(evolutionDir: string, usage: CompressionUsage, at?: Date): BudgetLedger;

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

@@ -0,0 +1,5 @@
+export * from "./budget-ledger";
+export * from "./lifecycle";
+export * from "./project-identity";
+export * from "./query";
+export * from "./trace-store";

package/dist/features/evolution/store/lifecycle.d.ts

@@ -0,0 +1,52 @@
+import type { KnowledgeKind } from "../types";
+export declare const QUARANTINE_SEGMENT = "quarantine";
+export type ProposalStatus = "pending" | "approved" | "rejected" | "quarantined" | "superseded";
+export type RetrievalMeta = {
+    status: ProposalStatus;
+    quarantined?: boolean;
+    superseded?: boolean;
+    projectId?: string;
+    kind?: KnowledgeKind;
+    tokenCost?: number;
+};
+export type RetrievalScope = {
+    projectId?: string;
+    kinds?: KnowledgeKind[];
+    tokenCap?: number;
+};
+/**
+ * Normative retrieval contract: approved && !quarantined && !superseded &&
+ * projectScope match && kind match && tokenCap.
+ */
+export declare function isRetrievable(meta: RetrievalMeta, scope: RetrievalScope): boolean;
+export type QuarantineOptions = {
+    projectRoot?: string;
+    sourceDir?: string;
+    reason?: string;
+};
+export type QuarantineResult = {
+    quarantined: boolean;
+    slug: string;
+    quarantinePath: string;
+    reason?: string;
+};
+export declare function promotedDirFor(slug: string, projectRoot?: string): string;
+export declare function quarantineDirFor(slug: string, projectRoot?: string): string;
+/** MOVE a promoted skill under `<evolutionDir>/quarantine/<slug>/` and audit it (instead of rm -rf). */
+export declare function quarantineSkill(slug: string, opts?: QuarantineOptions): Promise<QuarantineResult>;
+/** Restore a previously quarantined skill back to the promoted dir. Owned by T6. */
+export declare function restoreFromQuarantine(slug: string, opts?: {
+    projectRoot?: string;
+    destDir?: string;
+}): Promise<boolean>;
+export type SupersedeOptions = {
+    projectRoot?: string;
+    supersededBy: string;
+};
+export type SupersedeResult = {
+    slug: string;
+    supersededBy: string;
+    superseded: boolean;
+};
+/** Point an old artifact at its live head. Updates meta atomically, audits, never unlinks. */
+export declare function supersedeSkill(slug: string, opts: SupersedeOptions): Promise<SupersedeResult>;

package/dist/features/evolution/store/project-identity.d.ts

@@ -0,0 +1,27 @@
+import { type DistilledKnowledge, UNSCOPED_LEGACY } from "../types";
+export { UNSCOPED_LEGACY };
+export type ProjectIdentity = {
+    projectId: string;
+    root: string;
+    remote?: string;
+};
+/** Injectable git runner: returns trimmed stdout, or null when the command fails. */
+export type GitRunner = (args: string[], cwd: string) => string | null;
+/** Normalize a missing/empty project id to the unscoped sentinel. Pure. */
+export declare function normalizeProjectId(projectId: string | undefined): string;
+/** Lowercase, trim, collapse runs of non-alphanumerics to a single dash. Pure. */
+export declare function normalizeTitle(title: string): string;
+/** Drop the memoized identities (test hook + explicit invalidation). */
+export declare function clearProjectIdentityCache(): void;
+/** Short, stable project suffix used to disambiguate cross-project slugs. Pure. */
+export declare function projectSlugSuffix(projectId: string): string;
+/**
+ * Resolve the git identity for a project root. The id is `sha256:<hex>` of the
+ * git remote URL when one exists, otherwise of the canonical repo-root path.
+ * Results are memoized per canonical root: a second resolve for the same root
+ * spawns no git. `remote` is returned for in-memory use only — callers MUST NOT
+ * persist or log it.
+ */
+export declare function resolveProjectIdentity(root: string, runner?: GitRunner): ProjectIdentity;
+/** Scoped dedup key: projectId + kind + normalized title. Owned by T5. */
+export declare function dedupKey(identity: ProjectIdentity, knowledge: DistilledKnowledge): string;

package/dist/features/evolution/store/query.d.ts

@@ -0,0 +1,23 @@
+import { type RetrievalMeta, type RetrievalScope } from "./lifecycle";
+/** Appended when `get_context` output is cut at the char cap. */
+export declare const CONTEXT_TRUNCATION_MARKER = "\n...[context truncated]";
+/** One read-only retrieval candidate: normalized meta + searchable body. */
+export type RetrievalRecord = {
+    id: string;
+    meta: RetrievalMeta;
+    text: string;
+};
+/**
+ * Enumerate retrieval candidates from the staged skill store and the pending
+ * queue. Staged entries win on slug collisions. Read-only; missing dirs → [].
+ */
+export declare function readRetrievalRecords(projectRoot: string): RetrievalRecord[];
+export type SearchOptions = {
+    /** Case-insensitive substring match against id + body. Absent matches all. */
+    query?: string;
+    scope: RetrievalScope;
+};
+/** Filter records through the T4a predicate, then narrow by text match. */
+export declare function searchRecords(records: RetrievalRecord[], options: SearchOptions): RetrievalRecord[];
+/** Cut text at `cap` chars, appending the marker only when truncation happens. */
+export declare function truncateContext(text: string, cap: number): string;

package/dist/features/evolution/{store.d.ts → store/trace-store.d.ts}

@@ -1,4 +1,4 @@
-import type { EvolutionState, TraceRecord } from "./types";
+import type { EvolutionState, TraceRecord } from "../types";
 export declare const EVOLUTION_DIR = ".matrixx/evolution";
 export declare const TRACES_DIR = ".matrixx/evolution/traces";
 export declare const DISTILLED_DIR = ".matrixx/evolution/distilled";

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

@@ -12,6 +12,9 @@ export type TraceRecord = {
     errorType?: string;
     model?: string;
 };
+export type KnowledgeKind = "workflow" | "correction" | "debugging_pattern" | "gotcha" | "convention";
+/** Project scope used when git identity is unknown (T4a contract; populated by T5). */
+export declare const UNSCOPED_LEGACY = "unscoped-legacy";
 export type DistilledKnowledge = {
     title: string;
     summary: string;
@@ -21,6 +24,27 @@ export type DistilledKnowledge = {
     skillDraft?: string;
     confidence: number;
     sourceSessionIDs: string[];
+    kind: KnowledgeKind;
+    /** Git-derived project scope; absent normalizes to UNSCOPED_LEGACY. Populated by T5. */
+    projectId?: string;
+    /** Trace ids backing this distillation; absent defaults to []. */
+    sourceTraceIDs: string[];
+    /** ISO timestamp of distillation; absent is back-filled at parse time. */
+    distilledAt: string;
+};
+export type CompressionUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    costCents: number;
+};
+/**
+ * Cost/usage channel (T4a): `compress()` resolves to `{ knowledge, usage? }` with
+ * `usage = { inputTokens, outputTokens, costCents }`. T1 emits it, T3 (budget-ledger)
+ * consumes it, T8 provenance cites it. No separate store-appended ledger event.
+ */
+export type CompressResult = {
+    knowledge: DistilledKnowledge;
+    usage?: CompressionUsage;
 };
 export type CompressionInput = {
     sessionID: string;
@@ -31,7 +55,7 @@ export type CompressionInput = {
     taskHistory?: unknown[];
 };
 export interface Compressor {
-    compress(input: CompressionInput): Promise<DistilledKnowledge>;
+    compress(input: CompressionInput): Promise<CompressResult>;
 }
 export type EvolutionState = {
     totalTraces: number;
@@ -45,7 +69,16 @@ export type SkillMeta = {
     derived_from: string[];
     created_at: string;
     confidence: number;
+    kind?: KnowledgeKind;
+    /** Git-derived project scope; absent/failing back-compat normalizes to unscoped. */
+    projectId?: string;
     eval_score?: number | null;
     tags?: string[];
     prerequisites?: string[];
+    /** Live-head pointer set on an old artifact when a later re-distill replaces it. */
+    superseded_by?: string;
+    /** Canonical title slug shared across a supersede chain (old + new coexist). */
+    base_slug?: string;
+    /** Content hash used to detect byte-identical re-distills (idempotent suppression). */
+    content_hash?: string;
 };

package/dist/features/evolution/writer-emit.d.ts

@@ -0,0 +1,17 @@
+import type { DistilledKnowledge, KnowledgeKind } from "./types";
+export declare function slugify(title: string): string;
+export type EmitInput = {
+    pendingDir: string;
+    skillsDir: string;
+    slug: string;
+    knowledge: DistilledKnowledge;
+    projectId: string;
+    kind: KnowledgeKind;
+    contentHash: string;
+    baseSlug: string;
+};
+export declare function emitArtifact(input: EmitInput): Promise<{
+    slug: string;
+    pendingPath: string;
+    metaPath: string;
+}>;

package/dist/features/evolution/writer-frontmatter.d.ts

@@ -0,0 +1,23 @@
+import { type KnowledgeKind, type SkillMeta } from "./types";
+/**
+ * Provenance (T8) is the evidence trail behind a generated skill: which
+ * sessions and trace rows it was distilled from, and when. It is emitted both
+ * as SKILL.md YAML frontmatter and mirrored into meta.json.
+ */
+export type ProvenanceMeta = SkillMeta & {
+    session_ids: string[];
+    trace_ids: string[];
+    distilled_at: string;
+};
+export type Provenance = {
+    session_ids: string[];
+    trace_ids: string[];
+    project_id: string;
+    kind: KnowledgeKind;
+    confidence: number;
+    distilled_at: string;
+};
+/** Legacy artifacts predate provenance; loading them must never throw. */
+export declare function hasProvenance(meta: unknown): boolean;
+export declare function provenanceOf(meta: ProvenanceMeta): Provenance;
+export declare function toFrontmatter(meta: ProvenanceMeta): string;

package/dist/features/evolution/writer-supersede.d.ts

@@ -0,0 +1,20 @@
+import type { DistilledKnowledge, KnowledgeKind, SkillMeta } from "./types";
+export type SupersedeKey = {
+    baseSlug: string;
+    projectId: string;
+    kind: KnowledgeKind;
+};
+/** Stable hash of the distillable payload, ignoring volatile timestamps/provenance. */
+export declare function contentHashFor(knowledge: DistilledKnowledge): string;
+/** Distinct, deterministic slug for a chain entry so old and new coexist on disk. */
+export declare function chainSlug(baseSlug: string, contentHash: string): string;
+/** Return `desired`, or the first free `desired-N` when it is already taken. */
+export declare function uniqueSlug(taken: ReadonlySet<string>, desired: string): string;
+/** Read every pending `*.meta.json`; malformed files are skipped, missing dirs yield []. */
+export declare function listPendingMetas(pendingDir: string): SkillMeta[];
+/** Whether a meta shares the (projectId, kind, normalized title) key of a candidate. */
+export declare function knowledgeKeyMatches(meta: SkillMeta, key: SupersedeKey): boolean;
+/** The live artifact for a key: newest matching meta without `superseded_by`. */
+export declare function findLiveHead(metas: SkillMeta[], key: SupersedeKey): SkillMeta | null;
+/** Follow `superseded_by` from `startSlug` to the chain end; fail-open on breaks/cycles. */
+export declare function resolveHeadSlug(metas: SkillMeta[], startSlug: string): string;

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

@@ -5,11 +5,15 @@ export declare class EvolutionWriter {
     private skillsDir;
     private promotedBase;
     private globalBase?;
+    private projectRoot;
     constructor(config: EvolutionWriterConfig, projectRoot?: string);
+    private readMeta;
+    private emit;
     stage(knowledge: DistilledKnowledge): Promise<{
         slug: string;
         pendingPath: string;
         metaPath: string;
+        deduped?: boolean;
     }>;
     promote(slug: string): Promise<{
         promotedPath: string;

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/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,8 +24,6 @@ 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";

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

@@ -1,11 +1,6 @@
 export declare const HOOK_NAME = "task-continuation-enforcer";
 export declare const DEFAULT_SKIP_AGENTS: string[];
-export declare const EXPLORER_AGENTS: string[];
-export declare function hasNonExplorerBgTasks(tasks: Array<{
-    agent?: string;
-}>): boolean;
 export declare const CONTINUATION_PROMPT: string;
-export declare const BOOTSTRAP_PROMPT: string;
 export declare const COUNTDOWN_SECONDS = 2;
 export declare const TOAST_DURATION_MS = 900;
 export declare const COUNTDOWN_GRACE_PERIOD_MS = 500;