@planu/cli 3.9.9 → 3.9.11

package/dist/engine/tool-groups/group-manager.js

@@ -0,0 +1,205 @@
+import { readJson, writeJson } from '../../storage/base-store.js';
+import toolGroupsConfigJson from '../../config/tool-groups.json' with { type: 'json' };
+const STATE_PATH = 'data/global/tool-group-state.json';
+const toolGroupsConfig = toolGroupsConfigJson;
+export class GroupManager {
+    groups;
+    enabledState;
+    toolMap;
+    notifyChanged;
+    constructor(toolMap, notifyChanged) {
+        this.toolMap = toolMap;
+        this.notifyChanged = notifyChanged;
+        this.groups = new Map();
+        this.enabledState = new Map();
+    }
+    /** Load groups from config, restore persisted state, apply to toolMap. */
+    async init() {
+        for (const def of toolGroupsConfig.groups) {
+            this.groups.set(def.id, def);
+            this.enabledState.set(def.id, def.defaultEnabled);
+        }
+        const persisted = await this.loadPersistedState();
+        for (const [groupId, enabled] of persisted) {
+            if (this.groups.has(groupId)) {
+                this.enabledState.set(groupId, enabled);
+            }
+        }
+        for (const [groupId, enabled] of this.enabledState) {
+            this.applyGroupState(groupId, enabled);
+        }
+    }
+    /** Enable all tools in a group. */
+    enableGroup(groupId) {
+        const group = this.groups.get(groupId);
+        if (!group) {
+            return this.buildErrorResult(groupId, 'enable', `Group '${groupId}' does not exist.`);
+        }
+        this.enabledState.set(groupId, true);
+        this.applyGroupState(groupId, true);
+        void this.persistState().catch((err) => {
+            console.error('[planu] group-manager persistState failed:', err);
+        });
+        this.notifyChanged();
+        return this.buildActivationResult(groupId, 'enable');
+    }
+    /** Disable all tools in a group. */
+    disableGroup(groupId) {
+        const group = this.groups.get(groupId);
+        if (!group) {
+            return this.buildErrorResult(groupId, 'disable', `Group '${groupId}' does not exist.`);
+        }
+        if (group.locked) {
+            return this.buildErrorResult(groupId, 'disable', `Group '${groupId}' is locked and cannot be disabled.`);
+        }
+        this.enabledState.set(groupId, false);
+        this.applyGroupState(groupId, false);
+        void this.persistState().catch((err) => {
+            console.error('[planu] group-manager persistState failed:', err);
+        });
+        this.notifyChanged();
+        return this.buildActivationResult(groupId, 'disable');
+    }
+    /** Toggle a group based on its current state. */
+    toggleGroup(groupId) {
+        const group = this.groups.get(groupId);
+        if (!group) {
+            return this.buildErrorResult(groupId, 'toggle', `Group '${groupId}' does not exist.`);
+        }
+        const currentlyEnabled = this.enabledState.get(groupId) ?? group.defaultEnabled;
+        if (!currentlyEnabled) {
+            return this.enableGroup(groupId);
+        }
+        if (group.locked) {
+            return this.buildErrorResult(groupId, 'toggle', `Group '${groupId}' is locked and cannot be disabled.`);
+        }
+        return this.disableGroup(groupId);
+    }
+    /** Return runtime status for all groups, including a virtual 'ungrouped' group. */
+    getGroupStatus() {
+        const statuses = [];
+        const groupedTools = new Set();
+        for (const [groupId, def] of this.groups) {
+            for (const tool of def.tools) {
+                groupedTools.add(tool);
+            }
+            const enabled = this.enabledState.get(groupId) ?? def.defaultEnabled;
+            statuses.push({
+                id: groupId,
+                name: def.name,
+                description: def.description,
+                enabled,
+                tools: [...def.tools],
+                toolCount: def.tools.length,
+            });
+        }
+        const ungroupedTools = [];
+        for (const toolName of this.toolMap.keys()) {
+            if (!groupedTools.has(toolName)) {
+                ungroupedTools.push(toolName);
+            }
+        }
+        if (ungroupedTools.length > 0) {
+            statuses.push({
+                id: 'ungrouped',
+                name: 'Ungrouped',
+                description: 'Tools not assigned to any defined group.',
+                enabled: true,
+                tools: ungroupedTools,
+                toolCount: ungroupedTools.length,
+            });
+        }
+        return statuses;
+    }
+    /** Return the group ID that contains the given tool, or undefined. */
+    getToolGroup(toolName) {
+        for (const [groupId, def] of this.groups) {
+            if (def.tools.includes(toolName)) {
+                return groupId;
+            }
+        }
+        return undefined;
+    }
+    /** Count of tools currently enabled in toolMap. */
+    getActiveToolCount() {
+        let count = 0;
+        for (const slot of this.toolMap.values()) {
+            if (slot.enabled) {
+                count++;
+            }
+        }
+        return count;
+    }
+    /** Total tools registered in toolMap. */
+    getTotalToolCount() {
+        return this.toolMap.size;
+    }
+    /** Load persisted group states from disk. */
+    async loadPersistedState() {
+        const defaultState = { states: [], updatedAt: '' };
+        const persisted = await readJson(STATE_PATH, defaultState);
+        const result = new Map();
+        for (const entry of persisted.states) {
+            result.set(entry.groupId, entry.enabled);
+        }
+        return result;
+    }
+    /** Write current group states to disk. */
+    async persistState() {
+        const states = [];
+        for (const [groupId, enabled] of this.enabledState) {
+            states.push({ groupId, enabled, lastChanged: new Date().toISOString() });
+        }
+        const payload = {
+            states,
+            updatedAt: new Date().toISOString(),
+        };
+        await writeJson(STATE_PATH, payload);
+    }
+    /** Apply enabled/disabled state to all tools in a group via toolMap. */
+    applyGroupState(groupId, enabled) {
+        const def = this.groups.get(groupId);
+        /* v8 ignore next 3 */
+        if (!def) {
+            return;
+        }
+        for (const toolName of def.tools) {
+            const slot = this.toolMap.get(toolName);
+            if (!slot) {
+                continue;
+            }
+            if (enabled) {
+                slot.enable();
+            }
+            else {
+                slot.disable();
+            }
+        }
+    }
+    /** Build a successful GroupActivationResult for a given group and action. */
+    buildActivationResult(groupId, action) {
+        const newState = this.enabledState.get(groupId) ?? false;
+        return {
+            success: true,
+            group: groupId,
+            action,
+            newState,
+            allGroups: this.getGroupStatus(),
+            totalActiveTools: this.getActiveToolCount(),
+            totalTools: this.getTotalToolCount(),
+        };
+    }
+    /** Build a failed GroupActivationResult (group not found or locked). */
+    buildErrorResult(groupId, action, _message) {
+        return {
+            success: false,
+            group: groupId,
+            action,
+            newState: this.enabledState.get(groupId) ?? false,
+            allGroups: this.getGroupStatus(),
+            totalActiveTools: this.getActiveToolCount(),
+            totalTools: this.getTotalToolCount(),
+        };
+    }
+}
+//# sourceMappingURL=group-manager.js.map

