opencode-matrixx-v2 0.0.0-stage → 1.0.0

package/dist/tools/plan/section-read.d.ts

@@ -0,0 +1,24 @@
+import type { PlanReadFormat } from "./types";
+type SectionOutcome = {
+    kind: "error";
+    body: Record<string, unknown>;
+} | {
+    kind: "ok";
+    body: Record<string, unknown>;
+};
+export interface SectionReadRequest {
+    filePath: string;
+    content: string;
+    lines: string[];
+    format: PlanReadFormat;
+    selector: string;
+    sectionIndex: number | undefined;
+    /** True when `offset`/`limit` were also supplied — reported as `precedence`. */
+    paginated: boolean;
+}
+/**
+ * Build the `plan_read` response for a section read. Returns a JSON-ready object
+ * so the caller keeps a single stringify site.
+ */
+export declare function readSection(request: SectionReadRequest): SectionOutcome;
+export {};

package/dist/tools/plan/status-transition.d.ts

@@ -0,0 +1,47 @@
+import { type PlanErrorCode } from "./error-codes";
+/**
+ * Explicit human override for a backward plan-status jump.
+ *
+ * SINGLE definition site for the force-completion contract: Tasks 2 and 3
+ * import this type rather than redeclaring it. Structurally identical to
+ * `PlanStatusTransitionOptions` in `plan-contract/schema.ts`, so it passes
+ * straight through to `isPlanStatusTransitionAllowed`.
+ */
+export interface ForceCompletionOptions {
+    /** When true, a backward jump is honored instead of rejected. */
+    forceCompletion?: boolean;
+}
+/** Intended plan-status change extracted from a proposed edit. */
+export interface PlanStatusTransition {
+    /** Authoritative status before the edit. */
+    from: string;
+    /** Authoritative status after the edit. */
+    to: string;
+}
+/** Verdict of `adjudicate`: allow carries no payload, reject names the code. */
+export type StatusAdjudication = {
+    allowed: true;
+} | {
+    allowed: false;
+    error: PlanErrorCode;
+    from: string;
+    to: string;
+};
+/**
+ * Extract the intended plan-status transition between two plan contents.
+ *
+ * Parses the leading front-matter block of each side (body text is never
+ * scanned, so status words in prose are ignored) and returns the before/after
+ * pair when the status differs. Returns null when there is no transition:
+ * identical statuses, or either side missing/unparseable front-matter.
+ */
+export declare function extractStatusEdit(currentContent: string, nextContent: string): PlanStatusTransition | null;
+/**
+ * Allow or reject an extracted plan-status transition.
+ *
+ * A null transition (no status change) always allows. Otherwise the verdict
+ * delegates to `isPlanStatusTransitionAllowed`: forward or same-status jumps
+ * pass, backward jumps reject with `status_transition_rejected` unless
+ * `{ forceCompletion: true }` is supplied.
+ */
+export declare function adjudicate(transition: PlanStatusTransition | null, options?: ForceCompletionOptions): StatusAdjudication;

package/dist/tools/plan/types.d.ts

@@ -0,0 +1,56 @@
+import type { RawHashlineEdit } from "../hashline-edit/normalize-edits";
+export declare function resolveDirectory(context: unknown, ctx: unknown): string;
+export declare function validatePlanFilePath(filePath: string, directory: string): {
+    resolved: string;
+} | {
+    error: string;
+};
+export interface PlanCreateArgs {
+    filePath: string;
+    content: string;
+}
+export type PlanReadFormat = "hashline" | "content";
+export interface PlanOutlineEntry {
+    level: 2 | 3;
+    text: string;
+    line: number;
+    anchor: string;
+}
+/**
+ * One row of the byte-accounted section index (see `section-index.ts`).
+ * `endLine` is EXCLUSIVE — the section owns `[startLine, endLine)`.
+ */
+export interface PlanSectionIndexEntry {
+    /** Kebab-case id, `normalizeSectionKey(headingText)`. */
+    id: string;
+    level: 2 | 3;
+    /** Heading text exactly as it appears in the plan. */
+    headingText: string;
+    startLine: number;
+    /** Exclusive: next heading of level <= this one, else lines.length + 1. */
+    endLine: number;
+    /** UTF-8 byte length of the section's original text span (single byte ruler). */
+    bytes: number;
+    /** 64-bit position-sensitive hash over `id + startLine + span text`. */
+    contentHash: string;
+}
+export interface PlanReadArgs {
+    filePath: string;
+    format?: PlanReadFormat;
+    offset?: number;
+    limit?: number;
+}
+export interface PlanUpdateArgs {
+    filePath: string;
+    edits: RawHashlineEdit[];
+}
+export interface PlanDeleteArgs {
+    filePath: string;
+}
+export interface PlanInfo {
+    fileName: string;
+    filePath: string;
+    mtime: string;
+    mtimeMs: number;
+    size: number;
+}

