opencode-matrixx-v2 0.0.0-stage → 1.1.0

package/dist/shared/poll-timeout-outcome.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Poll-timeout outcome helper shared by the sync session poller.
+ *
+ * When `pollSyncSession` exhausts `maxPollTimeMs` without observing
+ * completion, the session is still running server-side. This helper turns
+ * that state into a machine-readable, non-throwing outcome string.
+ *
+ * Mirrors the shape of `src/shared/saturated-outcome.ts`
+ * (`formatSaturatedOutcome`): human-readable block plus a trailing
+ * `<task_metadata>{JSON}</task_metadata>` line for programmatic parsing.
+ */
+export declare const POLL_TIMEOUT_PREFIX = "Poll timeout reached";
+export declare const LAST_ASSISTANT_TEXT_CAP = 2000;
+export interface PollTimeoutOutcomeArgs {
+    sessionID: string;
+    agentToUse: string;
+    maxPollTimeMs: number;
+    lastAssistantText?: string;
+}
+export declare function formatPollTimeoutOutcome(args: PollTimeoutOutcomeArgs): string;
+export declare function isPollTimeoutOutcome(text: string): boolean;

package/dist/shared/port-utils.d.ts

@@ -0,0 +1,9 @@
+declare const DEFAULT_SERVER_PORT = 4096;
+export declare function isPortAvailable(port: number, hostname?: string): Promise<boolean>;
+export declare function findAvailablePort(startPort?: number, hostname?: string): Promise<number>;
+interface AutoPortResult {
+    port: number;
+    wasAutoSelected: boolean;
+}
+export declare function getAvailableServerPort(preferredPort?: number, hostname?: string): Promise<AutoPortResult>;
+export { DEFAULT_SERVER_PORT };

package/dist/shared/record-type-guard.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/shared/revive-outcome.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Revive-outcome helpers shared by the background task revive tools.
+ *
+ * A revive either produces a fresh session for a terminal task or is refused
+ * with a machine-readable reason. These helpers turn either case into a
+ * human-readable, non-throwing outcome for the revive tools.
+ *
+ * The status and reason are typed as `string` on purpose: this module lives
+ * in `src/shared` and must not depend on `BackgroundTaskStatus`
+ * or `ReviveBlockReason` from the background-agent feature.
+ */
+export declare const UNREVIVABLE_REASONS: readonly ["active", "uncertain", "no-session", "unknown-task", "expired"];
+export declare function isUnrevivableReason(reason: string): boolean;
+export declare function formatReviveOutcome(taskId: string, sessionID: string, status: string): string;
+export declare function formatUnrevivable(taskId: string, reason: string, detail?: string): string;

package/dist/shared/rtk-enforcement.d.ts

@@ -0,0 +1,18 @@
+import type { RtkConfig } from "../config/schema/rtk";
+export interface RtkEnforcement {
+    enabled: boolean;
+    binaryPresent: boolean;
+    binaryPath: string;
+    active: boolean;
+}
+export interface RtkEnforcementOptions {
+    hookEnabled?: boolean;
+    which?: (binary: string) => string | null;
+}
+/**
+ * Single source of truth for RTK enforcement state.
+ * Both the rtk-bash-rewriter registration gate and the agent prompt
+ * builders (guidance text) derive from this — prompt and hook can never
+ * disagree because they read the same resolved flags.
+ */
+export declare function resolveRtkEnforcement(rtk: RtkConfig | undefined, opts?: RtkEnforcementOptions): RtkEnforcement;

package/dist/shared/safe-create-hook.d.ts

@@ -0,0 +1,6 @@
+interface SafeCreateHookOptions {
+    enabled?: boolean;
+}
+export declare function safeCreateHook<T>(name: string, factory: () => T, options?: SafeCreateHookOptions): T | null;
+export declare function bindSafeHook(safeHookEnabled: boolean): <T>(hookName: string, factory: () => T) => T | null;
+export {};