package/dist/engine/tool-groups/stack-activator.d.ts

@@ -0,0 +1,15 @@
+import type { GroupActivationPlan, GroupStatus } from '../../types/index.js';
+/**
+ * Compute which groups should be enabled/disabled given a detected stack.
+ *
+ * - Matches each profile `signal` against the normalized (lowercased) detected
+ *   stack keywords (case-insensitive).
+ * - Only returns changes: groups already in the desired state are omitted.
+ * - Never requests disabling a group whose `enabled` state is already false.
+ * - Never requests disabling a locked group (caller also enforces this via
+ *   GroupManager, but we filter early to keep output intent-accurate).
+ * - De-duplicates group IDs and never reports a group in both lists; when a
+ *   group is requested for both enable and disable, enable wins.
+ */
+export declare function computeGroupActivations(detectedStack: readonly string[], currentGroups: readonly GroupStatus[]): GroupActivationPlan;
+//# sourceMappingURL=stack-activator.d.ts.map

package/dist/engine/tool-groups/stack-activator.js

@@ -0,0 +1,79 @@
+// stack-activator.ts — SPEC-568: Smart tool activation based on detected project stack.
+// Pure (no I/O): maps detected stack keywords to group activation changes.
+import toolGroupProfilesJson from '../../config/tool-group-profiles.json' with { type: 'json' };
+const profilesConfig = toolGroupProfilesJson;
+/**
+ * Compute which groups should be enabled/disabled given a detected stack.
+ *
+ * - Matches each profile `signal` against the normalized (lowercased) detected
+ *   stack keywords (case-insensitive).
+ * - Only returns changes: groups already in the desired state are omitted.
+ * - Never requests disabling a group whose `enabled` state is already false.
+ * - Never requests disabling a locked group (caller also enforces this via
+ *   GroupManager, but we filter early to keep output intent-accurate).
+ * - De-duplicates group IDs and never reports a group in both lists; when a
+ *   group is requested for both enable and disable, enable wins.
+ */
+export function computeGroupActivations(detectedStack, currentGroups) {
+    if (detectedStack.length === 0 || profilesConfig.profiles.length === 0) {
+        return { toEnable: [], toDisable: [] };
+    }
+    const stackSet = buildStackSet(detectedStack);
+    const matchingProfiles = profilesConfig.profiles.filter((profile) => stackSet.has(profile.signal.toLowerCase()));
+    if (matchingProfiles.length === 0) {
+        return { toEnable: [], toDisable: [] };
+    }
+    const requestedEnable = collectGroupIds(matchingProfiles, 'enable');
+    const requestedDisable = collectGroupIds(matchingProfiles, 'disable');
+    // enable wins over disable when a group appears in both
+    for (const id of requestedEnable) {
+        requestedDisable.delete(id);
+    }
+    const groupIndex = indexGroups(currentGroups);
+    const toEnable = [];
+    const toDisable = [];
+    for (const id of requestedEnable) {
+        const current = groupIndex.get(id);
+        // Skip unknown groups and groups already enabled.
+        if (!current || current.enabled) {
+            continue;
+        }
+        toEnable.push(id);
+    }
+    for (const id of requestedDisable) {
+        const current = groupIndex.get(id);
+        if (!current?.enabled) {
+            continue;
+        }
+        toDisable.push(id);
+    }
+    return { toEnable, toDisable };
+}
+function buildStackSet(detectedStack) {
+    const set = new Set();
+    for (const entry of detectedStack) {
+        if (typeof entry === 'string' && entry.length > 0) {
+            set.add(entry.toLowerCase());
+        }
+    }
+    return set;
+}
+function collectGroupIds(profiles, key) {
+    const ids = new Set();
+    for (const profile of profiles) {
+        for (const id of profile[key]) {
+            if (typeof id === 'string' && id.length > 0) {
+                ids.add(id);
+            }
+        }
+    }
+    return ids;
+}
+function indexGroups(groups) {
+    const map = new Map();
+    for (const g of groups) {
+        map.set(g.id, g);
+    }
+    return map;
+}
+//# sourceMappingURL=stack-activator.js.map

