@tea-agent/loop-agent 0.2.1 → 0.3.0

package/dist/commands/init.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { access, copyFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -5,6 +6,7 @@ import { copyDir } from "../shared/copy-dir.js";
 import { loadHarnessManifest } from "../governance/harness.js";
 const MANAGED_BLOCK_START = "<!-- LOOP_AGENT_INIT_START -->";
 const MANAGED_BLOCK_END = "<!-- LOOP_AGENT_INIT_END -->";
+const INIT_SURFACE_STATE_PATH = ".harness/init-surface.json";
 const CORE_DOC_FILES = [
     "README.md",
     "architecture/runtime-boundaries.md",
@@ -846,6 +848,236 @@ async function writeCompatPrompts(input) {
         });
     }
 }
+function sha256Text(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function sha256Buffer(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeRelativePath(relativePath) {
+    return relativePath.split(path.sep).join("/");
+}
+function manifestPathToTargetPath(relativePath, governanceRoot) {
+    if (governanceRoot !== "docs" && relativePath.startsWith("docs/")) {
+        return `${governanceRoot}/${relativePath.slice("docs/".length)}`;
+    }
+    return relativePath;
+}
+function targetPathToManifestPath(relativePath, governanceRoot) {
+    if (governanceRoot !== "docs" && relativePath.startsWith(`${governanceRoot}/`)) {
+        return `docs/${relativePath.slice(`${governanceRoot}/`.length)}`;
+    }
+    return relativePath;
+}
+async function readPackageVersion(assetRoot) {
+    const packageJson = JSON.parse(await readFile(path.join(assetRoot, "package.json"), "utf-8"));
+    return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+}
+async function readInitSurfaceManifest(assetRoot) {
+    const manifestPath = path.join(assetRoot, "docs", "init-surface.manifest.json");
+    const raw = await readFile(manifestPath, "utf-8");
+    const manifest = JSON.parse(raw);
+    const initFullRequired = manifest.initFullRequired ?? [];
+    const initSurface = manifest.initSurface ?? {};
+    const entries = initFullRequired.map((relativePath) => ({
+        path: relativePath,
+        mode: initSurface[relativePath] ?? inferInitSurfaceMode(relativePath),
+    }));
+    if (!entries.some((entry) => entry.path === INIT_SURFACE_STATE_PATH)) {
+        entries.push({ path: INIT_SURFACE_STATE_PATH, mode: "state" });
+    }
+    return { manifest, raw, sha256: sha256Text(raw), entries };
+}
+function inferInitSurfaceMode(relativePath) {
+    if (relativePath === INIT_SURFACE_STATE_PATH)
+        return "state";
+    if (relativePath === ".harness/tasks" ||
+        relativePath === ".harness/dag-runs/active" ||
+        relativePath.endsWith("/")) {
+        return "directory";
+    }
+    if (relativePath === "README.md" || relativePath === "AGENTS.md")
+        return "managed-block";
+    if (relativePath === "harness.json" ||
+        relativePath.startsWith("scripts/") ||
+        relativePath.startsWith(".harness/prompts/") ||
+        relativePath.startsWith("docs/README.md") ||
+        relativePath.startsWith("docs/development-principles.md") ||
+        relativePath.startsWith("docs/feature-workflow.md") ||
+        relativePath.startsWith("docs/verification-matrix.md") ||
+        relativePath.startsWith("docs/loop-agent-harness.md") ||
+        relativePath.startsWith("docs/architecture/runtime-boundaries.md")) {
+        return "generated";
+    }
+    return "copied";
+}
+async function buildDesiredSurfaceContent(input) {
+    const manifestPath = targetPathToManifestPath(input.entry.path, input.governanceRoot);
+    if (input.entry.mode === "directory" || input.entry.mode === "state")
+        return {};
+    if (manifestPath === "README.md") {
+        return {
+            content: buildManagedReadmeBlock({
+                projectName: input.projectName,
+                governanceRoot: input.governanceRoot,
+            }),
+        };
+    }
+    if (manifestPath === "AGENTS.md") {
+        return {
+            content: buildManagedAgentsBlock({
+                projectName: input.projectName,
+                governanceRoot: input.governanceRoot,
+            }),
+        };
+    }
+    if (manifestPath === "harness.json") {
+        const template = await readJsonIfExists(path.join(input.assetRoot, "harness.json"));
+        return {
+            content: `${JSON.stringify(buildHarness({
+                existing: {},
+                template,
+                projectName: input.projectName,
+                governanceRoot: input.governanceRoot,
+            }), null, 2)}\n`,
+        };
+    }
+    if (manifestPath.startsWith("scripts/")) {
+        const scripts = buildInitScriptFiles(input.governanceRoot);
+        return { content: scripts[manifestPath] };
+    }
+    if (manifestPath.startsWith(".harness/prompts/")) {
+        const name = path.basename(manifestPath);
+        return { content: COMPAT_PROMPTS[name] };
+    }
+    if (manifestPath.startsWith("docs/")) {
+        const doc = manifestPath.slice("docs/".length);
+        const generated = buildGeneratedCoreDoc({
+            doc,
+            projectName: input.projectName,
+            governanceRoot: input.governanceRoot,
+        });
+        if (generated !== undefined)
+            return { content: generated };
+    }
+    const sourcePath = path.join(input.assetRoot, manifestPath);
+    if (await exists(sourcePath))
+        return { content: await readFile(sourcePath, "utf-8"), sourcePath };
+    return {};
+}
+function extractManagedBlock(content) {
+    const start = content.indexOf(MANAGED_BLOCK_START);
+    const end = content.indexOf(MANAGED_BLOCK_END);
+    if (start < 0 || end <= start)
+        return undefined;
+    return content.slice(start, end + MANAGED_BLOCK_END.length);
+}
+async function readExistingSurfaceState(repoRoot) {
+    const filePath = path.join(repoRoot, INIT_SURFACE_STATE_PATH);
+    if (!(await exists(filePath)))
+        return undefined;
+    const parsed = JSON.parse(await readFile(filePath, "utf-8"));
+    if (!isRecord(parsed) || parsed.schemaVersion !== 1)
+        return undefined;
+    return parsed;
+}
+async function buildCurrentSurfaceState(input) {
+    const assetRoot = await findPackageRoot();
+    const controllerVersion = await readPackageVersion(assetRoot);
+    const manifest = await readInitSurfaceManifest(assetRoot);
+    const files = {};
+    for (const manifestEntry of manifest.entries) {
+        const targetRelativePath = normalizeRelativePath(manifestPathToTargetPath(manifestEntry.path, input.governanceRoot));
+        const entry = { ...manifestEntry, path: targetRelativePath };
+        const targetPath = path.join(input.repoRoot, targetRelativePath);
+        const targetStat = await stat(targetPath).catch(() => null);
+        const desired = await buildDesiredSurfaceContent({
+            assetRoot,
+            repoRoot: input.repoRoot,
+            projectName: input.projectName,
+            governanceRoot: input.governanceRoot,
+            entry,
+        });
+        const sourceSha256 = desired.content === undefined ? undefined : sha256Text(desired.content);
+        const base = {
+            status: targetStat ? "present" : "missing",
+            relationship: "missing-from-target",
+            sourceSha256,
+            sourcePath: desired.sourcePath ? repoRelative(assetRoot, desired.sourcePath) : undefined,
+            mode: entry.mode,
+        };
+        if (entry.mode === "state") {
+            files[targetRelativePath] = {
+                ...base,
+                status: "present",
+                relationship: "state-file",
+            };
+            continue;
+        }
+        if (!targetStat) {
+            files[targetRelativePath] = base;
+            continue;
+        }
+        if (entry.mode === "directory") {
+            files[targetRelativePath] = {
+                ...base,
+                relationship: targetStat.isDirectory() ? "directory-present" : "local-existing-unknown",
+            };
+            continue;
+        }
+        const current = await readFile(targetPath);
+        const currentSha256 = sha256Buffer(current);
+        if (entry.mode === "managed-block") {
+            const currentBlock = extractManagedBlock(current.toString("utf-8"));
+            files[targetRelativePath] = {
+                ...base,
+                currentSha256,
+                relationship: currentBlock && sourceSha256 && sha256Text(currentBlock) === sourceSha256
+                    ? "managed-block-current"
+                    : "managed-block-present",
+            };
+            continue;
+        }
+        files[targetRelativePath] = {
+            ...base,
+            currentSha256,
+            relationship: sourceSha256 && currentSha256 === sourceSha256
+                ? entry.mode === "generated"
+                    ? "matches-current-generated"
+                    : "matches-current-package"
+                : "local-existing-unknown",
+        };
+    }
+    return {
+        schemaVersion: 1,
+        controllerVersion,
+        stateKind: input.stateKind,
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+        manifestSha256: manifest.sha256,
+        files,
+    };
+}
+async function writeInitSurfaceState(input) {
+    const state = await buildCurrentSurfaceState(input);
+    const target = path.join(input.repoRoot, INIT_SURFACE_STATE_PATH);
+    await mkdir(path.dirname(target), { recursive: true });
+    await writeFile(target, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+    return state;
+}
+async function resolveInitProjectContext(input) {
+    const harness = await readJsonIfExists(path.join(input.repoRoot, "harness.json"));
+    return {
+        projectName: input.projectName ??
+            (typeof harness.project === "string" ? harness.project : undefined) ??
+            path.basename(input.repoRoot),
+        governanceRoot: input.governanceRoot ??
+            (typeof harness.governanceRoot === "string" ? harness.governanceRoot : undefined) ??
+            "docs",
+    };
+}
 function buildManagedReadmeBlock(input) {
     return [
         MANAGED_BLOCK_START,
@@ -1389,8 +1621,277 @@ export async function initializeLoopAgentProject(options) {
     }
     await ensureHarnessDirs(repoRoot, written);
     await writeCompatPrompts({ repoRoot, merge, written, skipped });
+    await writeInitSurfaceState({ repoRoot, projectName, governanceRoot, stateKind: "recorded" });
+    written.push(INIT_SURFACE_STATE_PATH);
     return { repoRoot, projectName, governanceRoot, profile, written, skipped };
 }
+function actionForMissing(pathName, state) {
+    if (state.mode === "state")
+        return undefined;
+    if (state.mode === "directory") {
+        return { type: "create-directory", path: pathName, reason: "required init directory is missing" };
+    }
+    if (state.mode === "copied") {
+        return { type: "copy-missing", path: pathName, reason: "required bundled init file is missing" };
+    }
+    if (state.mode === "generated") {
+        return { type: "write-generated-missing", path: pathName, reason: "required generated init file is missing" };
+    }
+    return { type: "refresh-managed-block", path: pathName, reason: "managed block file is missing or stale" };
+}
+function modelMergeTaskFor(pathName, state, allPaths) {
+    return {
+        path: pathName,
+        reason: "target file exists but does not match the current loop-agent initialization surface",
+        sourcePath: state.sourcePath,
+        allowedPaths: [pathName],
+        forbiddenPaths: [
+            ...allPaths.filter((candidate) => candidate !== pathName),
+            ".harness/dag-runs/**",
+            ".harness/runs/**",
+            ".git/**",
+        ],
+        mergeRules: [
+            "Preserve target-project user content and project-specific commands.",
+            "Adopt the current loop-agent initialization structure where it does not conflict with local intent.",
+            "Do not delete user-authored sections merely because they differ from the package template.",
+            "Keep writes inside allowedPaths only.",
+        ],
+        verification: [
+            "loop-agent init check-update --repo-root . --json",
+            "loop-agent init doctor --repo-root .",
+            "loop-agent inspect --repo-root .",
+            "bash scripts/check-repo.sh",
+        ],
+    };
+}
+function recommendedNextFor(report) {
+    const next = [];
+    if (report.surfaceState === "missing") {
+        next.push("loop-agent init update --repo-root <target> --bootstrap-surface");
+    }
+    if (report.deterministicActions.some((action) => action.type !== "bootstrap-surface")) {
+        next.push("loop-agent init update --repo-root <target> --apply-safe");
+    }
+    if (report.modelMergeTasks.length > 0) {
+        next.push("loop-agent init check-update --repo-root <target> --markdown");
+    }
+    if (report.humanDecisions.length > 0) {
+        next.push("Review humanDecisions before applying semantic or policy-sensitive changes.");
+    }
+    if (next.length === 0)
+        next.push("No init update actions are needed.");
+    return next;
+}
+export async function checkInitUpdate(input) {
+    const repoRoot = path.resolve(input.repoRoot);
+    const { projectName, governanceRoot } = await resolveInitProjectContext({
+        repoRoot,
+        projectName: input.projectName,
+        governanceRoot: input.governanceRoot,
+    });
+    const recordedState = await readExistingSurfaceState(repoRoot);
+    const surfaceState = recordedState?.stateKind ?? "missing";
+    const currentState = await buildCurrentSurfaceState({
+        repoRoot,
+        projectName,
+        governanceRoot,
+        stateKind: recordedState?.stateKind ?? "inferred-baseline",
+    });
+    const allPaths = Object.keys(currentState.files).sort();
+    const deterministicActions = [];
+    const modelMergeTasks = [];
+    const humanDecisions = [];
+    if (!recordedState) {
+        deterministicActions.push({
+            type: "bootstrap-surface",
+            path: INIT_SURFACE_STATE_PATH,
+            reason: "target project has no recorded init surface baseline",
+        });
+    }
+    for (const [pathName, state] of Object.entries(currentState.files)) {
+        if (state.relationship === "missing-from-target") {
+            const action = actionForMissing(pathName, state);
+            if (action)
+                deterministicActions.push(action);
+            continue;
+        }
+        if (state.relationship === "managed-block-present") {
+            deterministicActions.push({
+                type: "refresh-managed-block",
+                path: pathName,
+                reason: "managed block is missing or differs from the current package block",
+            });
+            continue;
+        }
+        if (state.relationship === "local-existing-unknown") {
+            if (state.mode === "directory") {
+                humanDecisions.push({
+                    path: pathName,
+                    reason: "required init directory path exists but is not a directory",
+                });
+            }
+            else {
+                modelMergeTasks.push(modelMergeTaskFor(pathName, state, allPaths));
+            }
+        }
+    }
+    const partial = {
+        repoRoot,
+        controllerVersion: currentState.controllerVersion,
+        surfaceState,
+        deterministicActions,
+        modelMergeTasks,
+        humanDecisions,
+        summary: {
+            missing: deterministicActions.filter((action) => action.type !== "bootstrap-surface").length,
+            modelMerge: modelMergeTasks.length,
+            humanDecision: humanDecisions.length,
+        },
+    };
+    const recommendedNext = recommendedNextFor(partial);
+    return {
+        ...partial,
+        ok: deterministicActions.length === 0 &&
+            modelMergeTasks.length === 0 &&
+            humanDecisions.length === 0,
+        recommendedNext,
+    };
+}
+async function applySafeAction(input) {
+    const assetRoot = await findPackageRoot();
+    const entry = {
+        path: input.action.path,
+        mode: input.action.type === "create-directory"
+            ? "directory"
+            : input.action.type === "copy-missing"
+                ? "copied"
+                : input.action.type === "refresh-managed-block"
+                    ? "managed-block"
+                    : "generated",
+    };
+    const target = path.join(input.repoRoot, input.action.path);
+    if (input.action.type === "create-directory") {
+        if (await exists(target))
+            return false;
+        await mkdir(target, { recursive: true });
+        return true;
+    }
+    const desired = await buildDesiredSurfaceContent({
+        assetRoot,
+        repoRoot: input.repoRoot,
+        projectName: input.projectName,
+        governanceRoot: input.governanceRoot,
+        entry,
+    });
+    if (desired.content === undefined)
+        return false;
+    await mkdir(path.dirname(target), { recursive: true });
+    if (input.action.type === "refresh-managed-block") {
+        const existing = (await exists(target)) ? await readFile(target, "utf-8") : "";
+        const next = input.action.path === "README.md" && existing.trim().length === 0
+            ? buildTargetReadme({ projectName: input.projectName, governanceRoot: input.governanceRoot })
+            : input.action.path === "AGENTS.md" && existing.trim().length === 0
+                ? `# AGENTS.md\n\n${desired.content}\n`
+                : mergeManagedBlock(existing, desired.content);
+        await writeFile(target, next, "utf-8");
+        return true;
+    }
+    if (await exists(target))
+        return false;
+    await writeFile(target, desired.content, "utf-8");
+    return true;
+}
+export async function applyInitUpdate(input) {
+    const repoRoot = path.resolve(input.repoRoot);
+    const { projectName, governanceRoot } = await resolveInitProjectContext({
+        repoRoot,
+        projectName: input.projectName,
+        governanceRoot: input.governanceRoot,
+    });
+    const applied = [];
+    const skipped = [];
+    if (input.bootstrapSurface) {
+        await writeInitSurfaceState({ repoRoot, projectName, governanceRoot, stateKind: "inferred-baseline" });
+        applied.push({
+            type: "bootstrap-surface",
+            path: INIT_SURFACE_STATE_PATH,
+            reason: "wrote inferred init surface baseline",
+        });
+    }
+    if (input.applySafe) {
+        const report = await checkInitUpdate({ repoRoot, projectName, governanceRoot });
+        for (const action of report.deterministicActions) {
+            if (action.type === "bootstrap-surface") {
+                skipped.push(action);
+                continue;
+            }
+            const currentState = await buildCurrentSurfaceState({
+                repoRoot,
+                projectName,
+                governanceRoot,
+                stateKind: "inferred-baseline",
+            });
+            const relationship = currentState.files[action.path]?.relationship;
+            if (relationship === "local-existing-unknown") {
+                skipped.push(action);
+                continue;
+            }
+            if (await applySafeAction({ repoRoot, projectName, governanceRoot, action }))
+                applied.push(action);
+            else
+                skipped.push(action);
+        }
+        await writeInitSurfaceState({ repoRoot, projectName, governanceRoot, stateKind: "inferred-baseline" });
+    }
+    return {
+        applied,
+        skipped,
+        report: await checkInitUpdate({ repoRoot, projectName, governanceRoot }),
+    };
+}
+function formatCheckUpdateText(report) {
+    return [
+        `loop-agent init update check for ${report.repoRoot}`,
+        `controllerVersion: ${report.controllerVersion}`,
+        `surfaceState: ${report.surfaceState}`,
+        `deterministicActions: ${report.deterministicActions.length}`,
+        `modelMergeTasks: ${report.modelMergeTasks.length}`,
+        `humanDecisions: ${report.humanDecisions.length}`,
+        "recommendedNext:",
+        ...report.recommendedNext.map((item) => `- ${item}`),
+    ].join("\n");
+}
+function formatCheckUpdateMarkdown(report) {
+    const lines = [
+        "# loop-agent init check-update",
+        "",
+        `- repoRoot: \`${report.repoRoot}\``,
+        `- controllerVersion: \`${report.controllerVersion}\``,
+        `- surfaceState: \`${report.surfaceState}\``,
+        "",
+        "## Deterministic Actions",
+        "",
+        ...(report.deterministicActions.length
+            ? report.deterministicActions.map((action) => `- \`${action.type}\` \`${action.path}\`: ${action.reason}`)
+            : ["- None"]),
+        "",
+        "## Model Merge Tasks",
+        "",
+    ];
+    if (report.modelMergeTasks.length === 0) {
+        lines.push("- None", "");
+    }
+    else {
+        for (const task of report.modelMergeTasks) {
+            lines.push(`### ${task.path}`, "", task.reason, "", "allowedPaths:", ...task.allowedPaths.map((item) => `- ${item}`), "", "forbiddenPaths:", ...task.forbiddenPaths.map((item) => `- ${item}`), "", "mergeRules:", ...task.mergeRules.map((item) => `- ${item}`), "", "verification:", ...task.verification.map((item) => `- ${item}`), "");
+        }
+    }
+    lines.push("## Human Decisions", "", ...(report.humanDecisions.length
+        ? report.humanDecisions.map((decision) => `- \`${decision.path}\`: ${decision.reason}`)
+        : ["- None"]), "", "## Recommended Next", "", ...report.recommendedNext.map((item) => `- ${item}`), "");
+    return lines.join("\n");
+}
 export async function runInitDoctor(input) {
     const repoRoot = path.resolve(input.repoRoot);
     const checks = [];
@@ -1432,9 +1933,12 @@ function parseInitArgs(repoRoot, args) {
     let provider;
     let model;
     let json = false;
+    let markdown = false;
+    let bootstrapSurface = false;
+    let applySafe = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
-        if ((arg === "instructions" || arg === "doctor") && !subcommand) {
+        if ((arg === "instructions" || arg === "doctor" || arg === "check-update" || arg === "update") && !subcommand) {
             subcommand = arg;
             continue;
         }
@@ -1464,6 +1968,12 @@ function parseInitArgs(repoRoot, args) {
             model = arg.slice("--model=".length);
         else if (arg === "--json")
             json = true;
+        else if (arg === "--markdown")
+            markdown = true;
+        else if (arg === "--bootstrap-surface")
+            bootstrapSurface = true;
+        else if (arg === "--apply-safe")
+            applySafe = true;
         else if (arg.startsWith("-"))
             throw new Error(`unknown init flag: ${arg}`);
         else
@@ -1471,7 +1981,20 @@ function parseInitArgs(repoRoot, args) {
     }
     if (profile !== "full" && profile !== "minimal")
         throw new Error("init --profile must be full or minimal");
-    return { repoRoot, projectName, governanceRoot, profile, merge, provider, model, subcommand, json };
+    return {
+        repoRoot,
+        projectName,
+        governanceRoot,
+        profile,
+        merge,
+        provider,
+        model,
+        subcommand,
+        json,
+        markdown,
+        bootstrapSurface,
+        applySafe,
+    };
 }
 export async function runInit(repoRoot, rawArgs) {
     const parsed = parseInitArgs(repoRoot, rawArgs);
@@ -1486,9 +2009,38 @@ export async function runInit(repoRoot, rawArgs) {
             process.exitCode = 1;
         return;
     }
+    if (parsed.subcommand === "check-update") {
+        const report = await checkInitUpdate(parsed);
+        if (parsed.json)
+            console.log(JSON.stringify(report, null, 2));
+        else if (parsed.markdown)
+            console.log(formatCheckUpdateMarkdown(report));
+        else
+            console.log(formatCheckUpdateText(report));
+        return;
+    }
+    if (parsed.subcommand === "update") {
+        if (!parsed.bootstrapSurface && !parsed.applySafe) {
+            throw new Error("usage: init update [--bootstrap-surface] [--apply-safe]");
+        }
+        const result = await applyInitUpdate(parsed);
+        console.log(parsed.json ? JSON.stringify(result, null, 2) : formatInitUpdateResult(result));
+        return;
+    }
     const result = await initializeLoopAgentProject(parsed);
     console.log(parsed.json ? JSON.stringify(result, null, 2) : formatInitResult(result));
 }
+function formatInitUpdateResult(result) {
+    return [
+        "loop-agent init update complete",
+        `applied: ${result.applied.length}`,
+        `skipped: ${result.skipped.length}`,
+        `remaining deterministicActions: ${result.report.deterministicActions.length}`,
+        `remaining modelMergeTasks: ${result.report.modelMergeTasks.length}`,
+        "recommendedNext:",
+        ...result.report.recommendedNext.map((item) => `- ${item}`),
+    ].join("\n");
+}
 function formatInitResult(result) {
     return [
         `Initialized loop-agent harness at ${result.repoRoot}`,

package/dist/workflows/dag/dynamic-runtime/loop-until.js

@@ -27,7 +27,7 @@ function renderLoopTemplate(template, iteration) {
         .replace(/\{\{\s*iteration\s*\}\}/g, String(iteration))
         .replace(/\{\{\s*iterationStatus\s*\}\}/g, iterationStatus);
 }
-function buildLoopBodyChildTask(input) {
+export function buildLoopBodyChildTask(input) {
     const { parent, bodyTask, iteration, nodeId, bodyIdMap } = input;
     const mappedDepends = bodyTask.dependsOn.map((depId) => bodyIdMap.get(depId) ?? depId);
     return {
@@ -37,6 +37,7 @@ function buildLoopBodyChildTask(input) {
         subtask_prompt: renderLoopTemplate(bodyTask.subtaskPromptTemplate, iteration),
         executor: bodyTask.executor,
         role: bodyTask.role,
+        skills: bodyTask.skills,
         writePolicy: bodyTask.writePolicy,
         allowedPaths: bodyTask.allowedPaths,
         forbiddenPaths: bodyTask.forbiddenPaths,

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -18,6 +18,7 @@ export function buildExpandedChildTask(input) {
         subtask_prompt: subtaskPrompt,
         executor: child.executor,
         role: child.role,
+        skills: child.skills,
         writePolicy: child.writePolicy,
         allowedPaths: renderDynamicPatternList(child.allowedPaths, item, index, expansion.itemName) ?? [],
         forbiddenPaths: renderDynamicPatternList(child.forbiddenPaths, item, index, expansion.itemName) ?? [],

package/dist/workflows/dag/init-hybrid.js

@@ -22,9 +22,9 @@ const HYBRID_DEFAULTS = {
 };
 const HYBRID_SKILLS_BY_ROLE = {
     planner: ["loop-agent"],
-    scout: ["ai-engineering-context"],
-    implementer: ["verification-before-completion"],
-    reviewer: ["requesting-code-review"],
+    scout: ["ai-engineering-context", "codebase-scout"],
+    implementer: ["test-driven-development", "verification-before-completion"],
+    reviewer: ["requesting-code-review", "code-review-core"],
     verifier: ["verification-before-completion", "systematic-debugging"],
     closeout: ["loop-agent", "verification-before-completion"],
 };

package/dist/workflows/dag/skills.js

@@ -4,10 +4,10 @@
  */
 export const DEFAULT_SKILLS_BY_ROLE = {
     planner: ["loop-agent"],
-    scout: ["ai-engineering-context"],
-    implementer: ["verification-before-completion"],
+    scout: ["ai-engineering-context", "codebase-scout"],
+    implementer: ["test-driven-development", "verification-before-completion"],
     verifier: ["verification-before-completion", "systematic-debugging"],
-    reviewer: ["requesting-code-review"],
+    reviewer: ["requesting-code-review", "code-review-core"],
     supervisor: ["verification-before-completion", "loop-agent"],
     closeout: ["loop-agent", "verification-before-completion"],
 };

package/dist/workflows/dag/types.js

@@ -94,6 +94,7 @@ export const dagStaticConfigSchema = z.object({
 export const dagDynamicExpansionChildTaskSchema = z.object({
     executor: dagNodeExecutorSchema.default("pi"),
     role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
     complexity: dagComplexitySchema.default("LOW"),
     subtaskPromptTemplate: z.string().min(1),
     outputContract: z.string().optional(),
@@ -153,6 +154,7 @@ export const dagDynamicLoopBodyTaskSchema = z.object({
     dependsOn: z.array(z.string()).default([]),
     executor: dagNodeExecutorSchema.default("pi"),
     role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
     complexity: dagComplexitySchema.default("LOW"),
     subtaskPromptTemplate: z.string().min(1),
     outputContract: z.string().optional(),