@karmaniverous/jeeves-meta 0.15.4 → 0.15.5

package/dist/lock.d.ts

@@ -0,0 +1,70 @@
+/**
+ * File-system lock for preventing concurrent synthesis on the same meta.
+ *
+ * Lock file: .meta/.lock containing `_lockPid` + `_lockStartedAt` (underscore-prefixed
+ * reserved keys, consistent with meta.json conventions).
+ * Stale timeout: 30 minutes.
+ *
+ * @module lock
+ */
+/**
+ * Resolve a path to a .meta directory.
+ *
+ * If the path already ends with '.meta', returns it as-is.
+ * Otherwise, appends '.meta' as a subdirectory.
+ *
+ * @param inputPath - Path that may or may not end with '.meta'.
+ * @returns The resolved .meta directory path.
+ */
+export declare function resolveMetaDir(inputPath: string): string;
+/** Parsed state of a .lock file. */
+export interface LockState {
+    /** Whether the lock file exists. */
+    exists: boolean;
+    /** Whether the lock contains a staged synthesis result. */
+    staged: boolean;
+    /** Whether the lock is actively held (non-stale PID lock). */
+    active: boolean;
+    /** Raw parsed data, or null if missing/corrupt. */
+    data: Record<string, unknown> | null;
+}
+/**
+ * Read and classify the state of a .meta/.lock file.
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns Parsed lock state.
+ */
+export declare function readLockState(metaPath: string): LockState;
+/**
+ * Attempt to acquire a lock on a .meta directory.
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns True if lock was acquired, false if already locked (non-stale).
+ */
+export declare function acquireLock(metaPath: string): boolean;
+/**
+ * Release a lock on a .meta directory.
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ */
+export declare function releaseLock(metaPath: string): void;
+/**
+ * Check if a .meta directory is currently locked (non-stale).
+ *
+ * @param metaPath - Absolute path to the .meta directory.
+ * @returns True if locked and not stale.
+ */
+export declare function isLocked(metaPath: string): boolean;
+/**
+ * Clean up stale lock files on startup.
+ *
+ * For each .meta directory found via the provided paths:
+ * - If lock contains PID-only data (synthesis incomplete), delete it.
+ * - If lock contains staged result (_id present), log warning and delete.
+ *
+ * @param metaPaths - Array of .meta directory paths to check.
+ * @param logger - Optional logger for warnings.
+ */
+export declare function cleanupStaleLocks(metaPaths: string[], logger?: {
+    warn: (obj: Record<string, unknown>, msg: string) => void;
+}): void;

package/dist/logger/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pino logger factory.
+ *
+ * @module logger
+ */
+import pino from 'pino';
+/** Minimal logger interface accepted by library functions. */
+export interface MinimalLogger {
+    debug: (obj: Record<string, unknown>, msg: string) => void;
+    info: (obj: Record<string, unknown>, msg: string) => void;
+    warn: (obj: Record<string, unknown>, msg: string) => void;
+    error: (obj: Record<string, unknown>, msg: string) => void;
+}
+/** Logger configuration options. */
+export interface LoggerConfig {
+    /** Log level (default: 'info'). */
+    level?: string;
+    /** Optional file path to write logs to. */
+    file?: string;
+}
+/**
+ * Create a pino logger instance.
+ *
+ * @param config - Optional logger configuration.
+ * @returns Configured pino logger.
+ */
+export declare function createLogger(config?: LoggerConfig): pino.Logger;

package/dist/mtimeFilter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Filter file paths by modification time.
+ *
+ * Shared utility for staleness detection and delta file enumeration.
+ * Uses `fs.statSync` for fast local mtime checks on known paths.
+ *
+ * @module mtimeFilter
+ */
+/**
+ * Check if any file in the list was modified after the given timestamp.
+ *
+ * Short-circuits on first match for efficiency (staleness checks).
+ *
+ * @param files - Array of file paths to check.
+ * @param afterMs - Timestamp in milliseconds. Files with `mtimeMs > afterMs` match.
+ * @returns True if any file was modified after the timestamp.
+ */
+export declare function hasModifiedAfter(files: string[], afterMs: number): boolean;
+/**
+ * Filter files to only those modified after the given timestamp.
+ *
+ * @param files - Array of file paths to filter.
+ * @param afterMs - Timestamp in milliseconds. Files with `mtimeMs > afterMs` are included.
+ * @returns Filtered array of file paths.
+ */
+export declare function filterModifiedAfter(files: string[], afterMs: number): string[];