package/dist/tools/preset/tools.d.ts

@@ -0,0 +1,7 @@
+import type { MatrixxConfig } from "../../config";
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+export interface PresetToolOptions {
+    pluginConfig?: MatrixxConfig;
+    directory?: string;
+}
+export declare function createPresetTool(options?: PresetToolOptions): Record<string, MatrixxToolDefinition>;

package/dist/tools/session-cleanup/index.d.ts

@@ -0,0 +1,13 @@
+import type { SessionDomainLike } from "../../shared/session-facade";
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+type SessionCleanupSession = SessionDomainLike & {
+    remove?(input: {
+        sessionID: string;
+    }): Promise<unknown>;
+};
+type SessionCleanupContext = {
+    session: SessionCleanupSession;
+};
+export declare const SESSION_CLEANUP_DESCRIPTION = "Delete leaked Matrixx-created sessions from the OpenCode session list.\n\nOlder Matrixx versions created a real top-level session (no parentID) on every\nevolution-compressor run and never deleted it, so the TUI session list filled up\nwith dozens of \"evolution-compressor\" entries. This tool removes them.\n\nSafety rules:\n- Dry run by default. Nothing is deleted unless you pass apply=true.\n- ONLY parentless sessions are touched. A session that has a parentID is already\n  hidden from the TUI list, so it is never a candidate.\n- Only titles matching known Matrixx patterns are considered. Your own sessions\n  (including \"Pickup ...\") are never touched.\n- include_look_at is opt-in and off by default.";
+export declare function createSessionCleanupTool(ctx: SessionCleanupContext): MatrixxToolDefinition;
+export {};

package/dist/tools/session-manager/constants.d.ts