package/dist/shared/saturated-outcome.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Launch-outcome helpers shared by the background task launch tools.
+ *
+ * A launch can terminate without ever producing a session. T7 made a saturated
+ * queue admission produce a terminal `stopped` task with
+ * `terminalReason: "queue-saturated"` (nested depth-exceeded produces
+ * `terminalReason: "nested-depth-exceeded"`). These helpers turn that terminal
+ * state into a machine-readable, non-throwing outcome for the launch tools.
+ *
+ * The status is typed as `string` on purpose: this module must not import from
+ * `src/features/**`, so it cannot depend on `BackgroundTaskStatus`.
+ */
+export declare const LAUNCH_TERMINAL_STATUSES: readonly ["error", "cancelled", "interrupt", "stopped", "statusUncertain"];
+export type LaunchTerminalStatus = (typeof LAUNCH_TERMINAL_STATUSES)[number];
+export declare function isLaunchTerminalStatus(status: string): status is LaunchTerminalStatus;
+export declare function isQueueSaturated(status: string, terminalReason: string | undefined): boolean;
+export declare function formatSaturatedOutcome(taskId: string): string;
+export declare function formatLaunchFailure(taskId: string, status: string): string;

package/dist/shared/sentinels.d.ts

@@ -0,0 +1,2 @@
+export declare const NOT_CACHED: unique symbol;
+export declare const FALSE_PENDING_RETRY: unique symbol;

package/dist/shared/session-context-source.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Native session-context access for message reads.
+ *
+ * V2's `context()` may answer with either a bare message array or a `{ messages }`
+ * object, so every read goes through `fetchSessionMessages` instead of call sites
+ * guessing the shape. Rejections propagate: callers that degrade on failure keep
+ * their existing `.catch(...)` handling.
+ */
+import type { MatrixxContext } from "../plugin/context";
+import type { SessionDomainLike } from "./session-facade";
+import type { SessionMessage } from "./session-message";
+export type { SessionDomainLike };
+export interface SessionContextDomain {
+    context(input: {
+        sessionID: string;
+    }): Promise<unknown>;
+}
+export type SessionContextCarrier = {
+    session: SessionContextDomain;
+};
+export interface ListDomain {
+    list(): Promise<unknown>;
+}
+export type NativeDomains = {
+    session: SessionDomainLike;
+    agent: ListDomain;
+    model: ListDomain;
+};
+export type NativePluginContext = MatrixxContext & NativeDomains;
+export type NativeContext = {
+    session: SessionContextDomain;
+    agent: ListDomain;
+    model: ListDomain;
+};
+export declare function messagesOf(raw: unknown): SessionMessage[];
+export declare function fetchSessionMessages(carrier: SessionContextCarrier, sessionID: string): Promise<SessionMessage[]>;

package/dist/shared/session-cursor.d.ts

@@ -0,0 +1,9 @@
+type CursorMessage = {
+    id?: string;
+    time?: {
+        created?: number;
+    };
+};
+export declare function consumeNewMessages<T extends CursorMessage>(sessionID: string | undefined, messages: T[]): T[];
+export declare function resetMessageCursor(sessionID?: string): void;
+export {};

package/dist/shared/session-directory-resolver.d.ts

@@ -0,0 +1 @@
+export declare function isWindowsAppDataDirectory(directory: string): boolean;

package/dist/shared/session-facade.d.ts

@@ -0,0 +1,55 @@
+export type FacadeResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+export type SessionPromptBody = Record<string, unknown>;
+export type SessionQuery = Record<string, unknown>;
+export type SessionBody = Record<string, unknown>;
+export type SessionDomainLike = {
+    context(args: {
+        sessionID: string;
+    }): Promise<unknown>;
+    get(args: {
+        sessionID: string;
+    }): Promise<unknown>;
+    list(query?: SessionQuery): Promise<unknown>;
+    create(body?: SessionBody): Promise<unknown>;
+    prompt(args: {
+        sessionID: string;
+    } & SessionPromptBody): Promise<unknown>;
+    interrupt(args: {
+        sessionID: string;
+    }): Promise<unknown>;
+    compact(args: {
+        sessionID: string;
+    }): Promise<unknown>;
+    switchAgent(args: {
+        sessionID: string;
+    } & SessionBody): Promise<unknown>;
+    switchModel(args: {
+        sessionID: string;
+    } & SessionBody): Promise<unknown>;
+    wait(args: {
+        sessionID: string;
+    }): Promise<unknown>;
+};
+export type SessionFacadeDeps = {
+    session: SessionDomainLike;
+};
+export type SessionFacade = {
+    getContext(sessionID: string): Promise<FacadeResult<unknown>>;
+    getSession(sessionID: string): Promise<FacadeResult<unknown>>;
+    listSessions(query?: SessionQuery): Promise<FacadeResult<unknown>>;
+    createSession(body?: SessionBody): Promise<FacadeResult<unknown>>;
+    prompt(sessionID: string, body?: SessionPromptBody): Promise<FacadeResult<unknown>>;
+    promptAsync(sessionID: string, body?: SessionPromptBody): Promise<FacadeResult<true>>;
+    interrupt(sessionID: string): Promise<FacadeResult<unknown>>;
+    compact(sessionID: string): Promise<FacadeResult<unknown>>;
+    switchAgent(sessionID: string, body?: SessionBody): Promise<FacadeResult<unknown>>;
+    switchModel(sessionID: string, body?: SessionBody): Promise<FacadeResult<unknown>>;
+    waitForIdle(sessionID: string): Promise<FacadeResult<unknown>>;
+};
+export declare function createSessionFacade(deps: SessionFacadeDeps): SessionFacade;

