@cruxy/cli 1.0.2 → 1.0.4

package/dist/skills/parser.d.ts

@@ -1,31 +0,0 @@
-import { CruxyError } from "../errors/index.js";
-import { type SkillFrontmatter } from "./types.js";
-/**
- * Thrown when a SKILL.md is malformed or fails validation. A {@link CruxyError}
- * (code CRUXY_E_SKILL_INVALID) so it carries a stable code if it reaches the
- * boundary; the loader still catches it to record a `SkillError` and exclude the
- * skill — loud, never silently skipped.
- */
-export declare class SkillValidationError extends CruxyError {
-    constructor(message: string);
-}
-/** The validated frontmatter plus the markdown body that followed it. */
-export interface ParsedSkill {
-    frontmatter: SkillFrontmatter;
-    body: string;
-}
-/**
- * Parse and validate a SKILL.md.
- *
- * The frontmatter is a deliberately small, strict subset of YAML — `key: value`
- * scalars, optional surrounding quotes, `#` comment lines — which is all the
- * two-field schema needs. Anything outside that subset (block scalars, nested
- * maps, a line without a colon, a missing/unterminated block) is a loud error
- * rather than a best-effort guess, so a skill never loads with a
- * silently-misread description.
- *
- * @param text the raw file contents
- * @param dirName the skill directory's basename; `name` must equal it
- * @throws {SkillValidationError} on any malformed or invalid input
- */
-export declare function parseSkill(text: string, dirName: string): ParsedSkill;

package/dist/skills/service.d.ts

@@ -1,41 +0,0 @@
-import { type LoaderSources } from "./loader.js";
-import { type Skill, type SkillCatalogEntry, type SkillStatus } from "./types.js";
-/** Logger surface the service reports through. */
-interface SkillServiceLogger {
-    debug(message: string): void;
-}
-/**
- * A ready-to-use skills catalog for one project root. It resolves the three
- * sources, caches the catalog, and refreshes lazily when a source directory's
- * mtime changes (i.e. a skill was added or removed). Bodies are never cached —
- * {@link SkillService.load} re-reads them on demand, so body edits are always
- * live. Build one with {@link getSkillService}, which caches per cwd.
- */
-export interface SkillService {
-    /** Catalog entries (name + description + source), refreshed if stale. */
-    list(): Promise<SkillCatalogEntry[]>;
-    /** Load one skill's body + resolved asset paths. Throws if unknown. */
-    load(name: string): Promise<Skill>;
-    /** Snapshot for `cruxy skills --status`: entries, errors, and source dirs. */
-    status(): Promise<SkillStatus>;
-}
-/**
- * Explicit dependency overrides for tests — the only way to point the loader at
- * fixture directories. Production callers never pass this, so they always use
- * the real project/user/builtin sources.
- */
-export interface SkillServiceDeps {
-    sources?: Partial<LoaderSources>;
-}
-/** The default source directories for a project root. */
-export declare function defaultSources(cwd: string): LoaderSources;
-/**
- * Get (or build) the {@link SkillService} for a project root, cached per
- * resolved cwd. Construction is cheap (just path resolution); the catalog is
- * built lazily on first use and refreshed on source-mtime change. `deps` is for
- * explicit test injection only (see {@link SkillServiceDeps}).
- */
-export declare function getSkillService(cwd: string, logger: SkillServiceLogger, deps?: SkillServiceDeps): SkillService;
-/** Drop all cached services. For tests and process teardown. */
-export declare function resetSkillServices(): void;
-export {};

package/dist/skills/types.d.ts