package/dist/normalizePath.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-export normalizePath from core.
+ *
+ * @module normalizePath
+ */
+export { normalizePath } from '@karmaniverous/jeeves-meta-core';

package/dist/orchestrator/buildTask.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Build task prompts for each synthesis step.
+ *
+ * Prompts are compiled as Handlebars templates with access to config,
+ * meta, and scope context. The architect can write template expressions
+ * into its _builder output; these resolve when the builder task is compiled.
+ *
+ * @module orchestrator/buildTask
+ */
+import type { MetaContext } from '../interfaces/index.js';
+import type { MetaConfig, MetaJson } from '../schema/index.js';
+/**
+ * Build the architect task prompt.
+ *
+ * @param ctx - Synthesis context.
+ * @param meta - Current meta.json.
+ * @param config - Synthesis config.
+ * @returns The architect task prompt string.
+ */
+export declare function buildArchitectTask(ctx: MetaContext, meta: MetaJson, config: MetaConfig): string;
+/**
+ * Build the builder task prompt.
+ *
+ * @param ctx - Synthesis context.
+ * @param meta - Current meta.json.
+ * @param config - Synthesis config.
+ * @returns The builder task prompt string.
+ */
+export declare function buildBuilderTask(ctx: MetaContext, meta: MetaJson, config: MetaConfig): string;
+/**
+ * Build the critic task prompt.
+ *
+ * @param ctx - Synthesis context.
+ * @param meta - Current meta.json (with _content already set by builder).
+ * @param config - Synthesis config.
+ * @returns The critic task prompt string.
+ */
+export declare function buildCriticTask(ctx: MetaContext, meta: MetaJson, config: MetaConfig): string;

package/dist/orchestrator/contextPackage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Build the MetaContext for a synthesis cycle.
+ *
+ * Computes shared inputs once: scope files, delta files, child meta outputs,
+ * previous content/feedback, steer, and archive paths.
+ *
+ * @module orchestrator/contextPackage
+ */
+import { type MetaNode } from '../discovery/index.js';
+import type { MetaContext, WatcherClient } from '../interfaces/index.js';
+import type { MinimalLogger } from '../logger/index.js';
+import type { MetaJson } from '../schema/index.js';
+/**
+ * Condense a file list into glob-like summaries.
+ * Groups by directory + extension pattern.
+ *
+ * @param files - Array of file paths.
+ * @param maxIndividual - Show individual files up to this count.
+ * @returns Condensed summary string.
+ */
+export declare function condenseScopeFiles(files: string[], maxIndividual?: number): string;
+/**
+ * Build the context package for a synthesis cycle.
+ *
+ * @param node - The meta node being synthesized.
+ * @param meta - Current meta.json content.
+ * @param watcher - WatcherClient for scope enumeration.
+ * @returns The computed context package.
+ */
+export declare function buildContextPackage(node: MetaNode, meta: MetaJson, watcher: WatcherClient, logger?: MinimalLogger): Promise<MetaContext>;

package/dist/orchestrator/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Orchestrator module — the main synthesis cycle.
+ *
+ * @module orchestrator
+ */
+export { buildArchitectTask, buildBuilderTask, buildCriticTask, } from './buildTask.js';
+export { buildContextPackage } from './contextPackage.js';
+export { orchestratePhase, type OrchestratePhaseResult, type PhaseProgressCallback, } from './orchestratePhase.js';
+export { type BuilderOutput, parseArchitectOutput, parseBuilderOutput, parseCriticOutput, } from './parseOutput.js';
+export { type PhaseResult, runArchitect, runBuilder, runCritic, } from './runPhase.js';