package/dist/shared/session-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Native session ID detection.
+ *
+ * OpenCode native sessions carry `ses_` IDs; background handles carry `bg_`
+ * IDs. A `ses_` ID with no bg_ handle attached is a native session, which
+ * can never be revived or polled as a background task.
+ */
+export declare function isNativeSessionId(id: string | undefined): boolean;

package/dist/shared/session-injected-paths.d.ts

@@ -0,0 +1,5 @@
+export declare function createInjectedPathsStorage(storageDir: string): {
+    loadInjectedPaths: (sessionID: string) => Set<string>;
+    saveInjectedPaths: (sessionID: string, paths: Set<string>) => void;
+    clearInjectedPaths: (sessionID: string) => void;
+};

package/dist/shared/session-message.d.ts

@@ -0,0 +1,30 @@
+export type ContentPart = {
+    type?: string;
+    text?: string;
+    [key: string]: unknown;
+};
+export type SessionRole = "user" | "assistant" | "system" | "tool" | "synthetic" | "skill" | "shell" | "compaction" | "idle" | "agent-switched" | "model-switched" | "location-switched" | "unknown";
+export type SessionMessage = {
+    id?: string;
+    type?: string;
+    time?: {
+        created?: number;
+    };
+    text?: string;
+    content?: ReadonlyArray<ContentPart>;
+    finish?: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+    };
+    error?: unknown;
+};
+export declare function roleOf(message: unknown): SessionRole;
+export declare function contentOf(message: unknown): ReadonlyArray<ContentPart>;
+export declare function textOf(message: unknown): string;
+export declare function finishOf(message: unknown): string | undefined;
+export declare function idOf(message: unknown): string | undefined;
+export declare function timeOf(message: unknown): number;
+export declare function isAssistant(message: unknown): boolean;

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

@@ -0,0 +1,15 @@
+export declare function setSessionTemperature(sessionID: string, temperature: number): void;
+export declare function getSessionTemperature(sessionID: string): number | undefined;
+export declare function clearSessionTemperature(sessionID: string): void;
+export declare function setSessionTools(sessionID: string, tools: Record<string, boolean>): void;
+export declare function getSessionTools(sessionID: string): Record<string, boolean> | undefined;
+export declare function clearSessionTools(): void;
+/**
+ * Per-session model tracking.
+ */
+type SessionModel = {
+    providerID: string;
+    modelID: string;
+};
+export declare function getSessionModel(sessionID: string): SessionModel | undefined;
+export {};

package/dist/shared/session-utils.d.ts

@@ -0,0 +1,2 @@
+import type { SessionContextCarrier } from "./session-context-source";
+export declare function isCallerOrchestrator(sessionID?: string, carrier?: SessionContextCarrier): Promise<boolean>;

package/dist/shared/shell-env.d.ts