@@ -0,0 +1,9 @@
+export { MESSAGE_STORAGE, OPENCODE_STORAGE, PART_STORAGE, SESSION_STORAGE } from "../../shared";
+export declare const TODO_DIR: string;
+export declare const TRANSCRIPT_DIR: string;
+export declare const SESSION_LIST_DESCRIPTION = "List all OpenCode sessions with optional filtering.\n\nReturns a list of available session IDs with metadata including message count, date range, and agents used.\n\nArguments:\n- limit (optional): Maximum number of sessions to return\n- from_date (optional): Filter sessions from this date (ISO 8601 format)\n- to_date (optional): Filter sessions until this date (ISO 8601 format)\n\nExample output:\n| Session ID | Messages | First | Last | Agents |\n|------------|----------|-------|------|--------|\n| ses_abc123 | 45 | 2025-12-20 | 2025-12-24 | build, oracle |\n| ses_def456 | 12 | 2025-12-19 | 2025-12-19 | build |";
+export declare const SESSION_READ_DESCRIPTION = "Read messages and history from an OpenCode session.\n\nReturns a formatted view of session messages with role, timestamp, and content. Optionally includes task state and transcript data.\n\nArguments:\n- session_id (required): Session ID to read\n- include_todos (optional): Include the session's task state from the task store if available (default: false). Every task attributed to the session is listed, including one that has been untouched long enough to be stale, so an unfinished item is never hidden from this diagnostic.\n- include_transcript (optional): Include transcript log if available (default: false)\n- limit (optional): Maximum number of messages to return (default: all)\n\nExample output:\nSession: ses_abc123\nMessages: 45\nDate Range: 2025-12-20 to 2025-12-24\n\n[Message 1] user (2025-12-20 10:30:00)\nHello, can you help me with...\n\n[Message 2] assistant (2025-12-20 10:30:15)\nOf course! Let me help you with...";
+export declare const SESSION_SEARCH_DESCRIPTION = "Search for content within OpenCode session messages.\n\nPerforms full-text search across session messages and returns matching excerpts with context.\n\nArguments:\n- query (required): Search query string\n- session_id (optional): Search within specific session only (default: all sessions)\n- case_sensitive (optional): Case-sensitive search (default: false)\n- limit (optional): Maximum number of results to return (default: 20)\n\nExample output:\nFound 3 matches across 2 sessions:\n\n[ses_abc123] Message msg_001 (user)\n...implement the **session manager** tool...\n\n[ses_abc123] Message msg_005 (assistant)\n...I'll create a **session manager** with full search...\n\n[ses_def456] Message msg_012 (user)\n...use the **session manager** to find...";
+export declare const SESSION_INFO_DESCRIPTION = "Get metadata and statistics about an OpenCode session.\n\nReturns detailed information about a session including message count, date range, agents used, and available data sources.\n\nArguments:\n- session_id (required): Session ID to inspect\n\nExample output:\nSession ID: ses_abc123\nMessages: 45\nDate Range: 2025-12-20 10:30:00 to 2025-12-24 15:45:30\nDuration: 4 days, 5 hours\nAgents Used: build, oracle, librarian\nHas Todos: Yes (12 items, 8 completed)\nHas Transcript: Yes (234 entries)";
+export declare const SESSION_DELETE_DESCRIPTION = "Delete an OpenCode session and all associated data.\n\nRemoves session messages, parts, todos, and transcript. This operation cannot be undone.\n\nArguments:\n- session_id (required): Session ID to delete\n- confirm (required): Must be true to confirm deletion\n\nExample:\nsession_delete(session_id=\"ses_abc123\", confirm=true)\nSuccessfully deleted session ses_abc123";
+export declare const TOOL_NAME_PREFIX = "session_";

package/dist/tools/session-manager/path-normalize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Normalize a directory for string comparison. Resolves symlinks via
+ * `realpathSync` (guarded: falls back to lexical normalize for missing
+ * paths), resolves relative paths against cwd, strips one trailing slash
+ * except for the filesystem root. Never throws.
+ */
+export declare function normalizeDirForCompare(dir: string): string;

package/dist/tools/session-manager/session-formatter.d.ts

@@ -0,0 +1,11 @@
+import type { SearchResult, SessionInfo, SessionMessage } from "./types";
+export declare function formatSessionList(sessionIDs: string[]): Promise<string>;
+export declare function formatSessionMessages(messages: SessionMessage[], includeTodos?: boolean, todos?: Array<{
+    id?: string;
+    content: string;
+    status: string;
+}>): string;
+export declare function formatSessionInfo(info: SessionInfo): string;
+export declare function formatSearchResults(results: SearchResult[]): string;
+export declare function filterSessionsByDate(sessionIDs: string[], fromDate?: string, toDate?: string): Promise<string[]>;
+export declare function searchInSession(sessionID: string, query: string, caseSensitive?: boolean, maxResults?: number): Promise<SearchResult[]>;

package/dist/tools/session-manager/storage.d.ts