package/dist/orchestrator/orchestratePhase.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Phase-aware orchestration entry point.
+ *
+ * Replaces the old staleness-based orchestrate() with phase-state-machine
+ * scheduling: each tick discovers all metas, computes invalidation,
+ * auto-retries failed phases, selects the best phase candidate, and
+ * executes exactly one phase.
+ *
+ * @module orchestrator/orchestratePhase
+ */
+import type { MetaExecutor, WatcherClient } from '../interfaces/index.js';
+import type { MinimalLogger } from '../logger/index.js';
+import type { ProgressEvent } from '../progress/index.js';
+import type { MetaConfig, PhaseName } from '../schema/index.js';
+import { type PhaseResult } from './runPhase.js';
+/** Callback for synthesis progress events. */
+export type PhaseProgressCallback = (event: ProgressEvent) => void | Promise<void>;
+/** Result of a single phase-aware orchestration tick. */
+export interface OrchestratePhaseResult {
+    /** Whether a phase was executed. */
+    executed: boolean;
+    /** Path to the meta that was selected. */
+    metaPath?: string;
+    /** Which phase was run. */
+    phase?: PhaseName;
+    /** The phase result (if executed). */
+    phaseResult?: PhaseResult;
+    /** Whether a full synthesis cycle completed (all phases fresh). */
+    cycleComplete?: boolean;
+}
+/**
+ * Run a single phase-aware orchestration tick.
+ *
+ * When targetPath is provided (override entry), runs the owed phase for
+ * that specific meta. Otherwise, discovers all metas, computes invalidation,
+ * and selects the best phase candidate corpus-wide.
+ */
+export declare function orchestratePhase(config: MetaConfig, executor: MetaExecutor, watcher: WatcherClient, targetPath?: string, onProgress?: PhaseProgressCallback, logger?: MinimalLogger): Promise<OrchestratePhaseResult>;

package/dist/orchestrator/parseOutput.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Parse subprocess outputs for each synthesis step.
+ *
+ * - Architect: returns text \> _builder
+ * - Builder: returns JSON \> _content + structured fields
+ * - Critic: returns text \> _feedback
+ *
+ * @module orchestrator/parseOutput
+ */
+/** Parsed builder output. */
+export interface BuilderOutput {
+    /** Narrative synthesis content. */
+    content: string;
+    /** Additional structured fields (non-underscore keys). */
+    fields: Record<string, unknown>;
+    /** Opaque state for progressive synthesis, if provided by the builder. */
+    state?: unknown;
+}
+/**
+ * Parse architect output. The architect returns a task brief as text.
+ *
+ * @param output - Raw subprocess output.
+ * @returns The task brief string.
+ */
+export declare function parseArchitectOutput(output: string): string;
+/**
+ * Parse builder output. The builder returns JSON with _content and optional fields.
+ *
+ * Attempts JSON parse first. If that fails, treats the entire output as _content.
+ *
+ * @param output - Raw subprocess output.
+ * @returns Parsed builder output with content and structured fields.
+ */
+export declare function parseBuilderOutput(output: string): BuilderOutput;
+/**
+ * Parse critic output. The critic returns evaluation text.
+ *
+ * @param output - Raw subprocess output.
+ * @returns The feedback string.
+ */
+export declare function parseCriticOutput(output: string): string;

package/dist/orchestrator/runPhase.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Per-phase executors for the phase-state machine.
+ *
+ * Each function runs exactly one phase on one meta, updates _phaseState
+ * via pure transitions, and persists via the lock-staged write.
+ *
+ * @module orchestrator/runPhase
+ */
+import type { MetaNode } from '../discovery/index.js';
+import type { MetaExecutor, WatcherClient } from '../interfaces/index.js';
+import type { MinimalLogger } from '../logger/index.js';
+import type { ProgressEvent } from '../progress/index.js';
+import type { MetaConfig, MetaError, MetaJson, PhaseState } from '../schema/index.js';
+/** Callback for synthesis progress events. */
+export type ProgressCallback = (event: ProgressEvent) => void | Promise<void>;
+/** Result of running a single phase. */
+export interface PhaseResult {
+    /** Whether the phase executed (vs. was skipped). */
+    executed: boolean;
+    /** Updated phase state after execution. */
+    phaseState: PhaseState;
+    /** Updated meta.json content (if written). */
+    updatedMeta?: MetaJson;
+    /** Error if the phase failed. */
+    error?: MetaError;
+    /** Whether the full cycle is now complete (all phases fresh). */
+    cycleComplete?: boolean;
+}
+/** Shared base options for all finalize calls. */
+export interface FinalizeBase {
+    metaPath: string;
+    current: MetaJson;
+    config: MetaConfig;
+    structureHash: string;
+}
+/** Write updated meta with phase state via lock staging. */
+export declare function persistPhaseState(base: FinalizeBase, phaseState: PhaseState, updates: Partial<MetaJson>): Promise<MetaJson>;
+export declare function runArchitect(node: MetaNode, currentMeta: MetaJson, phaseState: PhaseState, config: MetaConfig, executor: MetaExecutor, watcher: WatcherClient, structureHash: string, onProgress?: ProgressCallback, logger?: MinimalLogger): Promise<PhaseResult>;
+export declare function runBuilder(node: MetaNode, currentMeta: MetaJson, phaseState: PhaseState, config: MetaConfig, executor: MetaExecutor, watcher: WatcherClient, structureHash: string, onProgress?: ProgressCallback, logger?: MinimalLogger): Promise<PhaseResult>;
+export declare function runCritic(node: MetaNode, currentMeta: MetaJson, phaseState: PhaseState, config: MetaConfig, executor: MetaExecutor, watcher: WatcherClient, structureHash: string, onProgress?: ProgressCallback, logger?: MinimalLogger): Promise<PhaseResult>;