@@ -1,94 +0,0 @@
-import { z } from "zod";
-/**
- * Shared types for the skills system (C.18). A *skill* is a directory holding a
- * `SKILL.md` — YAML frontmatter (name + description) plus a markdown
- * instructions body — and optional `scripts/` and `reference/` asset subdirs.
- *
- * Progressive disclosure is the whole point: only `name` + `description` enter
- * the agent's context by default (the catalog); the full body is read on demand
- * by `load_skill`. Bodies are never held in the cached catalog.
- */
-/** Where a skill was discovered, highest precedence first. */
-export type SkillSource = "project" | "user" | "builtin";
-/** Precedence order: project overrides user overrides builtin. */
-export declare const SOURCE_PRECEDENCE: readonly SkillSource[];
-/**
- * Strict schema for SKILL.md frontmatter. `.strict()` rejects unknown keys, so a
- * typo'd field is a loud error rather than silently ignored. `name` is
- * kebab-case and must equal the skill's directory name (enforced by the parser).
- */
-export declare const SkillFrontmatterSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    name: string;
-    description: string;
-}, {
-    name: string;
-    description: string;
-}>;
-export type SkillFrontmatter = z.infer<typeof SkillFrontmatterSchema>;
-/**
- * The cheap catalog entry the agent sees by default — name, one-line
- * description, and which source won. No body.
- */
-export interface SkillCatalogEntry {
-    name: string;
-    description: string;
-    source: SkillSource;
-}
-/**
- * A fully-loaded skill, returned by `load_skill`/`getSkill`. Carries the
- * markdown body plus resolved, in-bounds asset paths.
- */
-export interface Skill {
-    name: string;
-    description: string;
-    source: SkillSource;
-    /** Markdown instructions (everything after the frontmatter block). */
-    body: string;
-    /** Absolute path of the skill directory — the root for its assets. */
-    assetRoot: string;
-    /** Project-relative-to-assetRoot POSIX paths of files under `scripts/`. */
-    scripts: string[];
-    /** Project-relative-to-assetRoot POSIX paths of files under `reference/`. */
-    references: string[];
-}
-/**
- * A validation failure for one candidate skill. Collected (never thrown past the
- * loader) so one bad skill can't break the catalog; surfaced loudly in
- * `cruxy skills --status` and excluded from the catalog.
- */
-export interface SkillError {
-    source: SkillSource;
-    /** Absolute path of the offending skill directory. */
-    dir: string;
-    /** The directory's basename (the would-be skill name), for display. */
-    name: string;
-    /** Actionable, human-readable reason. */
-    message: string;
-}
-/**
- * The resolved catalog: valid entries (deduped by precedence), the validation
- * errors that were excluded, and a name→location index used by `getSkill` to
- * read a body on demand. Bodies are intentionally absent.
- */
-export interface SkillCatalog {
-    entries: SkillCatalogEntry[];
-    errors: SkillError[];
-    /** name → winning skill's directory + source (for on-demand body reads). */
-    byName: Map<string, {
-        dir: string;
-        source: SkillSource;
-    }>;
-}
-/** Snapshot for `cruxy skills --status`. */
-export interface SkillStatus {
-    entries: SkillCatalogEntry[];
-    errors: SkillError[];
-    /** The three source directories, in precedence order. */
-    sources: {
-        source: SkillSource;
-        dir: string;
-    }[];
-}

package/dist/subagent/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./types.js";
-export * from "./semaphore.js";
-export * from "./registry-scope.js";
-export * from "./orchestrator.js";
-export * from "./spawn-tool.js";

package/dist/subagent/orchestrator.d.ts