@@ -0,0 +1,25 @@
+type ShellType = "unix" | "powershell" | "cmd";
+/**
+ * Build environment variable prefix command for the target shell.
+ *
+ * @param env - Record of environment variables to set
+ * @param shellType - The target shell type
+ * @returns Command prefix string to prepend to the actual command
+ *
+ * @example
+ * ```ts
+ * // Unix: "export VAR1=val1 VAR2=val2; command"
+ * buildEnvPrefix({ VAR1: "val1", VAR2: "val2" }, "unix")
+ * // => "export VAR1=val1 VAR2=val2;"
+ *
+ * // PowerShell: "$env:VAR1='val1'; $env:VAR2='val2'; command"
+ * buildEnvPrefix({ VAR1: "val1", VAR2: "val2" }, "powershell")
+ * // => "$env:VAR1='val1'; $env:VAR2='val2';"
+ *
+ * // cmd.exe: "set VAR1=val1 && set VAR2=val2 && command"
+ * buildEnvPrefix({ VAR1: "val1", VAR2: "val2" }, "cmd")
+ * // => "set VAR1=\"val1\" && set VAR2=\"val2\" &&"
+ * ```
+ */
+export declare function buildEnvPrefix(env: Record<string, string>, shellType: ShellType): string;
+export {};

package/dist/shared/shell-tool-name.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Canonical shell/delegation tool-name predicates (OpenCode V2 compat).
+ *
+ * OpenCode V2 renamed the shell tool `bash` -> `shell` (no alias; the
+ * effective name arrives at `tool.execute.before`). V1 configs still list
+ * `bash` in `blocked_tools`, so every gate must accept BOTH spellings.
+ * Centralize the compare here so no gate hardcodes a bare `"bash"` literal.
+ */
+export declare function isShellTool(name: unknown): boolean;
+/**
+ * Delegation-tool predicate (V2 `task` -> `subagent` rename).
+ * Kept as a SEPARATE export — never merge into isShellTool.
+ * `task` is retained as a deprecated alias for V1 callers.
+ */
+export declare function isTaskTool(name: unknown): boolean;

package/dist/shared/skill-path-resolver.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves @path references in skill content to absolute paths.
+ *
+ * Matches @references that contain at least one slash (e.g., @scripts/search.py, @data/)
+ * to avoid false positives with decorators (@param), JSDoc tags (@ts-expect-error), etc.
+ *
+ * Email addresses are excluded since they have alphanumeric characters before @.
+ */
+export declare function resolveSkillPathReferences(content: string, basePath: string): string;

package/dist/shared/software-dev-enforcement/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveSoftwareDevEnforcementContent, type SoftwareDevEnforcementResult, } from "./payload";
+export { isSoftwareDevExecutorTarget, isSoftwareDevOrchestratorTarget, softwareDevDisabledSkillError, } from "./targets";

package/dist/shared/software-dev-enforcement/payload.d.ts

@@ -0,0 +1,29 @@
+import type { BrowserAutomationProvider, SoftwareDevEnforcementConfigInput } from "../../config/schema";
+export interface SoftwareDevEnforcementResult {
+    content: string | undefined;
+    error: string | null;
+}
+/**
+ * Post-resolution software-dev enforcement (spec sections 4-6, Task 4).
+ *
+ * Keyed off the RESOLVED target (`resolution.agentToUse`) + resolved category via
+ * `isCodeWritingCategory()` — never raw `args.category` for target discrimination
+ * (the category path always fans to Mouse; raw category cannot distinguish
+ * orchestrator vs executor).
+ *
+ * Decision table (spec section 4):
+ * - orchestrator target (morpheus/keymaker/niobe/oracle) -> FULL software-dev template.
+ * - Mouse + code-writing category (source) -> SUBSET: missing tdd-enforcer/git-master
+ *   templates only, never full. Caller-present skills dedupe by name.
+ * - anything else -> undefined, no payload.
+ *
+ * Disabled precedence (spec section 8): explicit disabled_skills entry for a
+ * required skill fails closed even when master switch is off or mode is autoAppend;
+ * `enabled=false` exempts everything else; `autoAppend` mode suppresses the
+ * missing-tdd-enforcer throw but never the blocked-skill throw.
+ */
+export declare function resolveSoftwareDevEnforcementContent(agentToUse: string | undefined, resolvedCategory: string | undefined, loadSkills: string[], options?: {
+    enforcement?: SoftwareDevEnforcementConfigInput | null;
+    disabledSkills?: Set<string> | string[];
+    browserProvider?: BrowserAutomationProvider;
+}): SoftwareDevEnforcementResult;

package/dist/shared/software-dev-enforcement/targets.d.ts