package/dist/phaseState/derivePhaseState.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Backward-compatible derivation of _phaseState from existing meta fields.
+ *
+ * When a meta is loaded from disk without _phaseState, this reconstructs
+ * the phase state from _content, _builder, _state, _error.step, and
+ * the architect-invalidating inputs.
+ *
+ * @module phaseState/derivePhaseState
+ */
+import type { MetaJson, PhaseState } from '../schema/index.js';
+/** Inputs needed to determine architect invalidation for derivation. */
+export interface DerivationInputs {
+    /** Whether _structureHash has changed vs. computed value. */
+    structureChanged: boolean;
+    /** Whether _steer changed vs. latest archive. */
+    steerChanged: boolean;
+    /** Whether _architect prompt changed. */
+    architectChanged: boolean;
+    /** Whether _crossRefs declaration changed. */
+    crossRefsChanged: boolean;
+    /** architectEvery config value. */
+    architectEvery: number;
+}
+/**
+ * Derive _phaseState from existing meta fields.
+ *
+ * If the meta already has _phaseState, returns it as-is.
+ *
+ * Otherwise, reconstructs from available fields:
+ * - Never-synthesized meta (no _content, no _builder): all phases start pending/stale.
+ * - Errored meta: the failed phase is mapped from _error.step.
+ * - Mid-cycle meta with cached _builder but no _content: builder pending.
+ * - Fully-fresh meta: all phases fresh.
+ * - Meta with stale architect inputs: architect pending, downstream stale.
+ *
+ * @param meta - The meta.json content.
+ * @param inputs - Optional derivation inputs. If not provided, a simpler
+ *   heuristic is used (no architect invalidation check).
+ * @returns The derived PhaseState.
+ */
+export declare function derivePhaseState(meta: MetaJson, inputs?: DerivationInputs): PhaseState;

package/dist/phaseState/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Phase-state machine module.
+ *
+ * @module phaseState
+ */
+export { type DerivationInputs, derivePhaseState } from './derivePhaseState.js';
+export { type ArchitectInvalidator, computeInvalidation, type InvalidationResult, type StalenessInputs, } from './invalidate.js';
+export { buildPhaseCandidates, type PhaseCandidate, type PhaseCandidateInput, rankPhaseCandidates, selectPhaseCandidate, } from './phaseScheduler.js';
+export { architectSuccess, builderSuccess, criticSuccess, enforceInvariant, freshPhaseState, getOwedPhase, getPriorityBand, initialPhaseState, invalidateArchitect, invalidateBuilder, isFullyFresh, phaseFailed, phaseRunning, retryAllFailed, retryPhase, } from './phaseTransitions.js';

package/dist/phaseState/invalidate.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Per-tick invalidation pass.
+ *
+ * Computes architect-invalidating and builder-invalidating inputs for a meta,
+ * then applies the cascade to update _phaseState.
+ *
+ * @module phaseState/invalidate
+ */
+import type { MetaNode } from '../discovery/types.js';
+import type { MetaConfig, MetaJson, PhaseState } from '../schema/index.js';
+/** Architect-level invalidation reasons. */
+export type ArchitectInvalidator = 'structureHash' | 'steer' | '_architect' | '_crossRefs' | 'architectEvery';
+/** Staleness inputs for a meta (exposed in /preview). */
+export interface StalenessInputs {
+    structureHash: string;
+    steerChanged: boolean;
+    architectChanged: boolean;
+    crossRefsDeclChanged: boolean;
+    scopeMtimeMax: string | null;
+    crossRefContentChanged: boolean;
+}
+/** Result of computing invalidation for a single meta. */
+export interface InvalidationResult {
+    phaseState: PhaseState;
+    architectInvalidators: ArchitectInvalidator[];
+    stalenessInputs: StalenessInputs;
+    structureHash: string;
+    steerChanged: boolean;
+}
+/**
+ * Compute invalidation inputs and apply cascade for a single meta.
+ *
+ * @param meta - Current meta.json content with existing _phaseState.
+ * @param scopeFiles - Sorted file list from scope.
+ * @param config - MetaConfig for architectEvery.
+ * @param node - MetaNode for archive access.
+ * @param crossRefMetas - Map of cross-ref owner paths to their current _content.
+ * @param archiveCrossRefContent - Map of cross-ref owner paths to their archived _content.
+ * @returns Updated phase state and invalidation details.
+ */
+export declare function computeInvalidation(meta: MetaJson, scopeFiles: string[], config: MetaConfig, node: MetaNode, crossRefMetas?: Map<string, string | undefined>, archiveCrossRefContent?: Map<string, string | undefined>): Promise<InvalidationResult>;