@@ -1,169 +0,0 @@
-import type { Provider } from "@cruxy/sdk";
-import type { ApprovalDecision } from "../approval/types.js";
-import type { CruxyConfig } from "../config/index.js";
-import type { StreamRenderer } from "../render/index.js";
-import type { Router } from "../routing/index.js";
-import type { ApproveAction, ToolContext, ToolRegistry } from "../tools/index.js";
-import type { SandboxService } from "../sandbox/index.js";
-import { Workspace } from "../workspace/index.js";
-import { Semaphore } from "./semaphore.js";
-import type { SubagentResult, SubagentSpec } from "./types.js";
-/**
- * Everything a spawn needs from the surrounding session, injected by the
- * session factory so this package stays free of wiring detail. Shared members
- * are stateless (provider, config, logger) or deliberately run-scoped (the
- * renderer, and — via `makeChildApproval` — the checkpoint gate); everything
- * stateful (history, registry, allowlist, budget) is built fresh per spawn.
- */
-export interface SubagentOrchestratorDeps {
-    provider: Provider;
-    config: CruxyConfig;
-    /**
-     * Multi-model routing (C.30). When set, child runs route on their spec's task
-     * class (default `subagent`); omitted → the provider default (unchanged).
-     */
-    router?: Router;
-    /** The parent's registry — the ceiling every child scope derives from. */
-    parentRegistry: ToolRegistry;
-    cwd: string;
-    /**
-     * The session's declared workspace (C.26). Threaded onto the child ctx so a
-     * subagent sees the SAME roots as the main loop — without it the child would
-     * fall back to a single-root workspace over `cwd` and its fan tools would go
-     * silently primary-only (a split-brain WITHIN one session).
-     */
-    workspace: Workspace;
-    logger: ToolContext["logger"];
-    git?: {
-        branch: string;
-        dirty: boolean;
-    } | null;
-    projectInstructions?: string | null;
-    renderer?: StreamRenderer;
-    /**
-     * The run's sandbox (C.16), when enabled. Threaded into the child ctx so a
-     * subagent's shell/test commands run in the SAME box as the parent's —
-     * sandboxing is never silently dropped for a child.
-     */
-    sandbox?: SandboxService;
-    /**
-     * Build a fresh, fully-wrapped approval gate for one child run: a NEW
-     * `ApprovalService` (so the child gets its own empty session allowlist —
-     * parent grants never silently widen child authority) behind the same
-     * checkpoint hook as the parent (so child mutations land under the run's
-     * one checkpoint, C.32).
-     */
-    makeChildApproval(): (action: ApproveAction) => Promise<ApprovalDecision>;
-    /**
-     * Whether per-root checkpointing is active for the run (C.26 step 3). Threaded
-     * onto the child ctx so a subagent's non-primary writes lift the JC-1 refusal on
-     * the SAME condition as the parent — and, because `makeChildApproval` wraps the
-     * same shared checkpoint gate, those writes join the run's one set (⚖︎JC-δ).
-     */
-    checkpointsActive?: boolean;
-    /**
-     * The ONE shared execution semaphore (C.28). When set, parallel fan-out draws
-     * permits from THIS instance — the same one background jobs use — so the
-     * `subagent.maxConcurrency` cap bounds subagents AND jobs COMBINED, never one
-     * cap each. Omitted → the orchestrator constructs its own (C.33 behaviour,
-     * used by tests that exercise the orchestrator in isolation).
-     */
-    executionSemaphore?: Semaphore;
-}
-/**
- * Spawns subagents (C.14): the existing agent loop re-driven over isolated
- * state. Each spawn builds a fresh history seeded with only the task, a
- * scoped-down registry, a fresh approval gate, and a hard budget, runs
- * `runAgent` to completion (or cap), and folds the outcome into a compact
- * {@link SubagentResult}. The child transcript is dropped here — the parent
- * never sees it.
- *
- * Spawns are sequential by construction: the loop awaits each tool call, so
- * two spawn requests in one turn run one after the other in deterministic
- * order. Parallel fan-out is C.33's job — `spawn` is a self-contained async
- * unit with no cross-spawn state, so it slots in without reshaping this class.
- */
-export declare class SubagentOrchestrator {
-    private readonly deps;
-    /**
-     * The ONE shared bound on parallel fan-out (C.33, JC-D). Constructed once per
-     * session and reused by every {@link spawnMany} call (nested spawns reuse this
-     * same orchestrator instance), so `subagent.maxConcurrency` caps the number of
-     * concurrently-executing subagents across the WHOLE session — not per parent.
-     */
-    private readonly sem;
-    constructor(deps: SubagentOrchestratorDeps);
-    /** Live/queued fan-out slots (inspection/tests): proves the global cap holds. */
-    get concurrency(): {
-        available: number;
-        waiting: number;
-    };
-    /**
-     * Run one subagent to completion. `parentDepth` is the spawner's depth (the
-     * main agent is 0); spawning past `subagent.maxDepth` throws
-     * `CRUXY_E_SUBAGENT_DEPTH_EXCEEDED` — the spawn tool is also structurally
-     * withheld at the cap, so this throw is the fail-loud backstop.
-     *
-     * Never rejects on a *child* failure — provider or tool crashes come back as
-     * `status: "failed"` for the parent to reason over. The two exceptions that
-     * do propagate: the depth cap (above) and `CRUXY_E_APPROVAL_REQUIRED`
-     * (non-interactive default-deny must reach the boundary, U.3 — a subagent is
-     * not a way to swallow it).
-     */
-    spawn(spec: SubagentSpec, parentDepth: number, opts?: SpawnOptions): Promise<SubagentResult>;
-    /**
-     * Parallel fan-out (C.33): run N children concurrently under the shared
-     * concurrency semaphore and fold their outcomes into a result array whose
-     * order MATCHES `specs` (position i is spec i's result — never completion
-     * order). A DEPTH-0 capability only (the plural tool is never granted to a
-     * child), so no permit holder ever nests a second fan-out — the semaphore
-     * stays deadlock-free.
-     *
-     * Safety before dispatch: overlapping write scope is REFUSED
-     * (`CRUXY_E_SUBAGENT_SCOPE_OVERLAP`) so two writers can never race on one root.
-     *
-     * Cancellation: children share one {@link AbortController}. A child returning a
-     * `failed`/`budget-exceeded` result is a normal PARTIAL outcome — siblings run
-     * on. But a *fatal* throw from any child (non-interactive default-deny) or an
-     * abort on `opts.signal` (Ctrl-C) aborts the controller: every sibling stops at
-     * its next turn boundary and its in-flight shell child is kill-tree'd, so the
-     * fan-out leaves no orphan. All children are awaited to settle before a fatal
-     * throw propagates — never a detached, still-running sibling.
-     */
-    spawnMany(specs: readonly SubagentSpec[], parentDepth: number, opts?: {
-        signal?: AbortSignal;
-    }): Promise<SubagentResult[]>;
-    /**
-     * Resolve a child's scope from an optional root name. With a name: a
-     * single-root workspace over that root (writes confined to it) + that root's
-     * cwd. Without: the full session workspace + primary cwd (C.14 behaviour).
-     */
-    private childScope;
-    /**
-     * Refuse a fan-out where two WRITING children (any mutating tool granted)
-     * target the same root — the disjoint-scope guarantee (C.33). A writer with no
-     * declared root defaults to the session PRIMARY, so in a single-root session at
-     * most one child may write per batch (the rest must be read-only). Read-only
-     * children never conflict.
-     *
-     * Collects EVERY colliding root (not just the first) so the refusal names all
-     * conflicting task pairs at once — the model can fix them in one correction.
-     * The check is on DECLARED scope (tools + root), an honest over-approximation
-     * the error message is explicit about.
-     */
-    private assertDisjointWriteScopes;
-    /** Map the child's AgentResult to the structured, transcript-free shape. */
-    private toResult;
-}
-/** Per-spawn options: cancellation + a per-child render tag for a fan-out. */
-interface SpawnOptions {
-    /** Cooperative cancellation; threaded into `runAgent` and `ctx.signal`. */
-    signal?: AbortSignal;
-    /**
-     * A short per-child label for a parallel fan-out (JC-F), e.g. `"2/3"`, so
-     * interleaved trail notes are attributable to the child that emitted them.
-     * Undefined for a single sequential spawn — chrome is byte-identical to C.14.
-     */
-    slot?: string;
-}
-export {};

