@open-agent-toolkit/cli 0.1.5 → 0.1.7

package/dist/commands/shared/frontmatter.js

@@ -1,5 +1,51 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+export const PROJECT_STATE_KINDS = ['implementation', 'coordination'];
+export const PROJECT_STATE_PHASES = [
+    'discovery',
+    'spec',
+    'design',
+    'plan',
+    'implement',
+    'decomposition',
+];
+export const PROJECT_STATE_FRONTMATTER_FIELDS = [
+    'oat_kind',
+    'oat_parent',
+    'oat_siblings',
+    'oat_depends_on',
+    'oat_children',
+    'oat_inherited_context_revalidated',
+    'oat_phase',
+    'oat_phase_status',
+    'oat_status',
+    'oat_workflow_mode',
+    'oat_lifecycle',
+    'oat_current_task',
+    'oat_last_commit',
+    'oat_blockers',
+    'oat_hill_checkpoints',
+    'oat_hill_completed',
+    'oat_parallel_execution',
+    'oat_pr_status',
+    'oat_pr_url',
+    'oat_project_created',
+    'oat_project_completed',
+    'oat_project_state_updated',
+    'oat_docs_updated',
+    'oat_generated',
+    'oat_template',
+    'oat_template_name',
+];
+export function isProjectStateKind(value) {
+    return PROJECT_STATE_KINDS.includes(value);
+}
+export function isProjectStatePhase(value) {
+    return PROJECT_STATE_PHASES.includes(value);
+}
+export function isProjectStateFrontmatterField(value) {
+    return PROJECT_STATE_FRONTMATTER_FIELDS.includes(value);
+}
 export function getFrontmatterBlock(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     return match?.[1] ?? null;

package/dist/commands/state/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/commands/state/generate.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAClD;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,aAAa,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AA4GD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvE;AA8aD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CA2C9B"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/commands/state/generate.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAClD;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,aAAa,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAiHD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvE;AAydD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CA2C9B"}

package/dist/commands/state/generate.js

@@ -305,25 +305,53 @@ function computeNextStep(project, hasProjects, state) {
     }
     return { step: 'oat-project-progress', reason: 'Check current progress' };
 }