@@ -0,0 +1,61 @@
+import type { MatrixxConfig } from "../../config/schema";
+import { type SessionContextCarrier } from "../../shared/session-context-source";
+import type { SessionDomainLike } from "../../shared/session-facade";
+import type { SessionInfo, SessionMessage, SessionMetadata, TodoItem } from "./types";
+interface GetMainSessionsOptions {
+    directory?: string;
+}
+export declare function setStorageClient(carrier: SessionContextCarrier & {
+    session: SessionDomainLike;
+}): void;
+export declare function resetStorageClient(): void;
+/**
+ * Thread `ctx.directory` into the storage layer. `createSessionManagerTools` is the
+ * single construction point of this module, so the directory is held in a module
+ * setter for the same reason the SDK client is: `getSessionInfo` is a second
+ * consumer of the task read and has no directory of its own, so an explicit
+ * parameter would have to be threaded through both public signatures. Passing no
+ * directory makes the task store resolve to its global default, matching
+ * `getTaskDir`'s own contract when `directory` is omitted; this function needs a
+ * concrete string, so an unset directory falls back to `process.cwd()` exactly as
+ * `getTaskDir` does for a relative `storage_path`.
+ */
+export declare function setStorageDirectory(directory: string | undefined): void;
+/**
+ * Thread the plugin config into the task read, for the same reason as the directory:
+ * `getSessionInfo` is a second consumer of `readSessionTodos` and carries neither a
+ * config nor a directory of its own. Without it the read always resolves the
+ * `process.cwd()`-relative project store, which silently returns nothing for a user
+ * who configured `tasks.storage_path` or `tasks.scope: "global"` — the `include_todos`
+ * diagnostic would be permanently empty for exactly those users.
+ */
+export declare function setStorageConfig(config: Partial<MatrixxConfig> | undefined): void;
+export declare function getMainSessions(options: GetMainSessionsOptions): Promise<SessionMetadata[]>;
+export declare function getAllSessions(): Promise<string[]>;
+export { getMessageDir } from "../../shared/opencode-message-dir";
+export declare function sessionExists(sessionID: string): Promise<boolean>;
+export declare function readSessionMessages(sessionID: string): Promise<SessionMessage[]>;
+/**
+ * Read the file-backed task store for one session. Replaces the legacy read of
+ * OpenCode's own todo state, which had two branches: the SDK endpoint and a "stable
+ * mode" scan of OpenCode's on-disk todo directory. Both are gone.
+ *
+ * There is deliberately no `isSqliteBackend()` split here, unlike the message and
+ * session readers in this file. That distinction exists because those endpoints
+ * differ per backend; the task store is a plugin-owned local directory, so it is
+ * backend-independent and one read covers both. Do not "restore" the branch.
+ *
+ * Fails open via `readSessionTasks`: a missing store or an unreadable file yields
+ * `[]` rather than throwing, matching the contract of the reads it replaces.
+ *
+ * `excludeStale: false` is an explicit local opt-out, not a change of default.
+ * `SessionTaskQuery.excludeStale` stays `true` so a completion gate cannot leak a
+ * pending handle forever; that bound belongs to the gates, not to this read. This
+ * is the `include_todos` / `SessionInfo.todos` diagnostic, and the native list it
+ * replaced applied no staleness filter at all, so inheriting the default silently
+ * dropped an untouched-but-unfinished task from the view a user inspects when
+ * asking "what is this session carrying?" — which is why a session could report
+ * `has_todos: true` and render an empty list.
+ */
+export declare function readSessionTodos(sessionID: string): Promise<TodoItem[]>;
+export declare function getSessionInfo(sessionID: string): Promise<SessionInfo | null>;

package/dist/tools/session-manager/tools.d.ts

@@ -0,0 +1,4 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { NativePluginContext } from "../../shared/session-context-source";
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+export declare function createSessionManagerTools(ctx: NativePluginContext, pluginConfig?: Partial<MatrixxConfig>): Record<string, MatrixxToolDefinition>;

package/dist/tools/session-manager/types.d.ts

