@agentic-workflow-kit/orchestrator 0.1.0

package/dist/cli.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { analyzeWorkflowRun } from './analysis/runAnalyzer.js';
+import { FileArtifactStore } from './artifacts/FileArtifactStore.js';
+import { getHelpText, parseCommand, resolveInvocationCwd } from './cli/args.js';
+import { SystemClock } from './clock/SystemClock.js';
+import { createRunId, loadResolvedConfig, resolveCwdOnlyConfig } from './config/configLoader.js';
+import { CodexMcpStoryRunner } from './drivers/codex-mcp/CodexMcpStoryRunner.js';
+import { RealGitInspector } from './git/GitInspector.js';
+import { ConsoleLogger } from './logging/ConsoleLogger.js';
+import { WorkflowRunner } from './runner/WorkflowRunner.js';
+import { selectDispatchableStories } from './scheduler/scheduler.js';
+import { discoverMarkdownTracks, EmptyStorySource, MarkdownTrackStorySource } from './tracks/markdownTracker.js';
+export async function runCli(argv = process.argv.slice(2), options = {}) {
+    const command = parseCommand(argv);
+    const logger = new ConsoleLogger();
+    const stdout = options.stdout ?? console.log;
+    if (command.kind === 'help') {
+        stdout(getHelpText());
+        return;
+    }
+    if (command.kind === 'analyze-run') {
+        const analysis = await analyzeWorkflowRun(path.resolve(command.runPath), {
+            sessionRoots: command.overrides.sessionRoot ? [path.resolve(command.overrides.sessionRoot)] : undefined,
+        });
+        stdout(JSON.stringify(analysis, null, 2));
+        return;
+    }
+    if (command.kind === 'watch-run') {
+        await printRunSnapshot(path.resolve(command.runPath), command.overrides, stdout);
+        return;
+    }
+    const cwd = resolveInvocationCwd(command.overrides);
+    if (command.kind === 'mcp-check') {
+        const storyRunner = new CodexMcpStoryRunner(resolveCwdOnlyConfig(cwd), {
+            ...(options.createCodexMcpClient ? { createClient: options.createCodexMcpClient } : {}),
+        });
+        const status = await storyRunner.checkTools();
+        if (command.overrides.json) {
+            stdout(JSON.stringify(status, null, 2));
+        }
+        else {
+            logger.info('Codex MCP schema check passed', { tools: status.tools });
+        }
+        return;
+    }
+    const config = await loadResolvedConfig(command.overrides, cwd);
+    const tracks = await discoverTracks(config, command.overrides);
+    if (command.kind === 'list-tracks') {
+        printTracks(tracks, command.overrides);
+        return;
+    }
+    if (command.kind === 'list-stories') {
+        const stories = command.overrides.track
+            ? selectTrack(tracks, command.overrides.track).stories
+            : tracks.flatMap((track) => track.stories);
+        printStories(stories, command.overrides, 'No stories found.');
+        return;
+    }
+    if (command.kind === 'list-eligible') {
+        const stories = command.overrides.track
+            ? selectTrack(tracks, command.overrides.track).stories
+            : tracks.flatMap((track) => track.stories);
+        const eligible = stories.filter((story) => story.eligible);
+        printStories(eligible, command.overrides, 'No eligible stories.');
+        return;
+    }
+    const runId = createRunId();
+    const runDirectory = path.join(config.artifacts.runsDirAbs, runId);
+    const storySource = command.kind === 'run-story'
+        ? selectStorySourceForStory(config, tracks, command.storyId, command.overrides)
+        : selectStorySourceForRunEligible(config, tracks, command.overrides);
+    const workflowRunner = new WorkflowRunner({
+        command: command.kind,
+        config,
+        storySource,
+        storyRunner: new CodexMcpStoryRunner(config),
+        gitInspector: new RealGitInspector(),
+        artifactStore: new FileArtifactStore(runDirectory),
+        logger,
+        clock: new SystemClock(),
+        runId,
+    });
+    const run = command.kind === 'run-story'
+        ? workflowRunner.runStory(command.storyId, { force: command.overrides.force })
+        : command.overrides.dryRun
+            ? workflowRunner.dryRunEligible()
+            : workflowRunner.runEligible();
+    const result = command.overrides.watch ? await runWithEventWatch(run, runDirectory, command.overrides) : await run;
+    if (command.overrides.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        logger.info('run finished', {
+            runId: result.runId,
+            status: result.status,
+            completed: result.completed.map((child) => child.storyId),
+            blockedStoryId: result.blockedStoryId,
+            artifacts: runDirectory,
+        });
+    }
+    if (result.status === 'blocked') {
+        process.exitCode = 1;
+    }
+}
+async function discoverTracks(config, overrides) {
+    return await discoverMarkdownTracks({
+        workspaceRoot: config.workspace.rootAbs,
+        tracksDir: overrides.tracksDir ?? config.paths.tracksDir,
+        archiveDir: config.paths.archiveDir,
+        completeStatuses: config.statuses.complete,
+        eligibleStatuses: config.statuses.eligible,
+        idPattern: config.tracker.idPattern,
+    });
+}
+function selectStorySourceForRunEligible(config, tracks, overrides) {
+    if (overrides.track) {
+        const track = selectTrack(tracks, overrides.track);
+        return new MarkdownTrackStorySource(trackOptions(config, overrides), track.id);
+    }
+    const eligibleTracks = tracks.filter((track) => track.stories.some((story) => story.eligible));
+    if (eligibleTracks.length === 0)
+        return new EmptyStorySource();
+    if (eligibleTracks.length > 1) {
+        throw new Error(`multiple tracks have eligible stories: ${eligibleTracks.map((track) => track.id).join(', ')}; pass --track <id>`);
+    }
+    return new MarkdownTrackStorySource(trackOptions(config, overrides), eligibleTracks[0].id);
+}
+function selectStorySourceForStory(config, tracks, storyId, overrides) {
+    if (overrides.track) {
+        const track = selectTrack(tracks, overrides.track);
+        return new MarkdownTrackStorySource(trackOptions(config, overrides), track.id);
+    }
+    const matchingTracks = tracks.filter((track) => track.stories.some((story) => story.id === storyId));
+    if (matchingTracks.length === 0)
+        return new EmptyStorySource();
+    if (matchingTracks.length > 1) {
+        throw new Error(`story ${storyId} exists in multiple tracks: ${matchingTracks.map((track) => track.id).join(', ')}; pass --track <id>`);
+    }
+    return new MarkdownTrackStorySource(trackOptions(config, overrides), matchingTracks[0].id);
+}
+function selectTrack(tracks, trackId) {
+    const track = tracks.find((entry) => entry.id === trackId);
+    if (!track)
+        throw new Error(`track ${trackId} was not found`);
+    return track;
+}
+function trackOptions(config, overrides) {
+    return {
+        workspaceRoot: config.workspace.rootAbs,
+        tracksDir: overrides.tracksDir ?? config.paths.tracksDir,
+        archiveDir: config.paths.archiveDir,
+        completeStatuses: config.statuses.complete,
+        eligibleStatuses: config.statuses.eligible,
+        idPattern: config.tracker.idPattern,
+    };
+}
+function printTracks(tracks, overrides) {
+    if (overrides.json) {
+        console.log(JSON.stringify(tracks, null, 2));
+        return;
+    }
+    if (tracks.length === 0) {
+        console.log('No tracks found.');
+        return;
+    }
+    for (const track of tracks) {
+        const eligibleCount = track.stories.filter((story) => story.eligible).length;
+        console.log(`${track.id} ${track.title} (${eligibleCount}/${track.stories.length} eligible)`);
+    }
+}
+function printStories(stories, overrides, emptyMessage) {
+    const limited = selectDispatchableStories(stories, {
+        maxParallel: overrides.maxParallel ?? stories.length,
+    });
+    const printable = overrides.maxParallel ? limited : stories;
+    if (overrides.json) {
+        console.log(JSON.stringify(printable, null, 2));
+        return;
+    }
+    if (printable.length === 0) {
+        console.log(emptyMessage);
+        return;
+    }
+    for (const story of printable) {
+        const title = story.title ? ` ${story.title}` : '';
+        console.log(`${story.id}${title} [${story.status}]`);
+    }
+}
+async function printRunSnapshot(runDirectory, overrides, stdout) {
+    const [state, metrics] = await Promise.all([
+        readJsonIfExists(path.join(runDirectory, 'state.json')),
+        readJsonIfExists(path.join(runDirectory, 'metrics.live.json')),
+    ]);
+    const snapshot = { state, metrics };
+    if (overrides.json) {
+        stdout(JSON.stringify(snapshot, null, 2));
+        return;
+    }
+    stdout(`Run: ${runDirectory}`);
+    stdout(JSON.stringify(snapshot, null, 2));
+}
+async function runWithEventWatch(run, runDirectory, overrides) {
+    let done = false;
+    const watch = watchRunEvents(runDirectory, overrides, () => done);
+    try {
+        const result = await run;
+        done = true;
+        await watch;
+        return result;
+    }
+    catch (error) {
+        done = true;
+        await watch;
+        throw error;
+    }
+}
+async function watchRunEvents(runDirectory, overrides, isDone) {
+    const eventPath = path.join(runDirectory, 'events.ndjson');
+    let printed = 0;
+    while (!isDone()) {
+        printed = await printNewEvents(eventPath, printed, overrides);
+        await delay(250);
+    }
+    await printNewEvents(eventPath, printed, overrides);
+}
+async function printNewEvents(eventPath, printed, overrides) {
+    let content;
+    try {
+        content = await readFile(eventPath, 'utf8');
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return printed;
+        throw error;
+    }
+    const lines = content.trimEnd().split('\n').filter(Boolean);
+    for (const line of lines.slice(printed)) {
+        if (overrides.json) {
+            console.log(line);
+        }
+        else {
+            const event = JSON.parse(line);
+            const story = typeof event.storyId === 'string' ? ` ${event.storyId}` : '';
+            const status = typeof event.status === 'string' ? ` ${event.status}` : '';
+            console.log(`${String(event.ts ?? '')} ${String(event.type ?? 'event')}${story}${status}`.trim());
+        }
+    }
+    return lines.length;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readJsonIfExists(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+if (isDirectCliExecution()) {
+    runCli().catch((error) => {
+        const logger = new ConsoleLogger();
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}
+export function isDirectCliExecution(entrypoint = process.argv[1], moduleUrl = import.meta.url) {
+    if (entrypoint === undefined)
+        return false;
+    try {
+        return realpathSync(entrypoint) === realpathSync(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/clock/SystemClock.d.ts

@@ -0,0 +1,6 @@
+import type { Clock } from '../types.js';
+export declare class SystemClock implements Clock {
+    now(): string;
+    nowMs(): number;
+}
+//# sourceMappingURL=SystemClock.d.ts.map

package/dist/clock/SystemClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemClock.d.ts","sourceRoot":"","sources":["../../src/clock/SystemClock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,qBAAa,WAAY,YAAW,KAAK;IACvC,GAAG,IAAI,MAAM;IAGb,KAAK,IAAI,MAAM;CAGhB"}

package/dist/clock/SystemClock.js

@@ -0,0 +1,8 @@
+export class SystemClock {
+    now() {
+        return new Date().toISOString();
+    }
+    nowMs() {
+        return Date.now();
+    }
+}

package/dist/config/configLoader.d.ts

@@ -0,0 +1,5 @@
+import type { CliOverrides, ResolvedWorkflowConfig } from '../types.js';
+export declare function loadResolvedConfig(overrides?: CliOverrides, cwd?: string): Promise<ResolvedWorkflowConfig>;
+export declare function resolveCwdOnlyConfig(cwd?: string): ResolvedWorkflowConfig;
+export declare function createRunId(now?: () => string): string;
+//# sourceMappingURL=configLoader.d.ts.map

package/dist/config/configLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configLoader.d.ts","sourceRoot":"","sources":["../../src/config/configLoader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAsB,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAK5F,wBAAsB,kBAAkB,CACtC,SAAS,GAAE,YAAiB,EAC5B,GAAG,SAAgB,GAClB,OAAO,CAAC,sBAAsB,CAAC,CAsDjC;AAED,wBAAgB,oBAAoB,CAAC,GAAG,SAAgB,GAAG,sBAAsB,CAuChF;AAED,wBAAgB,WAAW,CAAC,GAAG,eAAiC,GAAG,MAAM,CAExE"}

package/dist/config/configLoader.js

@@ -0,0 +1,105 @@
+import path from 'node:path';
+import { loadConfig } from './resolve.js';
+const SUPPORTED_DRIVERS = new Set(['codex-mcp']);
+export async function loadResolvedConfig(overrides = {}, cwd = process.cwd()) {
+    const { config, workspaceRoot, configPath } = await loadConfig({
+        cwd,
+        configPath: overrides.configPath,
+    });
+    const driver = resolveDriver(config.orchestrator.driver);
+    const tracksDir = overrides.tracksDir ?? config.paths.tracksDir;
+    const archiveDir = config.paths.archiveDir;
+    const maxParallel = overrides.maxParallel ?? config.orchestrator.maxParallel;
+    const childTimeoutMs = overrides.childTimeoutMs ?? config.orchestrator.childTimeoutMs;
+    const childSessionConfig = {};
+    if (overrides.reasoning !== undefined) {
+        childSessionConfig.model_reasoning_effort = overrides.reasoning;
+    }
+    return {
+        version: 1,
+        configPath,
+        workspace: { rootAbs: workspaceRoot },
+        paths: {
+            tracksDir,
+            tracksDirAbs: path.resolve(workspaceRoot, tracksDir),
+            archiveDir,
+            archiveDirAbs: path.resolve(workspaceRoot, archiveDir),
+        },
+        artifacts: {
+            rootDir: '.codex/agentic-workflow-kit',
+            rootDirAbs: path.resolve(workspaceRoot, '.codex/agentic-workflow-kit'),
+            runsDirAbs: path.resolve(workspaceRoot, '.codex/agentic-workflow-kit/runs'),
+        },
+        statuses: {
+            eligible: config.statuses.eligible,
+            inProgress: config.statuses.inProgress,
+            complete: config.statuses.complete,
+        },
+        tracker: { idPattern: config.tracker.idPattern },
+        git: config.git,
+        orchestrator: {
+            driver,
+            maxParallel,
+            stopLaunchingOnBlocked: config.orchestrator.stopLaunchingOnBlocked,
+            childTimeoutMs,
+        },
+        codex: {
+            childSession: {
+                cwdAbs: workspaceRoot,
+                ...(overrides.model !== undefined ? { model: overrides.model } : {}),
+                ...(overrides.approvalPolicy !== undefined ? { approvalPolicy: overrides.approvalPolicy } : {}),
+                ...(overrides.sandbox !== undefined ? { sandbox: overrides.sandbox } : {}),
+                ...(Object.keys(childSessionConfig).length > 0 ? { config: childSessionConfig } : {}),
+            },
+        },
+    };
+}
+export function resolveCwdOnlyConfig(cwd = process.cwd()) {
+    const workspaceRoot = path.resolve(cwd);
+    return {
+        version: 1,
+        configPath: path.resolve(workspaceRoot, '.workflow/config.yaml'),
+        workspace: { rootAbs: workspaceRoot },
+        paths: {
+            tracksDir: 'docs/tracks',
+            tracksDirAbs: path.resolve(workspaceRoot, 'docs/tracks'),
+            archiveDir: 'docs/tracks/archive',
+            archiveDirAbs: path.resolve(workspaceRoot, 'docs/tracks/archive'),
+        },
+        artifacts: {
+            rootDir: '.codex/agentic-workflow-kit',
+            rootDirAbs: path.resolve(workspaceRoot, '.codex/agentic-workflow-kit'),
+            runsDirAbs: path.resolve(workspaceRoot, '.codex/agentic-workflow-kit/runs'),
+        },
+        statuses: {
+            eligible: ['specced', 'plan-approved'],
+            inProgress: 'implementing',
+            complete: ['done', 'verified'],
+        },
+        tracker: { idPattern: '^[A-Z]{2,}[0-9]+$' },
+        git: {
+            strategy: 'worktree',
+            branchPattern: '{track}/{id-lc}-{slug}',
+            baseBranch: 'main',
+            commitOnBase: 'forbid',
+        },
+        orchestrator: {
+            driver: 'codex-mcp',
+            maxParallel: 2,
+            stopLaunchingOnBlocked: true,
+            childTimeoutMs: 1_800_000,
+        },
+        codex: {
+            childSession: { cwdAbs: workspaceRoot },
+        },
+    };
+}
+export function createRunId(now = () => new Date().toISOString()) {
+    return now().replace(/[:.]/g, '-');
+}
+function resolveDriver(value) {
+    if (!SUPPORTED_DRIVERS.has(value)) {
+        throw new Error(`Unsupported orchestrator.driver "${value}". Supported drivers: codex-mcp.`);
+    }
+    return value;
+}

package/dist/config/generate-schema.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-schema.d.ts.map

package/dist/config/generate-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-schema.d.ts","sourceRoot":"","sources":["../../src/config/generate-schema.ts"],"names":[],"mappings":""}

package/dist/config/generate-schema.js

@@ -0,0 +1,8 @@
+import { writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { serializeConfigJsonSchema } from './jsonSchema.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const target = path.resolve(here, '../../../../references/config.schema.json');
+writeFileSync(target, serializeConfigJsonSchema());
+console.error(`wrote ${target}`);

package/dist/config/jsonSchema.d.ts

@@ -0,0 +1,3 @@
+export declare function buildConfigJsonSchema(): Record<string, unknown>;
+export declare function serializeConfigJsonSchema(): string;
+//# sourceMappingURL=jsonSchema.d.ts.map

package/dist/config/jsonSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSchema.d.ts","sourceRoot":"","sources":["../../src/config/jsonSchema.ts"],"names":[],"mappings":"AAMA,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQ/D;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD"}

package/dist/config/jsonSchema.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { isRecord } from '../internal/guards.js';
+import { ConfigSchema } from './schema.js';
+const ID = 'https://github.com/aryeko/agentic-workflow-kit/config.schema.json';
+export function buildConfigJsonSchema() {
+    const generated = z.toJSONSchema(ConfigSchema);
+    return relaxObjectRequired({
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        $id: ID,
+        title: 'agentic-workflow-kit config',
+        ...generated,
+    });
+}
+export function serializeConfigJsonSchema() {
+    return `${JSON.stringify(buildConfigJsonSchema(), null, 2)}\n`;
+}
+function relaxObjectRequired(value) {
+    const relaxed = relaxObjectRequiredInner(value, true);
+    if (!isRecord(relaxed)) {
+        throw new Error('Expected generated config JSON Schema to be an object');
+    }
+    return relaxed;
+}
+function relaxObjectRequiredInner(value, isRoot) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => relaxObjectRequiredInner(entry, false));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const next = {};
+    for (const [key, child] of Object.entries(value)) {
+        next[key] = relaxObjectRequiredInner(child, false);
+    }
+    if (next.type === 'object') {
+        if (isRoot) {
+            next.required = ['version'];
+        }
+        else {
+            delete next.required;
+        }
+    }
+    return next;
+}

package/dist/config/preset.d.ts

@@ -0,0 +1,16 @@
+export type PresetName = 'push-and-merge' | 'gated-automerge' | 'push-only';
+export interface RepoSignals {
+    /** True when the base branch requires pull-request reviews before merge. */
+    requiresReview: boolean;
+    /** True when the repo has CI configured (e.g. .github/workflows present). */
+    hasCI: boolean;
+}
+/**
+ * Choose the default PR/merge preset from detected repo signals.
+ *
+ * - Required reviews => humans gate the merge => open a PR and stop (push-only).
+ * - CI but no required reviews => wait on CI + bot review, then auto-merge (gated-automerge).
+ * - Neither => open a PR and auto-merge after best-effort local checks (push-and-merge).
+ */
+export declare function selectPreset(signals: RepoSignals): PresetName;
+//# sourceMappingURL=preset.d.ts.map

package/dist/config/preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset.d.ts","sourceRoot":"","sources":["../../src/config/preset.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAE5E,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,cAAc,EAAE,OAAO,CAAC;IACxB,6EAA6E;IAC7E,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CAI7D"}

package/dist/config/preset.js

@@ -0,0 +1,14 @@
+/**
+ * Choose the default PR/merge preset from detected repo signals.
+ *
+ * - Required reviews => humans gate the merge => open a PR and stop (push-only).
+ * - CI but no required reviews => wait on CI + bot review, then auto-merge (gated-automerge).
+ * - Neither => open a PR and auto-merge after best-effort local checks (push-and-merge).
+ */
+export function selectPreset(signals) {
+    if (signals.requiresReview)
+        return 'push-only';
+    if (signals.hasCI)
+        return 'gated-automerge';
+    return 'push-and-merge';
+}

package/dist/config/resolve.d.ts

@@ -0,0 +1,12 @@
+import { type WorkflowConfig } from './schema.js';
+export interface LoadConfigOptions {
+    cwd?: string;
+    configPath?: string;
+}
+export interface LoadedConfig {
+    configPath: string;
+    workspaceRoot: string;
+    config: WorkflowConfig;
+}
+export declare function loadConfig(options?: LoadConfigOptions): Promise<LoadedConfig>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/config/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/config/resolve.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAIhE,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,wBAAsB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,YAAY,CAAC,CAsBvF"}

package/dist/config/resolve.js

@@ -0,0 +1,30 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { isNodeError } from '../internal/guards.js';
+import { ConfigSchema } from './schema.js';
+const DEFAULT_CONFIG_PATH = '.workflow/config.yaml';
+export async function loadConfig(options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const configPath = path.resolve(cwd, options.configPath ?? DEFAULT_CONFIG_PATH);
+    let raw;
+    try {
+        raw = await readFile(configPath, 'utf8');
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            throw new Error('Missing .workflow/config.yaml. Run /workflow-init before using agentic-workflow-kit orchestrator.');
+        }
+        throw error;
+    }
+    const parsed = YAML.parse(raw);
+    const result = ConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new Error(formatZodError(result.error));
+    }
+    return { configPath, workspaceRoot: cwd, config: result.data };
+}
+function formatZodError(error) {
+    const details = error.issues.map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`).join('; ');
+    return `Invalid .workflow/config.yaml — ${details}`;
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+export declare const ConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    paths: z.ZodPrefault<z.ZodObject<{
+        tracksDir: z.ZodDefault<z.ZodString>;
+        specsDir: z.ZodDefault<z.ZodString>;
+        plansDir: z.ZodDefault<z.ZodString>;
+        archiveDir: z.ZodDefault<z.ZodString>;
+        prdsDir: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    statuses: z.ZodPrefault<z.ZodObject<{
+        eligible: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        inProgress: z.ZodDefault<z.ZodString>;
+        complete: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    tracker: z.ZodPrefault<z.ZodObject<{
+        idPattern: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    verify: z.ZodPrefault<z.ZodObject<{
+        changed: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        full: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    git: z.ZodPrefault<z.ZodObject<{
+        strategy: z.ZodDefault<z.ZodEnum<{
+            worktree: "worktree";
+            branch: "branch";
+        }>>;
+        branchPattern: z.ZodDefault<z.ZodString>;
+        baseBranch: z.ZodDefault<z.ZodString>;
+        commitOnBase: z.ZodDefault<z.ZodEnum<{
+            forbid: "forbid";
+            allow: "allow";
+        }>>;
+    }, z.core.$strict>>;
+    pr: z.ZodPrefault<z.ZodObject<{
+        create: z.ZodDefault<z.ZodBoolean>;
+        ci: z.ZodPrefault<z.ZodObject<{
+            wait: z.ZodDefault<z.ZodBoolean>;
+            command: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        review: z.ZodPrefault<z.ZodObject<{
+            wait: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                bot: "bot";
+                human: "human";
+            }>>;
+            bot: z.ZodDefault<z.ZodString>;
+            triageComments: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        merge: z.ZodPrefault<z.ZodObject<{
+            auto: z.ZodDefault<z.ZodBoolean>;
+            method: z.ZodDefault<z.ZodEnum<{
+                squash: "squash";
+                merge: "merge";
+                rebase: "rebase";
+            }>>;
+            deleteBranch: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    orchestrator: z.ZodPrefault<z.ZodObject<{
+        driver: z.ZodDefault<z.ZodString>;
+        maxParallel: z.ZodDefault<z.ZodNumber>;
+        stopLaunchingOnBlocked: z.ZodDefault<z.ZodBoolean>;
+        childTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WorkflowConfig = z.infer<typeof ConfigSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6Ed,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}