package/dist/engine/tool-groups/tier-manager.d.ts

@@ -0,0 +1,25 @@
+import type { TierDefinition, ToolTierId } from '../../types/tool-tier.js';
+import type { GroupManager } from './group-manager.js';
+/**
+ * SPEC-652: Manages Core/Domain/Power tier activation on top of GroupManager.
+ * Core tier groups are always enabled. Domain and Power tiers start disabled
+ * (lazy) and activate on demand via activateTier().
+ */
+export declare class TierManager {
+    private readonly config;
+    private readonly groupManager;
+    constructor(groupManager: GroupManager);
+    /** Disable all lazyLoad tier groups after GroupManager.init(). */
+    init(): Promise<void>;
+    /** Enable all groups belonging to the specified tier. */
+    activateTier(tierId: ToolTierId): void;
+    /** Get the tier definition by ID, or null if not found. */
+    getTier(tierId: ToolTierId): TierDefinition | null;
+    /** Resolve which tier a given group belongs to. Returns null if not mapped. */
+    getTierForGroup(groupId: string): ToolTierId | null;
+    /** All tier definitions. */
+    getTiers(): TierDefinition[];
+}
+export declare function setTierManager(tm: TierManager): void;
+export declare function getTierManager(): TierManager | null;
+//# sourceMappingURL=tier-manager.d.ts.map