@@ -0,0 +1,86 @@
+export interface SessionMessage {
+    id: string;
+    role: "user" | "assistant";
+    agent?: string;
+    time?: {
+        created: number;
+        updated?: number;
+    };
+    content: MessagePart[];
+}
+export interface MessagePart {
+    id: string;
+    type: string;
+    text?: string;
+    thinking?: string;
+    tool?: string;
+    callID?: string;
+    input?: Record<string, unknown>;
+    output?: string;
+    error?: string;
+}
+export interface SessionInfo {
+    id: string;
+    message_count: number;
+    first_message?: Date;
+    last_message?: Date;
+    agents_used: string[];
+    has_todos: boolean;
+    has_transcript: boolean;
+    todos?: TodoItem[];
+    transcript_entries?: number;
+}
+export interface TodoItem {
+    id?: string;
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+    priority?: string;
+}
+export interface SearchResult {
+    session_id: string;
+    message_id: string;
+    role: string;
+    excerpt: string;
+    match_count: number;
+    timestamp?: number;
+}
+export interface SessionMetadata {
+    id: string;
+    version?: string;
+    projectID: string;
+    directory: string;
+    title?: string;
+    parentID?: string;
+    isChild?: boolean;
+    time: {
+        created: number;
+        updated: number;
+    };
+    summary?: {
+        additions: number;
+        deletions: number;
+        files: number;
+    };
+}
+export interface SessionListArgs {
+    limit?: number;
+    offset?: number;
+    from_date?: string;
+    to_date?: string;
+    project_path?: string;
+}
+export interface SessionReadArgs {
+    session_id: string;
+    include_todos?: boolean;
+    include_transcript?: boolean;
+    limit?: number;
+}
+export interface SessionSearchArgs {
+    query: string;
+    session_id?: string;
+    case_sensitive?: boolean;
+    limit?: number;
+}
+export interface SessionInfoArgs {
+    session_id: string;
+}

package/dist/tools/shared/define-tool.d.ts

@@ -0,0 +1,78 @@
+import type { ZodType } from "zod";
+import { z } from "zod";
+import type { V2ToolContext, V2ToolInfo, V2ToolResult } from "../../plugin/context";
+/** Tool execution result: a plain string or a structured payload. */
+export type MatrixxToolResult = string | {
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+    title?: string;
+};
+/** Context passed to every Matrixx tool execute function. */
+export interface MatrixxToolContext {
+    readonly sessionID: string;
+    readonly messageID: string;
+    readonly agent: string;
+    readonly callID?: string;
+    readonly directory: string;
+    readonly worktree: string;
+    readonly abort: AbortSignal;
+    metadata(input: {
+        title?: string;
+        metadata?: Record<string, unknown>;
+    }): void;
+    ask(input: Record<string, unknown>): Promise<void>;
+}
+/**
+ * The single tool authoring shape for matrixx tools.
+ *
+ * `TArgs` is a Zod raw shape (a plain object mapping names to Zod schemas),
+ * converted to plain JSON Schema at registration time via
+ * `z.toJSONSchema(z.object(args), { io: "input" })`.
+ */
+export interface MatrixxToolDefinition<TArgs extends Record<string, ZodType> = Record<string, ZodType>> {
+    description: string;
+    args: TArgs;
+    execute(args: z.infer<z.ZodObject<TArgs>>, ctx: MatrixxToolContext): Promise<MatrixxToolResult>;
+    options?: {
+        codemode?: boolean;
+    };
+}
+export type DefinedTool<TArgs extends Record<string, ZodType> = Record<string, ZodType>> = MatrixxToolDefinition<TArgs> & {
+    name: string;
+};
+/**
+ * The only tool authoring entry point. Validates eagerly so a malformed
+ * definition fails fast with an explicit error instead of registering a
+ * silently undefined schema.
+ */
+export declare function defineTool<TArgs extends Record<string, ZodType>>(name: string, def: MatrixxToolDefinition<TArgs>): DefinedTool<TArgs>;
+/** Convert a Zod raw shape to plain JSON Schema (no Zod instances survive). */
+export declare function toInputSchema(name: string, args: unknown): Record<string, unknown>;
+/** Normalize a tool result, routing metadata through jsonSafeMetadata.
+ *
+ * Every result carries BOTH channels: `content` (rendered message parts) and
+ * `output` (the hook-visible result and declared tool output). The host hook
+ * layer only forwards `output` to tool.execute.after hooks and derives the
+ * final message from it — a content-only result arrives as an empty string
+ * downstream (observed live as the empty task response).
+ */
+export declare function normalizeResult(result: unknown): V2ToolResult;
+/** Build the Matrixx tool context from a V2 tool context and bridge deps. */
+export declare function buildMatrixxToolContext(context: V2ToolContext, deps: {
+    directory: string;
+    worktree: string;
+    assertPermission?: (input: Record<string, unknown>) => Promise<void>;
+}): MatrixxToolContext;
+/**
+ * Deps needed to bridge a Matrixx tool definition onto the V2 tool registry.
+ * Relocated verbatim from the deleted `src/plugin/opencode-tools.ts` (task 24)
+ * so the V2 `Tool.Info` translation survives and R1 still holds.
+ */
+export interface ToolBridgeDeps {
+    directory: string;
+    worktree: string;
+    assertPermission?: (input: Record<string, unknown>) => Promise<void>;
+    context?: unknown;
+}
+export declare function emitToolInfo(name: string, definition: MatrixxToolDefinition, deps: ToolBridgeDeps): V2ToolInfo | undefined;
+export declare function emitToolInfos(tools: Record<string, MatrixxToolDefinition>, deps: ToolBridgeDeps): V2ToolInfo[];