@@ -0,0 +1,13 @@
+import { type SoftwareDevEnforcementConfigInput } from "../../config/schema";
+/**
+ * Precedence-aware helpers for software-dev enforcement (spec §8).
+ * Pure derivations over resolved config; no I/O, no prompt mutation.
+ */
+export declare function isSoftwareDevOrchestratorTarget(agentToUse: string | undefined, enforcement?: SoftwareDevEnforcementConfigInput | null): boolean;
+export declare function isSoftwareDevExecutorTarget(agentToUse: string | undefined): boolean;
+/**
+ * Fail-closed error for a required skill blocked by an explicit
+ * disabled_skills entry. Same channel as skill-resolver errors:
+ * returned as a string, never thrown, never silently bypassed.
+ */
+export declare function softwareDevDisabledSkillError(requiredSkill: string): string;

package/dist/shared/state-root.d.ts

@@ -0,0 +1,26 @@
+export declare const MATRIX_STATE_DIR = ".matrixx";
+export type StateRootCandidates = {
+    readonly canonical?: unknown;
+    readonly pluginDirectory?: unknown;
+    readonly contextDirectory?: unknown;
+    readonly cwd?: string;
+};
+/**
+ * A linked git worktree carries `.git` as a file pointing at the main checkout,
+ * while the main checkout carries `.git` as a directory. State under a linked
+ * worktree is per-session and disposable, so it must never be adopted as the
+ * project's state root.
+ */
+export declare function isLinkedWorktree(directory: string): boolean;
+/**
+ * Resolves the directory that owns `.matrixx` state.
+ *
+ * The canonical project root is authoritative and is invariant across
+ * `session_move`, which mutates only the live session directory. A directory
+ * that already holds `.matrixx` is adopted only as a legacy migration path,
+ * and never when it is a linked worktree.
+ */
+export declare function resolveStateRoot(candidates: StateRootCandidates): string;
+export declare function stateRootFromToolContext(context: unknown, ctx: unknown): string;
+export declare function stateRootFromPluginContext(ctx: unknown): string;
+export declare function stateExists(directory: string): boolean;

package/dist/shared/status-types.d.ts

@@ -0,0 +1 @@
+export type TaskStatus = "pending" | "running" | "completed" | "error";

package/dist/shared/system-directive.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Unified system directive prefix for matrixx internal messages.
+ * All system-generated messages should use this prefix for consistent filtering.
+ *
+ * Format: [SYSTEM DIRECTIVE: MATRIXX - {TYPE}]
+ */
+export declare const SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MATRIXX";
+/**
+ * Creates a system directive header with the given type.
+ * @param type - The directive type (e.g., "TODO CONTINUATION", "MATRIX LOOP")
+ * @returns Formatted directive string like "[SYSTEM DIRECTIVE: MATRIXX - TODO CONTINUATION]"
+ */
+export declare function createSystemDirective(type: string): string;
+/**
+ * Checks if a message starts with the matrixx system directive prefix.
+ * Used by keyword-detector and other hooks to skip system-generated messages.
+ * @param text - The message text to check
+ * @returns true if the message is a system directive
+ */
+export declare function isSystemDirective(text: string): boolean;
+/** Presentational tags: unwrap, keep inner text (case-insensitive). */
+export declare const PRESENTATIONAL_TAGS: readonly ["analysis", "results", "files", "answer", "next_steps", "system-reminder"];
+export interface SanitizeKnownTagsOptions {
+    /**
+     * How to handle CONTROL (<instruction name=iteration_nudge>) elements.
+     * - "drop" (default): remove element including inner text. Used by keyword
+     *   detectors so control inner prose cannot leak mode keywords.
+     * - "unwrap-keep-inner": strip the element tags but keep inner prose.
+     *   Used by the DCP nudge sanitizer kept-nudge path so the kept part is
+     *   never sanitized to "" (guard + normalize then apply to inner prose).
+     */
+    control?: "drop" | "unwrap-keep-inner";
+    /**
+     * How to handle PRESENTATIONAL tags (analysis, results, files, answer,
+     * next_steps, system-reminder).
+     * - "unwrap" (default): strip tags but keep inner text. Used by the DCP
+     *   nudge sanitizer kept-nudge path so kept prose is preserved.
+     * - "drop": remove paired element including inner text. Used by keyword
+     *   detectors so system-reminder inner keywords cannot leak into mode
+     *   triggering.
+     */
+    presentation?: "unwrap" | "drop";
+}
+/**
+ * Sanitizes known tags in text using the closed table above.
+ * Control elements are dropped with inner text by default; presentational tags
+ * are unwrapped keeping inner text; unknown tags pass through byte-identical.
+ * @param text - The message text to sanitize
+ * @param options - Optional control-element handling (default drop)
+ * @returns sanitized text (trimmed at edges only when stripping changed it)
+ */
+export declare function sanitizeKnownTags(text: string, options?: SanitizeKnownTagsOptions): string;
+/**
+ * Checks if a message contains system-generated content that should be excluded
+ * from keyword detection and mode triggering.
+ * @param text - The message text to check
+ * @returns true if the message contains system-reminder tags
+ */
+export declare function hasSystemReminder(text: string): boolean;
+/**
+ * Removes system-reminder tag content from text.
+ * This prevents automated system messages from triggering mode keywords.
+ * Drop (not unwrap): inner content must not leak into keyword detection.
+ * @param text - The message text to clean
+ * @returns text with system-reminder content removed
+ */
+export declare function removeSystemReminders(text: string): string;
+export declare const SystemDirectiveTypes: {
+    readonly TASK_CONTINUATION: "TASK CONTINUATION";
+    readonly MATRIX_LOOP: "MATRIX LOOP";
+    readonly MISSION_CONTINUATION: "MISSION CONTINUATION";
+    readonly DELEGATION_REQUIRED: "DELEGATION REQUIRED";
+    readonly SINGLE_TASK_ONLY: "SINGLE TASK ONLY";
+    readonly COMPACTION_CONTEXT: "COMPACTION CONTEXT";
+    readonly CONTEXT_WINDOW_MONITOR: "CONTEXT WINDOW MONITOR";
+    readonly ORACLE_READ_ONLY: "ORACLE READ-ONLY";
+};