package/dist/engine/tool-groups/tier-manager.js

@@ -0,0 +1,62 @@
+import tierRegistryJson from '../../config/tool-tier-registry.json' with { type: 'json' };
+const config = tierRegistryJson;
+/**
+ * SPEC-652: Manages Core/Domain/Power tier activation on top of GroupManager.
+ * Core tier groups are always enabled. Domain and Power tiers start disabled
+ * (lazy) and activate on demand via activateTier().
+ */
+export class TierManager {
+    config;
+    groupManager;
+    constructor(groupManager) {
+        this.config = config;
+        this.groupManager = groupManager;
+    }
+    /** Disable all lazyLoad tier groups after GroupManager.init(). */
+    async init() {
+        for (const tier of this.config.tiers) {
+            if (!tier.lazyLoad) {
+                continue;
+            }
+            for (const groupId of tier.groups) {
+                this.groupManager.disableGroup(groupId);
+            }
+        }
+        await Promise.resolve();
+    }
+    /** Enable all groups belonging to the specified tier. */
+    activateTier(tierId) {
+        const tier = this.config.tiers.find((t) => t.id === tierId);
+        if (!tier) {
+            return;
+        }
+        for (const groupId of tier.groups) {
+            this.groupManager.enableGroup(groupId);
+        }
+    }
+    /** Get the tier definition by ID, or null if not found. */
+    getTier(tierId) {
+        return this.config.tiers.find((t) => t.id === tierId) ?? null;
+    }
+    /** Resolve which tier a given group belongs to. Returns null if not mapped. */
+    getTierForGroup(groupId) {
+        for (const tier of this.config.tiers) {
+            if (tier.groups.includes(groupId)) {
+                return tier.id;
+            }
+        }
+        return null;
+    }
+    /** All tier definitions. */
+    getTiers() {
+        return [...this.config.tiers];
+    }
+}
+let _tierManager = null;
+export function setTierManager(tm) {
+    _tierManager = tm;
+}
+export function getTierManager() {
+    return _tierManager;
+}
+//# sourceMappingURL=tier-manager.js.map

package/dist/engine/triagier/classifier.d.ts

@@ -0,0 +1,27 @@
+import type { TriageKind, TriageRequestInput, TriageResult } from '../../types/triagier.js';
+interface HeuristicResult {
+    kind: TriageKind;
+    confidence: number;
+    rationale: string;
+}
+/**
+ * Rule-based classifier using simple regex heuristics.
+ * Provides a fast, free, deterministic fallback when Haiku is unavailable.
+ *
+ * Rules (first match wins):
+ *   "what if" / "someday" / "imagine"       → idea
+ *   "fix typo" / "rename" / "typo"          → quick-fix
+ *   "bug" / "error" / "crash" / "broken"    → bug-spec
+ *   "add" / "implement" / "integrate" / ... → feature-spec
+ *   "epic" / "platform" / "migrate"         → epic
+ *   (default)                               → feature-spec
+ */
+export declare function heuristicClassify(description: string): HeuristicResult;
+/**
+ * Classify the intent of a user request into a TriageKind.
+ * Wraps the LLM call (or heuristic) in a cost guard (5s wall-clock).
+ * On guard trip, returns a safe fallback (feature-spec, confidence 0.5, rationale GUARD_FALLBACK).
+ */
+export declare function classifyIntent(input: TriageRequestInput): Promise<TriageResult>;
+export {};
+//# sourceMappingURL=classifier.d.ts.map