package/dist/subagent/registry-scope.d.ts

@@ -1,41 +0,0 @@
-import { ToolRegistry } from "../tools/index.js";
-/**
- * Child tool-registry derivation (C.14). The one rule: a subagent's toolset is
- * scoped DOWN from its parent's, never up. Enforcement is structural — the
- * child registry is built exclusively from `parent.get(name)` lookups, so a
- * tool the parent lacks is unobtainable, not merely denied.
- */
-/** The spawn tool's registered name (excluded from every scoped child set —
- * the orchestrator re-adds a depth-bound instance only while depth allows). */
-export declare const SPAWN_SUBAGENT_TOOL_NAME = "spawn_subagent";
-/** The parallel fan-out tool's name (C.33). Stripped from every child scope:
- * parallel fan-out is a depth-0 capability only, so a child can never obtain it
- * (which is also what keeps the concurrency semaphore deadlock-free — no permit
- * holder ever nests a second fan-out). A child may still spawn ONE sequential
- * subagent via {@link SPAWN_SUBAGENT_TOOL_NAME} when depth allows. */
-export declare const SPAWN_SUBAGENTS_TOOL_NAME = "spawn_subagents";
-/**
- * Mutating tools (C.33): a child holding ANY of these is a "writer" for the
- * disjoint-scope check. Two writers in one parallel batch must target distinct
- * roots, or the batch is refused pre-dispatch. Kept in sync with the gated,
- * side-effecting tool set (file writes, shell/test, VCS).
- */
-export declare const SUBAGENT_WRITE_TOOLS: ReadonlySet<string>;
-/**
- * The default child toolset: read-only investigation plus skills. Mirrors the
- * C.31 propose-phase set — no writes, no shell, no VCS unless the parent
- * explicitly grants them at spawn (and holds them itself).
- */
-export declare const DEFAULT_SUBAGENT_TOOLS: readonly string[];
-/**
- * Build a child registry as a strict subset of `parent`.
- *
- * - No `requested` → the intersection of {@link DEFAULT_SUBAGENT_TOOLS} with
- *   what the parent actually has (a scoped parent scopes its children further).
- * - With `requested` → every name must exist in the parent; an unavailable
- *   name **throws** (fail loud — the spawn tool surfaces it to the model as a
- *   tool error so it can self-correct, exactly like invalid arguments).
- * - `spawn_subagent` is always stripped: nesting is the orchestrator's
- *   decision (depth-capped), never a scope grant.
- */
-export declare function scopeRegistry(parent: ToolRegistry, requested?: readonly string[]): ToolRegistry;