package/dist/tools/silent-failure-scanner/constants.d.ts

@@ -0,0 +1,10 @@
+import type { ScanSeverity } from "./types";
+export declare const SILENT_FAILURE_SCAN_DESCRIPTION = "Scan Python and TypeScript/JavaScript source for silent-failure anti-patterns \u2014 code paths that turn a real error into a plausible-looking normal result. Read-only and deterministic; returns a JSON report with a status exit code (0=clean, 1=warnings, 2=errors).\n\nRules:\n- SF001 bare `except:` or an `except` whose body is only `pass` (also empty TS `catch {}`).\n- SF002 an `except`/catch that logs a warning and then returns a default value indistinguishable from a real outcome.\n- SF003 `asyncio.gather(...)` without `return_exceptions=True`.\n- SF004 results from `gather(return_exceptions=True)` indexed without per-result `isinstance` inspection.\n- SF005 gap-masking flags such as `createEmpty: true`.\n\nDetection is line-oriented with bounded block tracking (documented fallback); no AST dependency. Use `severity` to filter the report to a minimum severity (\"warn\" reports warnings and errors; \"error\" reports errors only).\n\nWaivers: pass `waivers` (project-relative or absolute path to a COMMITTED waiver JSON file \u2014 never under gitignored `.matrixx/`) shaped `{version:1,waivers:[{rule,file,symbol,reason,reviewedAt,owner?}]}`. The match key is rule+file+enclosing-symbol (never line numbers); matched findings are excluded from the status but reported in `waived`. Entries matching nothing appear in `staleWaivers` and force status to at least 1.";
+export declare const DEFAULT_GLOBS: string[];
+export declare const IGNORED_DIRS: Set<string>;
+export declare const RULE_CATALOG: Record<string, {
+    severity: ScanSeverity;
+    why: string;
+    fix: string;
+}>;
+export declare const SEVERITY_RANK: Record<ScanSeverity, number>;

package/dist/tools/silent-failure-scanner/index.d.ts

@@ -0,0 +1,4 @@
+export { DEFAULT_GLOBS, RULE_CATALOG, SILENT_FAILURE_SCAN_DESCRIPTION } from "./constants";
+export { scanPath } from "./scanner";
+export { createSilentFailureScannerTool } from "./tools";
+export type { ScanSeverity, SilentFailureFinding, SilentFailureScanResult, SilentFailureSummary, SilentFailureWaiver, SilentFailureWaiverWarning, } from "./types";

package/dist/tools/silent-failure-scanner/scanner.d.ts

@@ -0,0 +1,8 @@
+import type { ScanSeverity, SilentFailureScanResult } from "./types";
+export declare function scanPath(opts: {
+    base: string;
+    target: string;
+    globs?: string[];
+    threshold?: ScanSeverity;
+    waivers?: string;
+}): SilentFailureScanResult;

package/dist/tools/silent-failure-scanner/tools.d.ts

@@ -0,0 +1,3 @@
+import type { MatrixxContext } from "../../plugin/context";
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+export declare function createSilentFailureScannerTool(ctx: MatrixxContext): Record<string, MatrixxToolDefinition>;

package/dist/tools/silent-failure-scanner/types.d.ts