package/dist/phaseState/phaseScheduler.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Corpus-wide phase scheduler.
+ *
+ * Selects the highest-priority ready phase across all metas.
+ * Priority: critic (band 1) \> builder (band 2) \> architect (band 3).
+ * Tiebreak within band: weighted staleness (§3.9).
+ *
+ * @module phaseState/phaseScheduler
+ */
+import type { MetaEntry } from '../discovery/listMetas.js';
+import type { MetaNode } from '../discovery/types.js';
+import type { MetaJson, PhaseName, PhaseState } from '../schema/index.js';
+/** Input for phase candidate selection (from listMetas entries). */
+export interface PhaseCandidateInput {
+    node: MetaNode;
+    meta: MetaJson;
+    phaseState: PhaseState;
+    actualStaleness: number;
+    locked: boolean;
+    disabled: boolean;
+    isOverride?: boolean;
+}
+/**
+ * Build phase candidates from listMetas entries.
+ *
+ * Derives phase state, auto-retries failed phases, and applies Tier 1
+ * cheap-invalidation (no I/O) for metas with persisted _phaseState.
+ * Used by orchestratePhase, queue route, and status route.
+ */
+export declare function buildPhaseCandidates(entries: MetaEntry[], architectEvery: number): PhaseCandidateInput[];
+/** A candidate for phase-level scheduling. */
+export interface PhaseCandidate {
+    node: MetaNode;
+    meta: MetaJson;
+    phaseState: PhaseState;
+    owedPhase: PhaseName;
+    band: 1 | 2 | 3;
+    actualStaleness: number;
+    effectiveStaleness: number;
+}
+/**
+ * Rank all eligible phase candidates by priority.
+ *
+ * Filters to pending phases, computes effective staleness, and sorts by
+ * band (ascending: critic first) then effective staleness (descending).
+ *
+ * Used by selectPhaseCandidate (returns first) and the queue route (returns all).
+ */
+export declare function rankPhaseCandidates(metas: PhaseCandidateInput[], depthWeight: number): PhaseCandidate[];
+/**
+ * Select the best phase candidate across the corpus.
+ *
+ * @param metas - Array of (node, meta, phaseState, stalenessSeconds) tuples.
+ * @param depthWeight - Config depthWeight for staleness tiebreak.
+ * @returns The winning candidate, or null if no phase is ready.
+ */
+export declare function selectPhaseCandidate(metas: PhaseCandidateInput[], depthWeight: number): PhaseCandidate | null;