package/dist/engine/triagier/classifier.js

@@ -0,0 +1,127 @@
+// engine/triagier/classifier.ts — SPEC-726: Haiku-backed intent classifier
+//
+// If an LLM provider is available, calls Haiku for classification.
+// Falls back to a deterministic heuristic classifier on timeout, error, or
+// when no provider is configured.
+import { runWithGuard } from './cost-guard.js';
+import { routeToNextStep } from './router.js';
+/**
+ * Rule-based classifier using simple regex heuristics.
+ * Provides a fast, free, deterministic fallback when Haiku is unavailable.
+ *
+ * Rules (first match wins):
+ *   "what if" / "someday" / "imagine"       → idea
+ *   "fix typo" / "rename" / "typo"          → quick-fix
+ *   "bug" / "error" / "crash" / "broken"    → bug-spec
+ *   "add" / "implement" / "integrate" / ... → feature-spec
+ *   "epic" / "platform" / "migrate"         → epic
+ *   (default)                               → feature-spec
+ */
+export function heuristicClassify(description) {
+    const lower = description.toLowerCase();
+    if (/what if|someday|imagine|wouldn't it be|could we ever/.test(lower)) {
+        return {
+            kind: 'idea',
+            confidence: 0.75,
+            rationale: 'Description uses speculative language ("what if", "someday") indicating an exploratory idea rather than a concrete feature request.',
+        };
+    }
+    if (/fix\s+typo|\brename\b|typo|s\/\w+\/\w+|spelling|whitespace|minor\s+fix|small\s+fix/.test(lower)) {
+        return {
+            kind: 'quick-fix',
+            confidence: 0.8,
+            rationale: 'Description describes a small, self-contained change (typo, rename, whitespace) that can be implemented directly without requirements elicitation.',
+        };
+    }
+    if (/\bbugs?\b|\berrors?\b|\bcrash(es|ed|ing)?\b|\bbroken\b|\bfails?\b|\bdoes not work\b|\bisn't working\b/.test(lower)) {
+        return {
+            kind: 'bug-spec',
+            confidence: 0.75,
+            rationale: 'Description contains bug-related keywords (bug, error, crash, broken) indicating a defect that needs a formal bug spec.',
+        };
+    }
+    if (/\bepic\b|\bplatform\b|\bmigrat(e|ion)\b|\boverhaul\b|\brewrite\b|\brefactor\s+entire\b/.test(lower)) {
+        return {
+            kind: 'epic',
+            confidence: 0.7,
+            rationale: 'Description involves large-scale structural changes or platform-level work indicating an epic.',
+        };
+    }
+    if (/\badd\b|\bimplement\b|\bintegrat(e|ion)\b|\bbuild\b|\bcreate\b|\bintroduce\b|\bsupport\b/.test(lower)) {
+        return {
+            kind: 'feature-spec',
+            confidence: 0.7,
+            rationale: 'Description uses feature-oriented verbs (add, implement, integrate, build) indicating a standard feature spec.',
+        };
+    }
+    // Default
+    return {
+        kind: 'feature-spec',
+        confidence: 0.5,
+        rationale: 'Could not confidently classify from description alone; defaulting to feature-spec for further elicitation.',
+    };
+}
+// ---------------------------------------------------------------------------
+// GUARD_FALLBACK constant
+// ---------------------------------------------------------------------------
+const GUARD_FALLBACK_RESULT = {
+    kind: 'feature-spec',
+    confidence: 0.5,
+    rationale: 'GUARD_FALLBACK',
+    nextStep: { tool: 'elicit_requirements', mode: 'interactive' },
+};
+// ---------------------------------------------------------------------------
+// LLM-backed classifier (stub — uses heuristic until Haiku adapter is wired)
+// ---------------------------------------------------------------------------
+/**
+ * Try to classify using an LLM provider (Haiku-class).
+ * Currently implemented as a deterministic heuristic because no Haiku API
+ * adapter is wired in src/engine/llm-providers/. When a Haiku transport is
+ * available, replace this stub with a real call. The interface is unchanged.
+ *
+ * Architectural note: the spec says "If LLM provider unavailable, use
+ * deterministic heuristic as fallback." We document the stub explicitly and
+ * wrap it in runWithGuard so the timeout/fallback path is always exercised
+ * correctly when a real LLM call is wired in.
+ */
+// eslint-disable-next-line @typescript-eslint/require-await -- async signature required by cost-guard interface
+async function tryLlmClassify(input) {
+    // TODO: Wire real Haiku call here when llm-providers has a text-generation adapter.
+    // For now: deterministic heuristic (same result, no API cost).
+    return heuristicClassify(input.description);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Classify the intent of a user request into a TriageKind.
+ * Wraps the LLM call (or heuristic) in a cost guard (5s wall-clock).
+ * On guard trip, returns a safe fallback (feature-spec, confidence 0.5, rationale GUARD_FALLBACK).
+ */
+export async function classifyIntent(input) {
+    // Respect any hint provided by the caller
+    if (input.hint?.kind) {
+        const hintKind = input.hint.kind;
+        return {
+            kind: hintKind,
+            confidence: 1.0,
+            rationale: `Hint provided by caller: ${hintKind}`,
+            nextStep: routeToNextStep(hintKind),
+        };
+    }
+    const guardResult = await runWithGuard(() => tryLlmClassify(input), {
+        wallClockMs: 5_000,
+        maxOutputTokens: 1_500,
+    });
+    if ('fallback' in guardResult) {
+        return GUARD_FALLBACK_RESULT;
+    }
+    const { kind, confidence, rationale } = guardResult;
+    return {
+        kind,
+        confidence,
+        rationale,
+        nextStep: routeToNextStep(kind),
+    };
+}
+//# sourceMappingURL=classifier.js.map

package/dist/engine/triagier/cost-guard.d.ts

@@ -0,0 +1,19 @@
+export interface CostGuardOpts {
+    /** Maximum wall-clock time in milliseconds before fallback (default 5000) */
+    wallClockMs?: number;
+    /** Maximum output tokens before fallback (unused for deterministic path but documented) */
+    maxOutputTokens?: number;
+}
+export interface FallbackResult {
+    fallback: true;
+}
+/**
+ * Run `fn` under a wall-clock timeout.
+ * If fn completes within the deadline → return its result.
+ * If fn exceeds the deadline → return { fallback: true } and emit telemetry.
+ *
+ * Note: the in-flight promise from fn is not cancelled (JS has no cancellation primitives),
+ * but callers will receive the fallback immediately and can ignore the late result.
+ */
+export declare function runWithGuard<T>(fn: () => Promise<T>, opts?: CostGuardOpts): Promise<T | FallbackResult>;
+//# sourceMappingURL=cost-guard.d.ts.map

package/dist/engine/triagier/cost-guard.js

@@ -0,0 +1,50 @@
+// engine/triagier/cost-guard.ts — SPEC-726: Wall-clock + token budget guard for Haiku calls
+/**
+ * Run `fn` under a wall-clock timeout.
+ * If fn completes within the deadline → return its result.
+ * If fn exceeds the deadline → return { fallback: true } and emit telemetry.
+ *
+ * Note: the in-flight promise from fn is not cancelled (JS has no cancellation primitives),
+ * but callers will receive the fallback immediately and can ignore the late result.
+ */
+export async function runWithGuard(fn, opts) {
+    const wallClockMs = opts?.wallClockMs ?? 5_000;
+    const TIMEOUT_SENTINEL = Symbol('timeout');
+    const timeoutRace = new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(TIMEOUT_SENTINEL);
+        }, wallClockMs);
+    });
+    let result;
+    try {
+        result = await Promise.race([fn(), timeoutRace]);
+    }
+    catch (err) {
+        // fn threw — emit telemetry and return fallback
+        console.warn('[triagier:cost-guard] fn_threw', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        emitGuardTelemetry('fn_threw');
+        return { fallback: true };
+    }
+    if (result === TIMEOUT_SENTINEL) {
+        console.warn('[triagier:cost-guard] wall_clock_timeout', { wallClockMs });
+        emitGuardTelemetry('wall_clock_timeout');
+        return { fallback: true };
+    }
+    return result;
+}
+function emitGuardTelemetry(reason) {
+    // Best-effort telemetry — fire and forget, never throw
+    try {
+        // eslint-disable-next-line no-console -- intentional best-effort telemetry; no telemetry client available in this context
+        console.info('[triagier] triage_guard_tripped', {
+            reason,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch {
+        // ignore
+    }
+}
+//# sourceMappingURL=cost-guard.js.map

package/dist/engine/triagier/index.d.ts

@@ -0,0 +1,5 @@
+export { classifyIntent, heuristicClassify } from './classifier.js';
+export { routeToNextStep } from './router.js';
+export { runWithGuard } from './cost-guard.js';
+export type { CostGuardOpts, FallbackResult } from './cost-guard.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/triagier/index.js

@@ -0,0 +1,5 @@
+// engine/triagier/index.ts — SPEC-726: Public API for the Triagier engine
+export { classifyIntent, heuristicClassify } from './classifier.js';
+export { routeToNextStep } from './router.js';
+export { runWithGuard } from './cost-guard.js';
+//# sourceMappingURL=index.js.map

package/dist/engine/triagier/router.d.ts

@@ -0,0 +1,13 @@
+import type { TriageKind, TriageNextStep } from '../../types/triagier.js';
+/**
+ * Given a classified triage kind, return the routing hint for the next tool.
+ *
+ * Routing rules:
+ *   idea        → capture_idea (backlog, no spec)
+ *   quick-fix   → implement_plan (direct, ~10 min)
+ *   bug-spec    → elicit_requirements (interactive)
+ *   feature-spec→ elicit_requirements (interactive)
+ *   epic        → elicit_requirements (interactive)
+ */
+export declare function routeToNextStep(kind: TriageKind): TriageNextStep;
+//# sourceMappingURL=router.d.ts.map

package/dist/engine/triagier/router.js

@@ -0,0 +1,27 @@
+// engine/triagier/router.ts — SPEC-726: Route triage kind to next tool
+/**
+ * Given a classified triage kind, return the routing hint for the next tool.
+ *
+ * Routing rules:
+ *   idea        → capture_idea (backlog, no spec)
+ *   quick-fix   → implement_plan (direct, ~10 min)
+ *   bug-spec    → elicit_requirements (interactive)
+ *   feature-spec→ elicit_requirements (interactive)
+ *   epic        → elicit_requirements (interactive)
+ */
+export function routeToNextStep(kind) {
+    switch (kind) {
+        case 'idea':
+            return { tool: 'capture_idea' };
+        case 'quick-fix':
+            return { tool: 'implement_plan', mode: 'direct', estimatedMinutes: 10 };
+        case 'bug-spec':
+        case 'feature-spec':
+        case 'epic':
+            return { tool: 'elicit_requirements', mode: 'interactive' };
+        default:
+            // unreachable in well-typed callers; default to interactive elicitation
+            return { tool: 'elicit_requirements', mode: 'interactive' };
+    }
+}
+//# sourceMappingURL=router.js.map

package/dist/engine/trial-engine.d.ts

@@ -0,0 +1,5 @@
+export declare function getInstallationId(): string;
+export declare function getTrialStatus(_projectId?: string): null;
+export declare function isTrialActive(_projectId?: string): boolean;
+export declare function requestTrial(_projectId?: string): Promise<void>;
+//# sourceMappingURL=trial-engine.d.ts.map