@@ -0,0 +1,43 @@
+export type ScanSeverity = "warn" | "error";
+export interface SilentFailureFinding {
+    rule: string;
+    severity: ScanSeverity;
+    file: string;
+    line: number;
+    excerpt: string;
+    why: string;
+    fix: string;
+    symbol: string;
+}
+export interface SilentFailureSummary {
+    filesScanned: number;
+    total: number;
+    errors: number;
+    warnings: number;
+    byRule: Record<string, number>;
+    waived: number;
+    waivedByRule: Record<string, number>;
+    stale: number;
+}
+export interface SilentFailureScanResult {
+    status: 0 | 1 | 2;
+    findings: SilentFailureFinding[];
+    waived: SilentFailureFinding[];
+    summary: SilentFailureSummary;
+    waiverFile?: string;
+    staleWaivers: SilentFailureWaiver[];
+    waiverWarnings: SilentFailureWaiverWarning[];
+}
+export interface SilentFailureWaiver {
+    rule: string;
+    file: string;
+    symbol: string;
+    reason: string;
+    reviewedAt: string;
+    owner?: string;
+}
+export interface SilentFailureWaiverWarning {
+    kind: "stale" | "invalid-entry" | "load-warning";
+    message: string;
+    entry?: unknown;
+}

package/dist/tools/skill/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const TOOL_DESCRIPTION_NO_SKILLS = "Load a skill to get detailed instructions for a specific task. No skills are currently available.";
+export declare const TOOL_DESCRIPTION_PREFIX = "Load a skill to get detailed instructions for a specific task.\n\nSkills provide specialized knowledge and step-by-step guidance.\nUse this when a task matches an available skill's description.";

package/dist/tools/skill/tools.d.ts

@@ -0,0 +1,4 @@
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+import type { SkillLoadOptions } from "./types";
+export declare function createSkillTool(options?: SkillLoadOptions): MatrixxToolDefinition;
+export declare const skill: MatrixxToolDefinition;

package/dist/tools/skill/types.d.ts

@@ -0,0 +1,22 @@
+import type { BuiltinSkill } from "../../skills";
+export interface SkillArgs {
+    name: string;
+}
+export interface SkillInfo {
+    name: string;
+    description: string;
+    location?: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+}
+export interface SkillLoadOptions {
+    /** Pre-merged skills to use instead of discovering */
+    skills?: BuiltinSkill[];
+    /** MCP manager for querying skill-embedded MCP servers */
+    mcpManager?: never;
+    /** Session ID getter for MCP client identification */
+    getSessionID?: () => string;
+    disabledSkills?: Set<string>;
+}

package/dist/tools/slashcommand/command-discovery.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInfo } from "./types";
+export declare function discoverCommandsSync(directory?: string): CommandInfo[];

package/dist/tools/slashcommand/command-output-formatter.d.ts

@@ -0,0 +1,3 @@
+import type { CommandInfo } from "./types";
+export declare function formatLoadedCommand(command: CommandInfo, userMessage?: string): Promise<string>;
+export declare function formatCommandList(items: CommandInfo[]): string;

package/dist/tools/slashcommand/skill-command-converter.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinSkill } from "../../skills";
+import type { CommandInfo } from "./types";
+export declare function skillToCommandInfo(skill: BuiltinSkill): CommandInfo;

package/dist/tools/slashcommand/slashcommand-description.d.ts

@@ -0,0 +1,3 @@
+import type { CommandInfo } from "./types";
+export declare const TOOL_DESCRIPTION_PREFIX = "Load a skill or execute a command to get detailed instructions for a specific task.\n\nSkills and commands provide specialized knowledge and step-by-step guidance.\nUse this when a task matches an available skill's or command's description.\n\n**How to use:**\n- Call with command name only: command='publish'\n- Call with command and arguments: command='publish' user_message='patch'\n- The tool will return detailed instructions for the command with your arguments substituted.\n";
+export declare function buildDescriptionFromItems(items: CommandInfo[]): string;

package/dist/tools/slashcommand/slashcommand-tool.d.ts

@@ -0,0 +1,4 @@
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+import type { SlashcommandToolOptions } from "./types";
+export declare function createSlashcommandTool(options?: SlashcommandToolOptions): MatrixxToolDefinition;
+export declare const slashcommand: MatrixxToolDefinition;

package/dist/tools/slashcommand/tools.d.ts