package/dist/subagent/semaphore.d.ts

@@ -1,56 +0,0 @@
-/**
- * A counting semaphore (C.33): bounds how many agent runs execute at once.
- * FIFO — waiters are served in arrival order, so a fan-out's results stay
- * dispatch-order-fair — and the permit is handed directly from a releaser to
- * the next waiter, so the live count never transiently exceeds the cap.
- *
- * Used as the ONE shared bound on all concurrent execution: parallel subagent
- * fan-out (C.33) AND background jobs (C.28) draw permits from the SAME instance,
- * so `subagent.maxConcurrency` caps their COMBINED live count — never one cap
- * per subsystem. Parallel dispatch happens at depth 0 only (the `spawn_subagents`
- * tool is never granted to a child), and a permit is held for a child's whole
- * lifetime — including any *sequential* nested spawn beneath it, which is
- * deliberately un-permitted. Because no permit holder ever blocks trying to
- * acquire a second permit, the semaphore cannot be part of a wait cycle: it is
- * deadlock-free by construction (see the C.33 design doc's deadlock argument).
- *
- * C.28 adds a PRIORITY lane to {@link acquire}. A background job that pauses to
- * await a human approval RELEASES its permit (JC-D: a job blocked on a human is
- * not using compute, and holding the slot would deadlock the cap if N jobs all
- * paused). When the human approves, the job re-acquires with `priority: true` so
- * it jumps ahead of newly-dispatched work — a resumed job never starves behind a
- * fresh fan-out that filled the queue while it waited. Normal (non-priority)
- * waiters keep strict FIFO among themselves, so C.33's dispatch-order fairness is
- * unchanged for everything that does not pause.
- */
-export interface AcquireOptions {
-    /**
-     * Serve this waiter ahead of all non-priority waiters (still FIFO among
-     * priority waiters). Used by a resumed background job re-acquiring its slot
-     * after an approval, so it is not starved by work dispatched while it paused.
-     */
-    priority?: boolean;
-}
-export declare class Semaphore {
-    private permits;
-    /** Waiters that take the next permit ahead of {@link normal} (FIFO within). */
-    private readonly priority;
-    /** Ordinary waiters, served strictly FIFO after any priority waiters. */
-    private readonly normal;
-    constructor(permits: number);
-    /** Run `fn` while holding one permit; the permit is released even if it throws. */
-    run<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Take one permit, waiting if none is free. Resolves immediately when a permit
-     * is available; otherwise enqueues onto the priority or normal lane and resolves
-     * when {@link release} hands it a permit. Callers that acquire directly (a
-     * paused/resumed job) MUST call {@link release} exactly once per acquire.
-     */
-    acquire(opts?: AcquireOptions): Promise<void>;
-    /** Return one permit — handed straight to the next waiter (priority first). */
-    release(): void;
-    /** Permits currently available (inspection/tests). */
-    get available(): number;
-    /** Callers currently blocked waiting for a permit (inspection/tests). */
-    get waiting(): number;
-}

