@open-agent-toolkit/cli 0.1.4 → 0.1.6

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"}

package/dist/projects/split/seed-children.js

@@ -0,0 +1,122 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { scaffoldProject as defaultScaffoldProject } from '../../commands/project/new/scaffold.js';
+import { getFrontmatterBlock } from '../../commands/shared/frontmatter.js';
+import { replaceFrontmatter } from '../../commands/shared/frontmatter-write.js';
+import YAML from 'yaml';
+const SEEDED_SECTIONS = [
+    'Origin',
+    'Inherited Context',
+    'Child Scope',
+    'Known Dependencies',
+    'Assumptions To Revalidate',
+    'Likely Workflow Mode',
+    'Sibling Projects',
+];
+function readObjectFrontmatter(content, filePath) {
+    const block = getFrontmatterBlock(content);
+    if (!block) {
+        if (content.startsWith('---\n---')) {
+            return {};
+        }
+        throw new Error(`${filePath} is missing frontmatter`);
+    }
+    if (block.trim().length === 0) {
+        return {};
+    }
+    const parsed = YAML.parse(block);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${filePath} frontmatter must be an object`);
+    }
+    return parsed;
+}
+async function updateFrontmatter(filePath, updates) {
+    const content = await readFile(filePath, 'utf8');
+    const frontmatter = readObjectFrontmatter(content, filePath);
+    for (const [key, value] of Object.entries(updates)) {
+        frontmatter[key] = value;
+    }
+    const nextBlock = YAML.stringify(frontmatter).trimEnd();
+    const nextContent = getFrontmatterBlock(content)
+        ? replaceFrontmatter(content, nextBlock)
+        : content.replace(/^---\n---/, `---\n${nextBlock}\n---`);
+    await writeFile(filePath, nextContent, 'utf8');
+}
+function bulletList(items) {
+    if (items.length === 0) {
+        return '- None.';
+    }
+    return items.map((item) => `- ${item}`).join('\n');
+}
+function renderSeededDiscovery(plan, child) {
+    const siblingSlugs = plan.children
+        .map((candidate) => candidate.slug)
+        .filter((slug) => slug !== child.slug);
+    const sections = [
+        ['Origin', `Split from coordination parent \`${plan.parentSlug}\`.`],
+        [
+            'Inherited Context',
+            child.inheritedContext || 'No inherited context provided.',
+        ],
+        ['Child Scope', child.description ?? child.slug],
+        ['Known Dependencies', bulletList(child.knownDependencies)],
+        [
+            'Assumptions To Revalidate',
+            '- Revalidate inherited context before completing discovery.',
+        ],
+        ['Likely Workflow Mode', 'quick'],
+        ['Sibling Projects', bulletList(siblingSlugs)],
+    ];
+    return [
+        '---',
+        'oat_status: in_progress',
+        'oat_ready_for: null',
+        'oat_blockers: []',
+        'oat_inherited_context_revalidated: false',
+        'oat_generated: false',
+        '---',
+        '',
+        `# Discovery: ${child.slug}`,
+        '',
+        ...sections.flatMap(([heading, body]) => [`## ${heading}`, '', body, '']),
+    ].join('\n');
+}
+export async function seedChildren(plan, context, onlySlugs) {
+    const scaffoldProject = context.scaffoldProject ?? defaultScaffoldProject;
+    const childProjectPaths = [];
+    const orderedChildren = plan.children
+        .slice()
+        .sort((left, right) => left.order - right.order)
+        .filter((child) => !onlySlugs || onlySlugs.has(child.slug));
+    for (const child of orderedChildren) {
+        const scaffold = await scaffoldProject({
+            repoRoot: context.repoRoot,
+            projectName: child.slug,
+            mode: 'quick',
+            setActive: false,
+            refreshDashboard: false,
+            env: context.env,
+            today: context.today,
+            nowUtc: context.nowUtc,
+        });
+        const childRoot = join(context.repoRoot, scaffold.projectPath);
+        const siblings = plan.children
+            .map((candidate) => candidate.slug)
+            .filter((slug) => slug !== child.slug);
+        await updateFrontmatter(join(childRoot, 'state.md'), {
+            oat_phase: 'discovery',
+            oat_workflow_mode: 'quick',
+            oat_hill_checkpoints: [],
+            oat_parent: plan.parentSlug,
+            oat_siblings: siblings,
+            oat_depends_on: child.knownDependencies,
+        });
+        await updateFrontmatter(join(childRoot, 'plan.md'), {
+            oat_plan_source: 'quick',
+        });
+        await writeFile(join(childRoot, 'discovery.md'), renderSeededDiscovery(plan, child), 'utf8');
+        childProjectPaths.push(scaffold.projectPath);
+    }
+    return { childProjectPaths };
+}
+export { SEEDED_SECTIONS };

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

@@ -0,0 +1,10 @@
+export type Signal = 'independently-shippable' | 'no-shared-design-surface' | 'expect-separate-prs' | 'distinct-subsystems';
+export interface SignalEvaluation {
+    fired: Signal[];
+    triggered: boolean;
+    confidence: 'high' | 'soft' | 'below';
+}
+export declare function evaluateSignals(input: {
+    fired: Signal[];
+}): SignalEvaluation;
+//# sourceMappingURL=signals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../../src/projects/split/signals.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GACd,yBAAyB,GACzB,0BAA0B,GAC1B,qBAAqB,GACrB,qBAAqB,CAAC;AAE1B,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CACvC;AAOD,wBAAgB,eAAe,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,gBAAgB,CAiB5E"}

package/dist/projects/split/signals.js

@@ -0,0 +1,18 @@
+const LOAD_BEARING = new Set([
+    'independently-shippable',
+    'no-shared-design-surface',
+]);
+export function evaluateSignals(input) {
+    const fired = [...new Set(input.fired)];
+    const triggered = fired.length >= 2;
+    const loadBearingCount = fired.filter((signal) => LOAD_BEARING.has(signal)).length;
+    let confidence = 'below';
+    if (triggered) {
+        confidence = loadBearingCount === LOAD_BEARING.size ? 'high' : 'soft';
+    }
+    return {
+        fired,
+        triggered,
+        confidence,
+    };
+}

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

@@ -0,0 +1,14 @@
+import type { ChildPlan } from './child-plan.js';
+export interface ValidationError {
+    code: 'slug-collision-existing' | 'duplicate-child-slug' | 'parent-child-slug-collision' | 'unknown-dependency' | 'dependency-cycle' | 'unknown-foundation-child' | 'unknown-initial-active-child';
+    message: string;
+    slug?: string;
+}
+export type ValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    errors: ValidationError[];
+};
+export declare function validateChildPlan(plan: ChildPlan, existingSlugs: Set<string>): ValidationResult;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/projects/split/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,WAAW,eAAe;IAC9B,IAAI,EACA,yBAAyB,GACzB,sBAAsB,GACtB,6BAA6B,GAC7B,oBAAoB,GACpB,kBAAkB,GAClB,0BAA0B,GAC1B,8BAA8B,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAgD7C,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,EACf,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,gBAAgB,CA2ElB"}