package/dist/shared/task-system-gating.d.ts

@@ -0,0 +1,33 @@
+import type { MatrixxConfig } from "../config/schema";
+import type { TasksConfig } from "../config/schema/tasks";
+export declare const TASK_SYSTEM_DEFAULT: true;
+export type ResolvedTasksConfig = Required<Pick<TasksConfig, "enabled" | "scope" | "session_scoped">> & Pick<TasksConfig, "storage_path" | "task_list_id" | "stale_after_hours" | "pollTimeoutMs" | "background_stale_after_hours">;
+/**
+ * Fallback for `tasks.background_stale_after_hours` when the key is absent.
+ * Kept here, next to the resolution that applies it, so the default and its
+ * use site cannot drift; re-exported from the enforcer's `staleness.ts` where
+ * the other staleness default lives.
+ */
+export declare const DEFAULT_BACKGROUND_STALE_AFTER_HOURS = 2;
+/**
+ * Arm the one-time deprecation notice. Pass `undefined` to detach. The notice
+ * is delivered through `notify`, so any configured sink receives it. Nothing
+ * here throws — a notice is never worth a broken config load.
+ */
+export declare function bindTaskSystemDeprecationToast(_client?: unknown): void;
+/** Test-only: allow the one-time warning to fire again. */
+export declare function resetTaskSystemDeprecationWarning(): void;
+/**
+ * Merge the canonical `tasks` section with the remaining legacy locations:
+ * `morpheus.tasks.*` → same-named key, `task.pollTimeoutMs` → pollTimeoutMs.
+ *
+ * `enabled` is NOT derived from the config: the file-backed task system is
+ * unconditional and always resolves to `TASK_SYSTEM_DEFAULT`. The three keys
+ * that used to gate it (`tasks.enabled`, `experimental.task_system`,
+ * `new_task_system_enabled`) are parsed, ignored, and reported once per session
+ * via a log line plus a single startup toast. Nothing here throws.
+ *
+ * Pure derivation, no mutation — safe to call on every read.
+ */
+export declare function resolveTasksConfig(config: Partial<MatrixxConfig> | undefined | null): ResolvedTasksConfig;
+export declare function isTaskSystemEnabled(config: Partial<MatrixxConfig> | undefined | null): boolean;