package/dist/phaseState/phaseTransitions.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Pure phase-state transition functions.
+ *
+ * Implements every row of the §8 "Transitions and invalidation cascade" table.
+ * No I/O — pure functions over PhaseState and documented inputs.
+ *
+ * @module phaseState/phaseTransitions
+ */
+import type { PhaseState } from '../schema/meta.js';
+/**
+ * Create a fresh (fully-complete) phase state.
+ */
+export declare function freshPhaseState(): PhaseState;
+/**
+ * Create a phase state for a never-synthesized meta (all pending from architect).
+ */
+export declare function initialPhaseState(): PhaseState;
+/**
+ * Enforce the per-meta invariant: at most one phase is pending or running,
+ * and it is the first non-fresh phase in pipeline order.
+ *
+ * Stale phases that become the first non-fresh phase are promoted to pending.
+ */
+export declare function enforceInvariant(state: PhaseState): PhaseState;
+/**
+ * Architect invalidated: architect → pending; builder, critic → stale.
+ * Triggers: _structureHash change, _steer change, _architect change,
+ * _crossRefs declaration change, _synthesisCount \>= architectEvery.
+ */
+export declare function invalidateArchitect(state: PhaseState): PhaseState;
+/**
+ * Builder invalidated (scope mtime or cross-ref _content change):
+ * builder → pending; critic → stale.
+ * Only applies when architect is fresh; otherwise, builder stays stale.
+ */
+export declare function invalidateBuilder(state: PhaseState): PhaseState;
+/**
+ * Architect completes successfully.
+ * architect → fresh; builder → pending; critic → stale.
+ */
+export declare function architectSuccess(state: PhaseState): PhaseState;
+/**
+ * Builder completes successfully.
+ * builder → fresh; critic → pending.
+ */
+export declare function builderSuccess(state: PhaseState): PhaseState;
+/**
+ * Critic completes successfully.
+ * critic → fresh. Meta becomes fully fresh.
+ */
+export declare function criticSuccess(state: PhaseState): PhaseState;
+/**
+ * A phase fails (error, timeout, or abort).
+ * Target phase → failed; upstream and downstream unchanged.
+ */
+export declare function phaseFailed(state: PhaseState, phase: 'architect' | 'builder' | 'critic'): PhaseState;
+/**
+ * Retry a failed phase: failed → pending.
+ * Only valid when the phase is currently failed.
+ */
+export declare function retryPhase(state: PhaseState, phase: 'architect' | 'builder' | 'critic'): PhaseState;
+/**
+ * Retry all failed phases: each failed phase → pending.
+ * Used by scheduler ticks and queue reads to auto-promote failed phases.
+ */
+export declare function retryAllFailed(state: PhaseState): PhaseState;
+/**
+ * Mark a phase as running (scheduler picks it).
+ */
+export declare function phaseRunning(state: PhaseState, phase: 'architect' | 'builder' | 'critic'): PhaseState;
+/**
+ * Get the owed phase: first non-fresh phase in pipeline order, or null.
+ */
+export declare function getOwedPhase(state: PhaseState): 'architect' | 'builder' | 'critic' | null;
+/**
+ * Check if a meta is fully fresh (all phases fresh).
+ */
+export declare function isFullyFresh(state: PhaseState): boolean;
+/**
+ * Get the scheduler priority band for a meta's owed phase.
+ * 1 = critic (highest), 2 = builder, 3 = architect, null = fully fresh.
+ */
+export declare function getPriorityBand(state: PhaseState): 1 | 2 | 3 | null;

package/dist/progress/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Progress reporting via OpenClaw gateway `/tools/invoke` → `message` tool.
+ *
+ * @module progress
+ */
+import type { Logger } from 'pino';
+export type ProgressPhase = 'architect' | 'builder' | 'critic';
+export type ProgressEvent = {
+    type: 'synthesis_start' | 'phase_start' | 'phase_complete' | 'synthesis_complete' | 'error';
+    /** Owner path (not .meta path) of the entity being synthesized. */
+    path: string;
+    phase?: ProgressPhase;
+    tokens?: number;
+    durationMs?: number;
+    error?: string;
+};
+export type ProgressReporterConfig = {
+    gatewayUrl: string;
+    gatewayApiKey?: string;
+    /**
+     * Messaging channel name (e.g. 'slack'). When set alongside reportTarget,
+     * included in the gateway message payload as `channel`.
+     * Legacy: if reportTarget is unset, reportChannel is used as the target
+     * (single-channel mode, backward compatible).
+     */
+    reportChannel?: string;
+    /** Channel/user ID to send messages to. Takes priority over reportChannel as target. */
+    reportTarget?: string;
+    /** Optional base URL for the service, used to construct entity links. */
+    serverBaseUrl?: string;
+};
+export declare function formatProgressEvent(event: ProgressEvent, serverBaseUrl?: string): string;
+export declare class ProgressReporter {
+    private readonly config;
+    private readonly logger;
+    constructor(config: ProgressReporterConfig, logger: Logger);
+    report(event: ProgressEvent): Promise<void>;
+}

package/dist/prompts/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Built-in default prompts for the synthesis pipeline.
+ *
+ * Prompts ship as .md files bundled into dist/prompts/ via rollup-plugin-copy.
+ * Loaded at runtime relative to the compiled module location.
+ *
+ * Users can override via `defaultArchitect` / `defaultCritic` in the service
+ * config. Most installations should use the built-in defaults.
+ *
+ * @module prompts
+ */
+/** Built-in default architect prompt. */
+export declare const DEFAULT_ARCHITECT_PROMPT: string;
+/** Built-in default critic prompt. */
+export declare const DEFAULT_CRITIC_PROMPT: string;