package/dist/subagent/spawn-tool.d.ts

@@ -1,86 +0,0 @@
-import { z } from "zod";
-import type { Tool } from "../tools/index.js";
-import type { SubagentOrchestrator } from "./orchestrator.js";
-/**
- * The `spawn_subagent` tool (C.14): the parent-facing seam for delegation. A
- * normal tool on the same loop as everything else — no hidden control flow.
- * Bound to the spawner's depth at construction, so the registry a tool lives
- * on structurally encodes how much deeper nesting may go: at the configured
- * cap the tool simply isn't registered.
- */
-declare const parameters: z.ZodObject<{
-    task: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
-    maxIterations: z.ZodOptional<z.ZodNumber>;
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    task: string;
-    maxIterations?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: [string, ...string[]] | undefined;
-}, {
-    task: string;
-    maxIterations?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: [string, ...string[]] | undefined;
-}>;
-/** Build a `spawn_subagent` tool bound to `orchestrator` at `depth`. */
-export declare function makeSpawnSubagentTool(orchestrator: SubagentOrchestrator, depth: number): Tool<typeof parameters>;
-declare const batchParameters: z.ZodObject<{
-    tasks: z.ZodArray<z.ZodObject<{
-        task: z.ZodString;
-        tools: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
-        root: z.ZodOptional<z.ZodString>;
-        maxIterations: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        task: string;
-        root?: string | undefined;
-        maxIterations?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: [string, ...string[]] | undefined;
-    }, {
-        task: string;
-        root?: string | undefined;
-        maxIterations?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: [string, ...string[]] | undefined;
-    }>, "atleastone">;
-}, "strip", z.ZodTypeAny, {
-    tasks: [{
-        task: string;
-        root?: string | undefined;
-        maxIterations?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: [string, ...string[]] | undefined;
-    }, ...{
-        task: string;
-        root?: string | undefined;
-        maxIterations?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: [string, ...string[]] | undefined;
-    }[]];
-}, {
-    tasks: [{
-        task: string;
-        root?: string | undefined;
-        maxIterations?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: [string, ...string[]] | undefined;
-    }, ...{
-        task: string;
-        root?: string | undefined;
-        maxIterations?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: [string, ...string[]] | undefined;
-    }[]];
-}>;
-/**
- * Build the `spawn_subagents` tool (C.33) — the PARALLEL fan-out seam, bound to
- * `depth`. One tool call dispatches N independent, internally-sequential children
- * concurrently (JC-A) under the shared concurrency semaphore, and returns their
- * results IN REQUEST ORDER. A DEPTH-0 capability: it is never granted to a child,
- * so fan-out never nests (which keeps the semaphore deadlock-free).
- */
-export declare function makeSpawnSubagentsTool(orchestrator: SubagentOrchestrator, depth: number): Tool<typeof batchParameters>;
-export {};

package/dist/subagent/types.d.ts