@@ -0,0 +1,2 @@
+export { discoverCommandsSync } from "./command-discovery";
+export { createSlashcommandTool, slashcommand } from "./slashcommand-tool";

package/dist/tools/slashcommand/types.d.ts

@@ -0,0 +1,46 @@
+import type { BuiltinSkill } from "../../skills";
+export interface LazyContentLoader {
+    loaded: boolean;
+    content?: string;
+    load: () => Promise<string>;
+}
+export type CommandScope = "builtin" | "config" | "user" | "project" | "opencode" | "opencode-project" | "plugin";
+export interface CommandMetadata {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    model?: string;
+    agent?: string;
+    subtask?: boolean;
+}
+export interface CommandInfo {
+    name: string;
+    path?: string;
+    metadata: CommandMetadata;
+    content?: string;
+    scope: CommandScope;
+    lazyContentLoader?: LazyContentLoader;
+}
+export interface PluginCommandEntry {
+    name: string;
+    description?: string;
+    model?: unknown;
+    agent?: string;
+    subtask?: boolean;
+    template?: unknown;
+}
+export interface PluginCommandClient {
+    command: {
+        list(): Promise<{
+            data?: PluginCommandEntry[];
+        }>;
+    };
+}
+export interface SlashcommandToolOptions {
+    /** Pre-loaded commands (skip discovery if provided) */
+    commands?: CommandInfo[];
+    /** Pre-loaded skills (skip discovery if provided) */
+    skills?: BuiltinSkill[];
+    /** Host command client for discovering plugin-registered commands */
+    client?: PluginCommandClient;
+}

package/dist/tools/staleness-gap-checker/checker.d.ts

@@ -0,0 +1,15 @@
+import type { StalenessResult, StalenessSample } from "./types";
+export declare function toMillis(value: number | string | undefined): number | null;
+/**
+ * Validates and normalizes a raw parsed object into a sample, or returns null
+ * when the object does not carry the required shape.
+ */
+export declare function coerceSample(raw: unknown): StalenessSample | null;
+export declare function parseNdjson(text: string): {
+    samples: StalenessSample[];
+    invalid: number;
+};
+export declare function analyzeSamples(samples: StalenessSample[], opts?: {
+    maxGapMultiplier?: number;
+    now?: number;
+}): StalenessResult;

package/dist/tools/staleness-gap-checker/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const STALENESS_GAP_CHECK_DESCRIPTION = "Deterministic, read-only checker for market-data feed health. Given a list of samples (or a newline-delimited JSON log) it detects per-(symbol,exchange) sequence gaps, regressions and duplicates, and classifies staleness (now - exchange_ts vs the expected inter-arrival interval). Returns a JSON report with a status exit code (0=clean, 1=warnings, 2=errors).\n\nStaleness: expected interval is the median positive delta of exchange_ts within a group; state is healthy, warn (> maxGapMultiplier x expected, default 2x), or stale (> 5x expected). \"now\" defaults to the maximum pub_ts across the input (so the check is deterministic without a wall clock); pass \"now\" to override.\n\nProviding neither samples nor logPath fails closed with status 2 rather than a clean pass.";
+export declare const DEFAULT_MAX_GAP_MULTIPLIER = 2;
+export declare const STALE_MULTIPLIER = 5;

package/dist/tools/staleness-gap-checker/index.d.ts

@@ -0,0 +1,4 @@
+export { analyzeSamples, coerceSample, parseNdjson, toMillis } from "./checker";
+export { DEFAULT_MAX_GAP_MULTIPLIER, STALE_MULTIPLIER, STALENESS_GAP_CHECK_DESCRIPTION } from "./constants";
+export { createStalenessGapCheckerTool } from "./tools";
+export type { GapFinding, GapKind, StalenessEntry, StalenessResult, StalenessSample, StalenessState, StalenessSummary, } from "./types";

package/dist/tools/staleness-gap-checker/tools.d.ts

@@ -0,0 +1,3 @@
+import type { MatrixxContext } from "../../plugin/context";
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+export declare function createStalenessGapCheckerTool(ctx: MatrixxContext): Record<string, MatrixxToolDefinition>;