package/dist/shared/tmux/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;
+export declare const SESSION_TIMEOUT_MS: number;
+export declare const SESSION_MISSING_GRACE_MS = 6000;
+export declare const SESSION_READY_POLL_INTERVAL_MS = 500;
+export declare const SESSION_READY_TIMEOUT_MS = 10000;

package/dist/shared/tmux/tmux-utils/environment.d.ts

@@ -0,0 +1,3 @@
+export type SplitDirection = "-h" | "-v";
+export declare function isInsideTmux(): boolean;
+export declare function getCurrentPaneId(): string | undefined;

package/dist/shared/tmux/tmux-utils/pane-dimensions.d.ts

@@ -0,0 +1,5 @@
+export interface PaneDimensions {
+    paneWidth: number;
+    windowWidth: number;
+}
+export declare function getPaneDimensions(paneId: string): Promise<PaneDimensions | null>;

package/dist/shared/tmux/tmux-utils/server-health.d.ts

@@ -0,0 +1,2 @@
+export declare function isServerRunning(serverUrl: string): Promise<boolean>;
+export declare function resetServerCheck(): void;

package/dist/shared/tmux/tmux-utils.d.ts

@@ -0,0 +1,4 @@
+export { getCurrentPaneId, isInsideTmux } from "./tmux-utils/environment";
+export type { PaneDimensions } from "./tmux-utils/pane-dimensions";
+export { getPaneDimensions } from "./tmux-utils/pane-dimensions";
+export { isServerRunning, resetServerCheck } from "./tmux-utils/server-health";

package/dist/shared/tmux/types.d.ts

@@ -0,0 +1,4 @@
+export interface SpawnPaneResult {
+    success: boolean;
+    paneId?: string;
+}

package/dist/shared/token-cache.d.ts

@@ -0,0 +1,23 @@
+export interface TokenInfo {
+    input: number;
+    output: number;
+    reasoning: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+interface CachedTokenEntry {
+    providerID: string;
+    modelID: string;
+    tokens: TokenInfo;
+    updatedAt: number;
+}
+export declare function updateTokenCache(sessionID: string, data: {
+    providerID: string;
+    modelID?: string;
+    tokens: TokenInfo;
+}): void;
+export declare function getCachedTokenUsage(sessionID: string, staleThresholdMs?: number): CachedTokenEntry | null;
+export declare function clearTokenCache(sessionID: string): void;
+export {};

package/dist/shared/tool-guards.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared tool name guard functions.
+ * Used by multiple hooks to check tool types (read/write).
+ */
+/**
+ * Check if a tool name represents a read operation.
+ * @param toolName - The tool name to check (case-insensitive)
+ * @returns true if the tool is a read tool
+ */
+export declare function isReadTool(toolName: string): boolean;
+/**
+ * Check if a tool name represents a write operation.
+ * @param toolName - The tool name to check (case-insensitive)
+ * @returns true if the tool is a write tool
+ */
+export declare function isWriteTool(toolName: string): boolean;

package/dist/shared/transcript-path.d.ts

@@ -0,0 +1 @@
+export declare function getTranscriptPath(sessionId: string): string;

package/dist/shared/truncate-description.d.ts

@@ -0,0 +1 @@
+export declare function truncateDescription(description: string, maxLength?: number): string;

package/dist/shared/unwrap-list.d.ts

@@ -0,0 +1 @@
+export declare function unwrapList<T>(value: unknown): T[];

package/dist/shared/wallclock-outcome.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Wall-clock outcome helpers shared by the background agent wall-clock supervisor.
+ *
+ * A wall-clock timeout terminates a running task that exceeds its elapsed-time bound
+ * measured from `startedAt`. This module formats the human-readable + machine-readable
+ * outcome payload (mirroring saturated-outcome.ts / revive-outcome.ts).
+ *
+ * The status and reason are typed as `string` on purpose: this module lives in
+ * `src/shared` and must not depend on `BackgroundTaskStatus` or any type from
+ * `src/features/**`.
+ */
+export declare function formatWallclockTimeout(taskId: string, elapsedMs: number, limitMs: number): string;
+/**
+ * Checks whether the given status and terminal reason pair indicates a
+ * wall-clock timeout. Uses raw strings so this module never imports
+ * from src/features/**.
+ */
+export declare function isWallclockTimeout(status: string, terminalReason: string | undefined): boolean;