+function isTerminalCoordinationProject(kind, phase, phaseStatus) {
+    return (kind === 'coordination' &&
+        phase === 'decomposition' &&
+        phaseStatus === 'complete');
+}
 async function listAvailableProjects(repoRoot, projectsRoot) {
     const fullRoot = join(repoRoot, projectsRoot);
     try {
         const entries = await readdir(fullRoot, { withFileTypes: true });
         const dirs = entries.filter((e) => e.isDirectory());
-        if (dirs.length === 0)
-            return '*(No projects found)*';
+        if (dirs.length === 0) {
+            return {
+                active: '*(No projects found)*',
+                decompositions: '*(No decompositions found)*',
+            };
+        }
         const lines = [];
+        const decompositions = [];
         for (const dir of dirs) {
             const stateFile = join(fullRoot, dir.name, 'state.md');
             if (await fileExists(stateFile)) {
                 const phase = (await parseFrontmatterField(stateFile, 'oat_phase')) || 'unknown';
-                lines.push(`- **${dir.name}** - ${phase}`);
+                const phaseStatus = (await parseFrontmatterField(stateFile, 'oat_phase_status')) ||
+                    'in_progress';
+                const kind = (await parseFrontmatterField(stateFile, 'oat_kind')) ||
+                    'implementation';
+                const line = `- **${dir.name}** - ${phase}`;
+                if (isTerminalCoordinationProject(kind, phase, phaseStatus)) {
+                    decompositions.push(line);
+                }
+                else {
+                    lines.push(line);
+                }
             }
         }
-        return lines.length > 0 ? lines.join('\n') : '*(No projects found)*';
+        return {
+            active: lines.length > 0 ? lines.join('\n') : '*(No projects found)*',
+            decompositions: decompositions.length > 0
+                ? decompositions.join('\n')
+                : '*(No decompositions found)*',
+        };
     }
     catch {
-        return '*(No projects directory found)*';
+        return {
+            active: '*(No projects directory found)*',
+            decompositions: '*(No decompositions found)*',
+        };
     }
 }
 function buildDashboardMarkdown(project, state, knowledge, staleness, nextStep, projectsList, generatedDate) {
@@ -412,7 +440,11 @@ function buildDashboardMarkdown(project, state, knowledge, staleness, nextStep,
     lines.push('');
     lines.push('## Available Projects');
     lines.push('');
-    lines.push(projectsList);
+    lines.push(projectsList.active);
+    lines.push('');
+    lines.push('## Decompositions');
+    lines.push('');
+    lines.push(projectsList.decompositions);
     lines.push('');
     return lines.join('\n');
 }

package/dist/projects/split/child-plan.d.ts

@@ -0,0 +1,46 @@
+export type SplitOrigin = 'declared' | 'detected-mid-stream' | 'detected-convergence' | 'brainstorm-picker';
+export interface SplitChildInput {
+    slug: string;
+    description?: string;
+    inheritedContext?: string;
+    knownDependencies?: string[];
+    foundation?: boolean;
+}
+export interface SplitPayload {
+    origin: SplitOrigin;
+    parentSlug?: string;
+    declaredChildren?: SplitChildInput[];
+    inferredChildren?: SplitChildInput[];
+    priorDiscovery?: {
+        path: string;
+        brainstormSessionId?: string;
+        parentSlug?: string;
+        children?: SplitChildInput[];
+        inheritedContext?: string;
+        integrationSketch?: string;
+    };
+    interactive: boolean;
+    foundationChild?: string;
+    integrationSketch?: string;
+    initialActiveChild?: string;
+}
+export interface ChildPlan {
+    parentSlug: string;
+    children: Array<{
+        slug: string;
+        description?: string;
+        inheritedContext: string;
+        knownDependencies: string[];
+        order: number;
+    }>;
+    foundationChild?: string;
+    integrationSketch?: string;
+    initialActiveChild: string;
+}
+export interface SplitPlanDocument {
+    origin: SplitOrigin;
+    interactive: boolean;
+    plan: ChildPlan;
+}
+export declare function buildSplitPlanDocument(payload: SplitPayload): SplitPlanDocument;
+//# sourceMappingURL=child-plan.d.ts.map

package/dist/projects/split/child-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-plan.d.ts","sourceRoot":"","sources":["../../../src/projects/split/child-plan.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GACnB,UAAU,GACV,qBAAqB,GACrB,sBAAsB,GACtB,mBAAmB,CAAC;AAExB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IACrC,cAAc,CAAC,EAAE;QACf,IAAI,EAAE,MAAM,CAAC;QACb,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;QAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,gBAAgB,EAAE,MAAM,CAAC;QACzB,iBAAiB,EAAE,MAAM,EAAE,CAAC;QAC5B,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,IAAI,EAAE,SAAS,CAAC;CACjB;AA0GD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,YAAY,GACpB,iBAAiB,CAiCnB"}

package/dist/projects/split/child-plan.js

@@ -0,0 +1,107 @@
+function deriveSlugFromPath(path) {
+    const normalized = path.trim().replace(/\/+$/, '');
+    const slug = normalized.split('/').at(-1);
+    if (!slug) {
+        throw new Error('Unable to derive parent slug from priorDiscovery.path');
+    }
+    return slug;
+}
+function resolveParentSlug(payload) {
+    if (payload.parentSlug) {
+        return payload.parentSlug;
+    }
+    if (payload.priorDiscovery?.parentSlug) {
+        return payload.priorDiscovery.parentSlug;
+    }
+    if (payload.priorDiscovery?.path) {
+        return deriveSlugFromPath(payload.priorDiscovery.path);
+    }
+    throw new Error('SplitPayload requires parentSlug or priorDiscovery.path');
+}
+function resolveChildren(payload) {
+    const children = payload.declaredChildren ??
+        payload.inferredChildren ??
+        payload.priorDiscovery?.children;
+    if (!children || children.length === 0) {
+        throw new Error('SplitPayload requires at least one child');
+    }
+    return children;
+}
+function resolveFoundationChild(payload, children) {
+    return (payload.foundationChild ?? children.find((child) => child.foundation)?.slug);
+}
+function orderChildren(children, foundationChild) {
+    const childSlugs = new Set(children.map((child) => child.slug));
+    const bySlug = new Map(children.map((child) => [child.slug, child]));
+    const inputOrder = new Map(children.map((child, index) => [child.slug, index]));
+    const indegree = new Map(children.map((child) => [child.slug, 0]));
+    const dependents = new Map();
+    for (const child of children) {
+        for (const dependency of child.knownDependencies ?? []) {
+            if (!childSlugs.has(dependency)) {
+                continue;
+            }
+            indegree.set(child.slug, (indegree.get(child.slug) ?? 0) + 1);
+            const existing = dependents.get(dependency) ?? [];
+            existing.push(child.slug);
+            dependents.set(dependency, existing);
+        }
+    }
+    const priority = (slug) => slug === foundationChild ? -1 : (inputOrder.get(slug) ?? 0);
+    const ready = children
+        .filter((child) => indegree.get(child.slug) === 0)
+        .map((child) => child.slug)
+        .sort((left, right) => priority(left) - priority(right));
+    const ordered = [];
+    while (ready.length > 0) {
+        const slug = ready.shift();
+        const child = bySlug.get(slug);
+        if (child) {
+            ordered.push(child);
+        }
+        for (const dependent of dependents.get(slug) ?? []) {
+            indegree.set(dependent, (indegree.get(dependent) ?? 0) - 1);
+            if (indegree.get(dependent) === 0) {
+                ready.push(dependent);
+                ready.sort((left, right) => priority(left) - priority(right));
+            }
+        }
+    }
+    if (ordered.length !== children.length) {
+        const orderedSlugs = new Set(ordered.map((child) => child.slug));
+        ordered.push(...children
+            .filter((child) => !orderedSlugs.has(child.slug))
+            .sort((left, right) => priority(left.slug) - priority(right.slug)));
+    }
+    return ordered;
+}
+export function buildSplitPlanDocument(payload) {
+    const parentSlug = resolveParentSlug(payload);
+    const children = resolveChildren(payload);
+    const foundationChild = resolveFoundationChild(payload, children);
+    const orderedChildren = orderChildren(children, foundationChild);
+    const firstChild = orderedChildren[0]?.slug;
+    if (!firstChild) {
+        throw new Error('SplitPayload requires at least one child');
+    }
+    return {
+        origin: payload.origin,
+        interactive: payload.interactive,
+        plan: {
+            parentSlug,
+            children: orderedChildren.map((child, index) => ({
+                slug: child.slug,
+                description: child.description,
+                inheritedContext: child.inheritedContext ??
+                    payload.priorDiscovery?.inheritedContext ??
+                    child.description ??
+                    '',
+                knownDependencies: [...(child.knownDependencies ?? [])],
+                order: index + 1,
+            })),
+            foundationChild,
+            integrationSketch: payload.integrationSketch ?? payload.priorDiscovery?.integrationSketch,
+            initialActiveChild: payload.initialActiveChild ?? foundationChild ?? firstChild,
+        },
+    };
+}

package/dist/projects/split/document-validation.d.ts

@@ -0,0 +1,14 @@
+import type { ChildPlan, SplitPlanDocument } from './child-plan.js';
+export interface DocumentValidationError {
+    code: string;
+    message: string;
+}
+export declare function normalizePlanForValidation(plan: ChildPlan): ChildPlan;
+export declare function validateSplitPlanDocumentShape(value: unknown): {
+    ok: true;
+    document: SplitPlanDocument;
+} | {
+    ok: false;
+    errors: DocumentValidationError[];
+};
+//# sourceMappingURL=document-validation.d.ts.map

package/dist/projects/split/document-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-validation.d.ts","sourceRoot":"","sources":["../../../src/projects/split/document-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAe,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAE9E,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAaD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAQrE;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GACzD;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,GACzC;IACE,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,uBAAuB,EAAE,CAAC;CACnC,CAgGJ"}

package/dist/projects/split/document-validation.js

@@ -0,0 +1,106 @@
+const SPLIT_ORIGINS = [
+    'declared',
+    'detected-mid-stream',
+    'detected-convergence',
+    'brainstorm-picker',
+];
+function isObject(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+export function normalizePlanForValidation(plan) {
+    return {
+        ...plan,
+        children: plan.children.map((child) => ({
+            ...child,
+            knownDependencies: child.knownDependencies ?? [],
+        })),
+    };
+}
+export function validateSplitPlanDocumentShape(value) {
+    const errors = [];
+    if (!isObject(value)) {
+        return {
+            ok: false,
+            errors: [{ code: 'invalid-document', message: 'Expected JSON object' }],
+        };
+    }
+    if (typeof value.origin !== 'string' ||
+        !SPLIT_ORIGINS.includes(value.origin)) {
+        errors.push({
+            code: 'invalid-origin',
+            message: 'SplitPlanDocument origin is required',
+        });
+    }
+    if (typeof value.interactive !== 'boolean') {
+        errors.push({
+            code: 'invalid-interactive',
+            message: 'SplitPlanDocument interactive boolean is required',
+        });
+    }
+    if (!isObject(value.plan)) {
+        errors.push({
+            code: 'invalid-plan',
+            message: 'SplitPlanDocument plan object is required',
+        });
+    }
+    else {
+        if (typeof value.plan.parentSlug !== 'string') {
+            errors.push({
+                code: 'invalid-parent-slug',
+                message: 'ChildPlan parentSlug is required',
+            });
+        }
+        if (!Array.isArray(value.plan.children)) {
+            errors.push({
+                code: 'invalid-children',
+                message: 'ChildPlan children array is required',
+            });
+        }
+        else {
+            value.plan.children.forEach((child, index) => {
+                if (!isObject(child)) {
+                    errors.push({
+                        code: 'invalid-child',
+                        message: `ChildPlan child ${index + 1} must be an object`,
+                    });
+                    return;
+                }
+                if (typeof child.slug !== 'string') {
+                    errors.push({
+                        code: 'invalid-child-slug',
+                        message: `ChildPlan child ${index + 1} slug is required`,
+                    });
+                }
+                if (child.knownDependencies !== undefined &&
+                    !Array.isArray(child.knownDependencies)) {
+                    errors.push({
+                        code: 'invalid-known-dependencies',
+                        message: `ChildPlan child ${index + 1} knownDependencies must be an array`,
+                    });
+                }
+                if (typeof child.order !== 'number') {
+                    errors.push({
+                        code: 'invalid-child-order',
+                        message: `ChildPlan child ${index + 1} order is required`,
+                    });
+                }
+            });
+        }
+        if (typeof value.plan.initialActiveChild !== 'string') {
+            errors.push({
+                code: 'invalid-initial-active-child',
+                message: 'ChildPlan initialActiveChild is required',
+            });
+        }
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return {
+        ok: true,
+        document: {
+            ...value,
+            plan: normalizePlanForValidation(value.plan),
+        },
+    };
+}

package/dist/projects/split/finalize.d.ts

@@ -0,0 +1,7 @@
+import type { ChildPlan } from './child-plan.js';
+import type { SplitProjectContext } from './write-parent.js';
+export interface FinalizeSplitResult {
+    activeProjectPath: string;
+}
+export declare function finalizeSplit(plan: ChildPlan, context: SplitProjectContext): Promise<FinalizeSplitResult>;
+//# sourceMappingURL=finalize.d.ts.map

package/dist/projects/split/finalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../../../src/projects/split/finalize.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAiB1D,MAAM,WAAW,mBAAmB;IAClC,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CAoB9B"}

package/dist/projects/split/finalize.js

@@ -0,0 +1,32 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getFrontmatterBlock } from '../../commands/shared/frontmatter.js';
+import { replaceFrontmatter } from '../../commands/shared/frontmatter-write.js';
+import { setActiveProject } from '../../config/oat-config.js';
+import YAML from 'yaml';
+function readObjectFrontmatter(content, filePath) {
+    const block = getFrontmatterBlock(content);
+    if (!block) {
+        throw new Error(`${filePath} is missing frontmatter`);
+    }
+    const parsed = YAML.parse(block);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${filePath} frontmatter must be an object`);
+    }
+    return parsed;
+}
+export async function finalizeSplit(plan, context) {
+    const projectsRoot = context.projectsRoot ?? '.oat/projects/shared';
+    const parentPath = join(projectsRoot, plan.parentSlug).split('\\').join('/');
+    const statePath = join(context.repoRoot, parentPath, 'state.md');
+    const stateContent = await readFile(statePath, 'utf8');
+    const frontmatter = readObjectFrontmatter(stateContent, statePath);
+    frontmatter['oat_phase'] = 'decomposition';
+    frontmatter['oat_phase_status'] = 'complete';
+    await writeFile(statePath, replaceFrontmatter(stateContent, YAML.stringify(frontmatter).trimEnd()), 'utf8');
+    const activeProjectPath = join(projectsRoot, plan.initialActiveChild)
+        .split('\\')
+        .join('/');
+    await setActiveProject(context.repoRoot, activeProjectPath);
+    return { activeProjectPath };
+}

package/dist/projects/split/resume.d.ts

@@ -0,0 +1,19 @@
+import type { ChildPlan, SplitPlanDocument } from './child-plan.js';
+import type { SplitProjectContext } from './write-parent.js';
+export declare class SplitResumeError extends Error {
+    constructor(message: string);
+}
+export interface PartialSplit {
+    document: SplitPlanDocument;
+    plan: ChildPlan;
+    missingChildren: string[];
+    parentProjectPath: string;
+    projectsRoot: string;
+}
+export interface ResumeSplitOptions {
+    confirmed?: boolean;
+}
+export declare function detectPartialSplit(parentPath: string, context: SplitProjectContext): Promise<PartialSplit>;
+export declare function resumeSplit(parentPath: string, context: SplitProjectContext, options?: ResumeSplitOptions): Promise<PartialSplit>;
+export declare function continueSplitResume(partial: PartialSplit, context: SplitProjectContext): Promise<PartialSplit>;
+//# sourceMappingURL=resume.d.ts.map

package/dist/projects/split/resume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume.d.ts","sourceRoot":"","sources":["../../../src/projects/split/resume.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAKjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,EAAE,SAAS,CAAC;IAChB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA6CD,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CA8DvB;AAED,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,YAAY,CAAC,CAQvB;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAavB"}

package/dist/projects/split/resume.js

@@ -0,0 +1,107 @@
+import { readFile, stat } from 'node:fs/promises';
+import { isAbsolute, join, relative } from 'node:path';
+import { getFrontmatterBlock } from '../../commands/shared/frontmatter.js';
+import YAML from 'yaml';
+import { validateSplitPlanDocumentShape } from './document-validation.js';
+import { finalizeSplit } from './finalize.js';
+import { seedChildren } from './seed-children.js';
+import { validateChildPlan } from './validation.js';
+export class SplitResumeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SplitResumeError';
+    }
+}
+function readObjectFrontmatter(content, filePath) {
+    const block = getFrontmatterBlock(content);
+    if (!block) {
+        throw new SplitResumeError(`${filePath} is missing frontmatter`);
+    }
+    const parsed = YAML.parse(block);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new SplitResumeError(`${filePath} frontmatter must be an object`);
+    }
+    return parsed;
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveParentPaths(parentPath, context) {
+    const absoluteParentPath = isAbsolute(parentPath)
+        ? parentPath
+        : join(context.repoRoot, parentPath);
+    const parentProjectPath = relative(context.repoRoot, absoluteParentPath)
+        .split('\\')
+        .join('/');
+    const segments = parentProjectPath.split('/');
+    const projectsRoot = segments.slice(0, -1).join('/');
+    return { absoluteParentPath, parentProjectPath, projectsRoot };
+}
+export async function detectPartialSplit(parentPath, context) {
+    const { absoluteParentPath, parentProjectPath, projectsRoot } = resolveParentPaths(parentPath, context);
+    const statePath = join(absoluteParentPath, 'state.md');
+    const state = readObjectFrontmatter(await readFile(statePath, 'utf8'), statePath);
+    if (state['oat_kind'] !== 'coordination') {
+        throw new SplitResumeError('Split resume requires a coordination parent');
+    }
+    if (state['oat_phase_status'] === 'complete') {
+        throw new SplitResumeError('Cannot resume a completed split parent');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(join(absoluteParentPath, 'references', 'split-plan.json'), 'utf8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new SplitResumeError(`Cannot resume split without valid references/split-plan.json: ${message}`);
+    }
+    const documentShape = validateSplitPlanDocumentShape(parsed);
+    if (!documentShape.ok) {
+        throw new SplitResumeError(`Cannot resume split without valid references/split-plan.json: ${documentShape.errors
+            .map((error) => error.message)
+            .join('; ')}`);
+    }
+    const document = documentShape.document;
+    const validation = validateChildPlan(document.plan, new Set());
+    if (!validation.ok) {
+        throw new SplitResumeError(`Cannot resume split with invalid references/split-plan.json: ${validation.errors
+            .map((error) => error.message)
+            .join('; ')}`);
+    }
+    const missingChildren = [];
+    for (const child of document.plan.children) {
+        if (!(await exists(join(context.repoRoot, projectsRoot, child.slug)))) {
+            missingChildren.push(child.slug);
+        }
+    }
+    return {
+        document,
+        plan: document.plan,
+        missingChildren,
+        parentProjectPath,
+        projectsRoot,
+    };
+}
+export async function resumeSplit(parentPath, context, options = {}) {
+    const partial = await detectPartialSplit(parentPath, context);
+    if (options.confirmed !== true) {
+        throw new SplitResumeError('Split resume requires explicit confirmation before writing missing children.');
+    }
+    return continueSplitResume(partial, context);
+}
+export async function continueSplitResume(partial, context) {
+    if (partial.missingChildren.length > 0) {
+        await seedChildren(partial.plan, { ...context, projectsRoot: partial.projectsRoot }, new Set(partial.missingChildren));
+    }
+    await finalizeSplit(partial.plan, {
+        ...context,
+        projectsRoot: partial.projectsRoot,
+    });
+    return partial;
+}

package/dist/projects/split/seed-children.d.ts

@@ -0,0 +1,9 @@
+import type { ChildPlan } from './child-plan.js';
+import type { SplitProjectContext } from './write-parent.js';
+declare const SEEDED_SECTIONS: readonly ["Origin", "Inherited Context", "Child Scope", "Known Dependencies", "Assumptions To Revalidate", "Likely Workflow Mode", "Sibling Projects"];
+export interface SeedChildrenResult {
+    childProjectPaths: string[];
+}
+export declare function seedChildren(plan: ChildPlan, context: SplitProjectContext, onlySlugs?: Set<string>): Promise<SeedChildrenResult>;
+export { SEEDED_SECTIONS };
+//# sourceMappingURL=seed-children.d.ts.map

package/dist/projects/split/seed-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-children.d.ts","sourceRoot":"","sources":["../../../src/projects/split/seed-children.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,QAAA,MAAM,eAAe,wJAQX,CAAC;AAoFX,MAAM,WAAW,kBAAkB;IACjC,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,mBAAmB,EAC5B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,OAAO,CAAC,kBAAkB,CAAC,CA4C7B;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}