@@ -1,65 +0,0 @@
-import type { Usage } from "@cruxy/sdk";
-import type { TaskClass } from "../routing/index.js";
-import type { BudgetLimits } from "../agent/budget.js";
-export type { BudgetLimits };
-/**
- * Types for subagent orchestration (C.14): the main agent delegates a bounded
- * subtask to a child agent that runs the SAME loop with its own fresh history,
- * a scoped-down tool registry, and a hard budget — then returns a structured
- * result and discards its transcript. The parent reasons over the result only;
- * context isolation is the whole point.
- */
-/**
- * Why a subagent run ended. Every path returns a result — never a hang.
- * `cancelled` (C.33) is a parallel-fan-out outcome: a fatal sibling failure or
- * Ctrl-C aborted this child before it finished — recorded honestly, never
- * dressed up as `done`.
- */
-export type SubagentStatus = "done" | "budget-exceeded" | "failed" | "cancelled";
-/** A spawn request: the bounded task plus optional scope/budget narrowing. */
-export interface SubagentSpec {
-    /** The complete, self-contained subtask the subagent should perform. */
-    task: string;
-    /**
-     * Tool names to grant, resolved against the *parent's* registry — a subagent
-     * can only ever scope DOWN. Omitted → the default read-only set.
-     */
-    tools?: readonly string[];
-    /**
-     * Budget overrides. Clamped to `subagent.defaultBudget` from config — a
-     * spawn can narrow its budget, never raise it past the configured ceilings.
-     */
-    budget?: Partial<BudgetLimits>;
-    /**
-     * Routing task class for this spawn (C.30); defaults to `subagent`. A
-     * declaration at the spawn call site — not something the router guesses.
-     */
-    taskClass?: TaskClass;
-    /**
-     * The workspace root (by exact name, C.26) this child is scoped to (C.33).
-     * When set, the child's cwd and confinement narrow to that ONE root, so its
-     * writes land there and nowhere else — the unit of the parallel fan-out's
-     * disjoint-scope guarantee: two writing children must name distinct roots or
-     * the batch is refused pre-dispatch. Omitted → the child inherits the full
-     * session workspace (read-only fan-out, or a single-root session), unchanged
-     * from C.14.
-     */
-    root?: string;
-}
-/**
- * What the parent gets back — compact structured data, never the transcript.
- * `summary` is the subagent's final assistant message (partial when a budget
- * tripped); `artifacts` are the project-relative paths the subagent was
- * approved to mutate.
- */
-export interface SubagentResult {
-    status: SubagentStatus;
-    summary: string;
-    artifacts?: string[];
-    /** Present on `budget-exceeded` / `failed`: the coded, actionable reason. */
-    error?: string;
-    /** Model turns the subagent consumed. */
-    iterations: number;
-    /** Token usage the subagent consumed (folded into the parent's accounting). */
-    usage: Usage;
-}

package/dist/testing/detect.d.ts

@@ -1,3 +0,0 @@
-import type { CruxyConfig } from "../config/index.js";
-import type { TestCommand } from "./types.js";
-export declare function detectTestCommand(cwd: string, config: CruxyConfig): TestCommand | null;

package/dist/testing/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./types.js";
-export * from "./detect.js";
-export * from "./runner.js";
-export * from "./parse.js";
-export * from "./run-tests-tool.js";

package/dist/testing/parse.d.ts

@@ -1,33 +0,0 @@
-import type { FailureParser, TestFailure } from "./types.js";
-/**
- * Best-effort failure extraction (C.13). Two conservative parsers ship —
- * vitest-style and jest-style — behind the pluggable {@link FailureParser}
- * seam. The contract: extract only what a pattern positively recognizes;
- * when nothing matches, return NOTHING (the caller falls back to the raw
- * tail). Parsers never decide pass/fail and never invent counts — `message`
- * fields are verbatim runner output, not summaries we authored.
- */
-/**
- * Vitest: per-test failure lines (`FAIL src/x.test.ts > suite > name`, also
- * `×`/`✗` markers) and the `Tests  2 failed | 570 passed (572)` summary.
- * Plain file-level `FAIL <file>` lines are deliberately left to the jest
- * parser, which owns the file+bullet association.
- */
-export declare const parseVitest: FailureParser;
-/**
- * Jest: `FAIL <file>` headers with `● <name>` bullets underneath (the bullet's
- * following indented lines are its message, verbatim), and the
- * `Tests: …, N total` summary. A FAIL header with no bullets (e.g. a suite
- * that failed to load) becomes one file-level failure.
- */
-export declare const parseJest: FailureParser;
-/** Parser order: most-specific first. The pluggable seam for new frameworks. */
-export declare const defaultParsers: readonly FailureParser[];
-/**
- * Run the parser chain; the first parser that recognizes anything wins.
- * Nothing recognized → empty failures, no total — the raw tail is the result.
- */
-export declare function parseFailures(output: string): {
-    failures: TestFailure[];
-    total?: number;
-};