cloving 1.3.0 → 1.4.0

package/dist/src/workflow-contracts.js

@@ -43,7 +43,7 @@ const outcomes = {
     },
     handoff_requested: {
         keys: ["cycleId", "kind", "promotionId"],
-        optional: ["ticketStatus", "issueUpdate", "reason"],
+        optional: ["ticketStatus", "issueUpdate", "reason", "report"],
         parse: (fields) => {
             const cycleId = textField(fields, {
                 key: "cycleId",
@@ -58,6 +58,9 @@ const outcomes = {
             const ticketStatus = fields["ticketStatus"];
             const issueUpdate = fields["issueUpdate"];
             const reason = fields["reason"];
+            const report = fields["report"];
+            if (!validReport(report))
+                return null;
             if (issueUpdate !== undefined && issueUpdate !== "failed")
                 return null;
             if (ticketStatus !== undefined && !isTicketStatus(ticketStatus))
@@ -68,11 +71,15 @@ const outcomes = {
                 kind: "handoff_requested",
                 cycleId,
                 promotionId,
-                ...Object.fromEntries(Object.entries({ issueUpdate, ticketStatus, reason }).filter(([, value]) => value !== undefined)),
+                ...Object.fromEntries(Object.entries({ issueUpdate, ticketStatus, reason, report }).filter(([, value]) => value !== undefined)),
             };
         },
     },
 };
+function validReport(report) {
+    return (report === undefined ||
+        (typeof report === "string" && report.length > 0 && report.length <= 65536));
+}
 export function validateDevelopmentInput(value) {
     const fields = exactFields(value, { required: ["cycleId"] });
     const cycleId = fields && textField(fields, { key: "cycleId", pattern: identifier });

package/dist/src/workflow-discovery.d.ts

@@ -1,19 +1,8 @@
-export interface WorkflowReservation {
-    readonly baseName?: string;
-    readonly workflowId?: string;
-    readonly functionName?: string;
-}
 export interface WorkflowDiscoveryIdentity {
     readonly queue?: boolean;
     readonly baseName: string;
     readonly workflowId: string | undefined;
     readonly functionNames: readonly string[];
 }
-export type WorkflowConflictCode = "workflow-conflict" | "bundled-name-reserved" | "queue-workflow-conflict";
-export declare function workflowConflicts(candidates: readonly WorkflowDiscoveryIdentity[], bundled: readonly WorkflowReservation[]): readonly (readonly WorkflowConflictCode[])[];
-export declare const bundledWorkflowIds: {
-    readonly ticket: "develop-ticket";
-    readonly issue: "develop-issue";
-    readonly prompt: "develop-prompt";
-    readonly prd: "develop-prd";
-};
+export type WorkflowConflictCode = "workflow-conflict" | "queue-workflow-conflict";
+export declare function workflowConflicts(candidates: readonly WorkflowDiscoveryIdentity[]): readonly (readonly WorkflowConflictCode[])[];

package/dist/src/workflow-discovery.js

@@ -5,32 +5,20 @@ function identityKeys(identity) {
         ...identity.functionNames.map((name) => `function:${name}`),
     ];
 }
-export function workflowConflicts(candidates, bundled) {
+export function workflowConflicts(candidates) {
     const keys = candidates.map(identityKeys);
     const counts = new Map();
     for (const names of keys) {
         for (const name of new Set(names))
             counts.set(name, (counts.get(name) ?? 0) + 1);
     }
-    const reserved = new Set(bundled.flatMap((entry) => identityKeys({
-        ...entry,
-        functionNames: entry.functionName === undefined ? [] : [entry.functionName],
-    })));
     const queued = candidates.filter((candidate) => candidate.queue === true);
     return keys.map((names, index) => {
         const codes = [];
         if (queued.length > 1 && candidates[index]?.queue === true)
             codes.push("queue-workflow-conflict");
-        if (names.some((name) => reserved.has(name)))
-            codes.push("bundled-name-reserved");
         if (names.some((name) => (counts.get(name) ?? 0) > 1))
             codes.push("workflow-conflict");
         return codes;
     });
 }
-export const bundledWorkflowIds = {
-    ticket: "develop-ticket",
-    issue: "develop-issue",
-    prompt: "develop-prompt",
-    prd: "develop-prd",
-};

package/dist/src/workflow-refusals.js

@@ -12,7 +12,6 @@ const refusalCodes = new Set([
     "effect-limit",
     "direct-effect",
     "workflow-conflict",
-    "bundled-name-reserved",
     "unsafe-workflow-path",
     "workflow-read-failed",
     "workflow-source-changed",

package/dist/src/workflows.d.ts

@@ -1,6 +1,5 @@
 export { loadCycle, type CycleLoad } from "./steps/load-cycle.ts";
 export { protectedEffect } from "./steps/protected-effect.ts";
-export { decisionGate } from "./steps/decision-gate.ts";
 export { waitForDecision } from "./steps/wait-for-decision.ts";
 export { reviewByPerson } from "./steps/review-by-person.ts";
 export { reviewByAgent } from "./steps/review-by-agent.ts";
@@ -11,6 +10,7 @@ export type { MergeCheckName, MergeReason, MergeRequest, MergeResult, PullReques
 export { handoff } from "./steps/handoff.ts";
 export { waitForRun } from "./steps/wait-for-run.ts";
 export { runCommand } from "./steps/run-command.ts";
+export { waitForCommand, type CommandWaitRequest, type CommandWaitOutcome, } from "./steps/wait-for-command.ts";
 export { sleep } from "./steps/sleep.ts";
 export type { CommandRequest, GateRequest, GateResult, DecisionResult, HandoffRequest, HandoffValue, RunWaitRequest, RunWaitOutcome, ProtectedRequest, ProtectedResult, ProtectedScope, } from "./step-bridge.ts";
 export type { CycleOutcome, DevelopmentInput } from "./workflow-contracts.ts";

package/dist/src/workflows.js

@@ -1,6 +1,5 @@
 export { loadCycle } from "./steps/load-cycle.js";
 export { protectedEffect } from "./steps/protected-effect.js";
-export { decisionGate } from "./steps/decision-gate.js";
 export { waitForDecision } from "./steps/wait-for-decision.js";
 export { reviewByPerson } from "./steps/review-by-person.js";
 export { reviewByAgent } from "./steps/review-by-agent.js";
@@ -9,5 +8,6 @@ export { mergeWhenGreen } from "./steps/merge-when-green.js";
 export { handoff } from "./steps/handoff.js";
 export { waitForRun } from "./steps/wait-for-run.js";
 export { runCommand } from "./steps/run-command.js";
+export { waitForCommand, } from "./steps/wait-for-command.js";
 export { sleep } from "./steps/sleep.js";
 export { ticketStatus } from "./ticket-status.js";

package/dist/tools/red-green-command.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/red-green-command.js

@@ -0,0 +1,174 @@
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { record } from "../src/protocol.js";
+import { configuration } from "../src/configuration-schema.js";
+import { parseCommandSeconds } from "../src/command-settings.js";
+import { redGreenProcess } from "./red-green-process.js";
+function git(argumentsList) {
+    return execFileSync("git", [...argumentsList], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+async function run(input) {
+    const temporary = mkdtempSync(join(tmpdir(), "cloving-red-green-"));
+    const tree = join(temporary, "tree");
+    try {
+        git(["worktree", "add", "--detach", tree, input.revision]);
+        if (input.revision !== input.head)
+            git([
+                "--literal-pathspecs",
+                "-C",
+                tree,
+                "restore",
+                "--source",
+                input.head,
+                "--worktree",
+                "--",
+                ...input.files,
+            ]);
+        const options = {
+            directory: tree,
+            signal: input.signal,
+            milliseconds: input.milliseconds,
+        };
+        const prepared = input.prepare === undefined
+            ? undefined
+            : await redGreenProcess(input.prepare, options);
+        if (prepared !== undefined && prepared.status !== 0)
+            return { ...prepared, prepareFailed: true };
+        const tested = await redGreenProcess([...input.test, ...input.files], options);
+        return tested;
+    }
+    finally {
+        git(["worktree", "remove", "--force", tree]);
+        rmSync(temporary, { recursive: true, force: true });
+    }
+}
+async function redGreenCommand(signal) {
+    if (process.argv.slice(2).includes("--help")) {
+        process.stdout.write('Usage: cloving red-green\n\nReads {"head":"<full commit ID>"} on standard input.\nCLOVING_RED_GREEN configures test, testFiles, prepare, assertionPattern and skipPattern.\nPrints one JSON verdict from temporary detached worktrees.\n');
+        return;
+    }
+    let text = "";
+    for await (const chunk of process.stdin)
+        text += String(chunk);
+    const head = inputHead(text);
+    const { settings, assertion, skip } = redGreenSettings();
+    const { test, testFiles: prefixes, prepare } = settings;
+    if (git(["cat-file", "-t", head]).trim() !== "commit")
+        throw new Error("invalid-red-green-input: head must be a full commit ID");
+    if (git(["rev-parse", "--verify", head]).trim() !== head.toLowerCase())
+        throw new Error("invalid-red-green-input: head must be a full commit ID");
+    const base = git(["merge-base", head, "refs/remotes/origin/HEAD"]).trim();
+    const files = changedTests({ base, head, prefixes });
+    if (files.length === 0) {
+        process.stdout.write(JSON.stringify({
+            verdict: "no-test-change",
+            base,
+            head,
+            files,
+            output: "",
+        }) + "\n");
+        return;
+    }
+    const milliseconds = parseCommandSeconds(process.env["CLOVING_COMMAND_SECONDS"]) * 1000;
+    const options = { head, files, test, prepare, signal, milliseconds };
+    const red = await run({ ...options, revision: base });
+    signal.throwIfAborted();
+    const green = await run({ ...options, revision: head });
+    signal.throwIfAborted();
+    const result = classify({ red, green, assertion, skip });
+    process.stdout.write(JSON.stringify({
+        ...result,
+        output: result.output.slice(-16000),
+        base,
+        head,
+        files,
+    }) + "\n");
+}
+function changedTests(input) {
+    return git([
+        "diff",
+        "--no-renames",
+        "--name-only",
+        "--diff-filter=AMT",
+        "-z",
+        input.base,
+        input.head,
+    ])
+        .split("\0")
+        .filter((file) => input.prefixes.some((prefix) => file.startsWith(prefix)));
+}
+function classify(input) {
+    const { red, green, assertion, skip } = input;
+    for (const result of [red, green])
+        if (result.prepareFailed === true)
+            return { verdict: "prepare-failed", output: result.output };
+    for (const result of [red, green])
+        if (skip.test(result.output))
+            return { verdict: "skipped-test", output: result.output };
+    if (red.status === 0)
+        return { verdict: "false-red", output: red.output };
+    if (red.status === null || !assertion.test(red.output))
+        return { verdict: "red-not-assertion", output: red.output };
+    if (green.status !== 0)
+        return { verdict: "green-failed", output: green.output };
+    return { verdict: "accepted", output: green.output };
+}
+function inputHead(text) {
+    let input;
+    try {
+        input = JSON.parse(text);
+    }
+    catch {
+        throw new Error("invalid-red-green-input: expected JSON with a full commit ID in head");
+    }
+    const head = record(input)?.["head"];
+    if (typeof head !== "string" ||
+        !/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(head))
+        throw new Error("invalid-red-green-input: head must be a full commit ID");
+    return head;
+}
+function redGreenSettings() {
+    try {
+        const value = JSON.parse(process.env["CLOVING_RED_GREEN"] ?? "null");
+        const settings = configuration({ version: 1, checks: { redGreen: value } }, "project").checks?.redGreen;
+        if (settings === undefined)
+            throw new Error("missing settings");
+        return {
+            settings,
+            assertion: new RegExp(settings.assertionPattern ?? "ERR_ASSERTION"),
+            skip: new RegExp(settings.skipPattern ?? "# SKIP\\b"),
+        };
+    }
+    catch (error) {
+        throw new Error("invalid-CLOVING_RED_GREEN: " +
+            (error instanceof Error ? error.message : String(error)), { cause: error });
+    }
+}
+const controller = new AbortController();
+const interrupt = () => {
+    controller.abort();
+};
+process.on("disconnect", interrupt);
+if (!process.connected)
+    interrupt();
+process.on("SIGTERM", interrupt);
+process.on("SIGINT", interrupt);
+try {
+    await redGreenCommand(controller.signal);
+}
+catch (error) {
+    process.stderr.write((error instanceof Error ? error.message : String(error)) + "\n");
+    process.exitCode = 1;
+}
+finally {
+    process.off("disconnect", interrupt);
+    if (process.connected)
+        process.disconnect?.();
+    process.off("SIGTERM", interrupt);
+    process.off("SIGINT", interrupt);
+}

package/dist/tools/red-green-process.d.ts

@@ -0,0 +1,10 @@
+export interface RunResult {
+    readonly status: number | null;
+    readonly output: string;
+    readonly prepareFailed?: boolean;
+}
+export declare function redGreenProcess(argumentsList: readonly string[], options: {
+    readonly directory: string;
+    readonly signal: AbortSignal;
+    readonly milliseconds: number;
+}): Promise<RunResult>;

package/dist/tools/red-green-process.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { addAbortListener } from "node:events";
+function stop(child) {
+    if (child.pid === undefined)
+        return;
+    try {
+        process.kill(-child.pid, "SIGKILL");
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") !== "ESRCH")
+            child.kill("SIGKILL");
+    }
+}
+export async function redGreenProcess(argumentsList, options) {
+    options.signal.throwIfAborted();
+    const child = spawn(argumentsList[0] ?? "", argumentsList.slice(1), {
+        cwd: options.directory,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true,
+        env: { ...process.env, NODE_TEST_CONTEXT: undefined },
+    });
+    let output = "";
+    let stopped = false;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        output += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+        output += chunk;
+    });
+    child.once("error", (error) => {
+        output += error.message;
+    });
+    const closed = new Promise((resolve) => {
+        child.once("close", (status) => {
+            resolve({ status: stopped ? null : status, output });
+        });
+    });
+    const terminate = () => {
+        stopped = true;
+        stop(child);
+        child.stdout.destroy();
+        child.stderr.destroy();
+    };
+    const listener = addAbortListener(options.signal, terminate);
+    const timeout = setTimeout(() => {
+        output += "\nred-green command timed out\n";
+        terminate();
+    }, options.milliseconds);
+    try {
+        return await closed;
+    }
+    finally {
+        clearTimeout(timeout);
+        listener[Symbol.dispose]();
+        stop(child);
+    }
+}

package/dist/tools/self-host-processes.d.ts

@@ -1,4 +1,5 @@
 export interface HostProcesses {
+    readonly environment?: Readonly<NodeJS.ProcessEnv>;
     readonly project: string;
     readonly product: string;
     readonly runtime: string;
@@ -7,5 +8,6 @@ export interface HostProcesses {
     readonly watchPort: string;
     readonly phoneRelay: string;
     readonly updateMilliseconds: number | undefined;
+    readonly stopMilliseconds?: number;
 }
 export declare function hostedPrograms(settings: HostProcesses): Promise<number>;

package/dist/tools/self-host-processes.js

@@ -18,13 +18,26 @@ function launched(argumentsList, settings) {
             settle(status ?? 1);
         });
     });
-    return { child, ended };
+    return { name: settings.name, child, ended };
 }
-async function stopped(programs) {
+async function stopped(programs, milliseconds) {
     for (const program of programs)
-        if (!program.child.killed)
+        if (!program.child.killed &&
+            program.child.exitCode === null &&
+            program.child.signalCode === null)
             program.child.kill("SIGTERM");
-    await Promise.all(programs.map((program) => program.ended));
+    await Promise.all(programs.map(async (program) => {
+        const timer = setTimeout(() => {
+            if (program.child.kill("SIGKILL"))
+                process.stderr.write(`Cloving stopped the ${program.name} child with SIGKILL after ${String(milliseconds / 1000)} s\n`);
+        }, milliseconds);
+        try {
+            await program.ended;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }));
 }
 function updatingGit(settings, stopping) {
     const git = promisify(execFile);
@@ -97,9 +110,10 @@ function productChild(settings, argumentsList) {
         join(settings.product, `src/${program}${extname(import.meta.filename)}`),
         ...rest,
     ], {
+        name: program === "cli" ? "watch" : program,
         directory: settings.product,
         environment: {
-            ...process.env,
+            ...(settings.environment ?? process.env),
             CLOVING_RUNTIME_DIR: settings.runtime,
             CLOVING_WATCH_REPOSITORY: settings.repository,
         },
@@ -107,8 +121,9 @@ function productChild(settings, argumentsList) {
 }
 function hostedChildren(settings) {
     const daemon = launched([join(settings.project, "start.mjs")], {
+        name: "daemon",
         directory: settings.project,
-        environment: process.env,
+        environment: settings.environment ?? process.env,
     });
     const watch = settings.watchPort === "off"
         ? []
@@ -127,15 +142,19 @@ export async function hostedPrograms(settings) {
     const { daemon, programs } = hostedChildren(settings);
     const stopping = new AbortController();
     let updating = false;
-    const interrupt = () => {
+    let shutdown;
+    const stop = () => (shutdown ??= stopped(programs, settings.stopMilliseconds ?? 60000));
+    const signal = (signal) => {
         stopping.abort();
         for (const program of programs)
-            program.child.kill("SIGINT");
+            program.child.kill(signal);
+        shutdown = stop();
+    };
+    const interrupt = () => {
+        signal("SIGINT");
     };
     const terminate = () => {
-        stopping.abort();
-        for (const program of programs)
-            program.child.kill("SIGTERM");
+        signal("SIGTERM");
     };
     process.on("SIGINT", interrupt);
     process.on("SIGTERM", terminate);
@@ -143,7 +162,7 @@ export async function hostedPrograms(settings) {
         stopping: stopping.signal,
         stop: async () => {
             updating = true;
-            await stopped(programs);
+            await stop();
         },
     });
     try {
@@ -159,7 +178,7 @@ export async function hostedPrograms(settings) {
     }
     finally {
         stopping.abort();
-        await stopped(programs);
+        await stop();
         await polling;
         process.off("SIGINT", interrupt);
         process.off("SIGTERM", terminate);

package/dist/tools/self-host-project.js

@@ -1,13 +1,12 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { copyFile, mkdir, readFile, rm, symlink, writeFile, } from "node:fs/promises";
+import { mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { findPackageJSON } from "node:module";
-import { basename, dirname, extname, join, resolve } from "node:path";
+import { dirname, extname, join, resolve } from "node:path";
 import packageMetadata from "#package" with { type: "json" };
 import { record } from "../src/protocol.js";
 import { isWorkflowDeclaration, } from "../src/workflow-declaration.js";
-import { bundledWorkflowIds, } from "../src/workflow-discovery.js";
-import { workflowDeclarations, workflowFiles, workflowManifests, } from "./self-host-workflows.js";
+import { workflowManifests } from "./self-host-workflows.js";
 import { loadWorkflowFolders, } from "./workflow-folders.js";
 import { isWorkflowManifest } from "./workflow-manifest.js";
 import { retainWorkflowBundle } from "./workflow-bundles.js";
@@ -17,9 +16,6 @@ async function initializeProject(settings) {
     await rm(project, { recursive: true, force: true });
     await mkdir(join(project, "workflows"), { recursive: true, mode: 0o700 });
     await writeFile(join(project, "package.json"), '{"name":"cloving-self-host","private":true,"type":"module"}');
-    const files = await workflowFiles(join(product, "workflows"));
-    for (const file of files)
-        await copyWorkflow(settings, file);
     const modules = join(project, "node_modules");
     await mkdir(join(modules, "cloving"), { recursive: true });
     const dependencies = new Map(Object.keys(packageMetadata.dependencies).map((name) => [name, join(product, "package.json")]));
@@ -46,7 +42,6 @@ async function initializeProject(settings) {
             `./src/${subpath.slice("./workflows/".length) || "workflows"}${extname(import.meta.filename)}`,
         ])),
     }));
-    return files;
 }
 async function compile(settings) {
     const { product, project } = settings;
@@ -70,23 +65,6 @@ async function compile(settings) {
         throw new Error("The compiled workflow manifest is invalid.");
     return compiled;
 }
-function reservations(input) {
-    const { files, manifests, declarations } = input;
-    return [
-        ...files.map((file) => ({
-            baseName: basename(file, extname(file)),
-        })),
-        ...Object.entries(manifests).map(([functionName, manifest]) => ({
-            baseName: manifest.name,
-            workflowId: manifest.workflowId,
-            functionName,
-        })),
-        ...[
-            ...Object.values(bundledWorkflowIds),
-            ...declarations.map((item) => item.workflowId),
-        ].map((workflowId) => ({ workflowId })),
-    ];
-}
 async function stageCandidates(project, candidates) {
     if (candidates.length === 0)
         return [];
@@ -135,37 +113,6 @@ function operatorDeclaration(staged, compiled) {
         functionName: workflow.workflowId.slice(workflow.workflowId.lastIndexOf("//") + 2),
     };
 }
-async function copyWorkflow(settings, file) {
-    const { product, project } = settings;
-    await copyFile(join(product, "workflows", file), join(project, "workflows", file));
-    const sidecar = `${basename(file, extname(file))}.declaration.json`;
-    const declaration = await readFile(join(product, "workflows", sidecar)).catch((error) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return undefined;
-        throw error;
-    });
-    if (declaration !== undefined)
-        await writeFile(join(project, "workflows", sidecar), declaration);
-}
-function bundledListings(input) {
-    const { product, files, manifests, declarations } = input;
-    const byFunction = new Map(declarations.map(({ functionName, ...declaration }) => [
-        functionName,
-        declaration,
-    ]));
-    return Object.entries(manifests).map(([functionName, manifest]) => {
-        const declaration = byFunction.get(functionName);
-        const file = files.find((file) => basename(file, extname(file)) === manifest.name);
-        return {
-            scope: "bundled",
-            workflowId: declaration?.workflowId ?? manifest.name,
-            file: join(product, "workflows", file ?? manifest.name),
-            admitted: true,
-            codes: [],
-            ...(declaration === undefined ? {} : { declaration }),
-        };
-    });
-}
 async function writeManifests(project, compiled) {
     const manifests = {};
     for (const [functionName, manifest] of Object.entries(compiled)) {
@@ -180,21 +127,13 @@ async function writeManifests(project, compiled) {
 }
 export async function preparedProject(settings) {
     const { product, project } = settings;
-    const files = await initializeProject(settings);
-    let compiled = await compile(settings);
-    const bundled = workflowManifests(compiled);
-    const declarations = await workflowDeclarations(join(project, "workflows"), bundled);
-    const folders = await loadWorkflowFolders({
-        ...settings,
-        bundled: reservations({ files, manifests: bundled, declarations }),
-    }, { packageRoot: await workflowPackageRoot(product) });
+    await initializeProject(settings);
+    const folders = await loadWorkflowFolders(settings, {
+        packageRoot: await workflowPackageRoot(product),
+    });
     const staged = await stageCandidates(project, folders.candidates);
-    if (staged.length > 0)
-        compiled = await compile(settings);
-    const combined = [
-        ...declarations,
-        ...staged.map((candidate) => operatorDeclaration({ ...candidate, project }, compiled)),
-    ];
+    const compiled = await compile(settings);
+    const combined = staged.map((candidate) => operatorDeclaration({ ...candidate, project }, compiled));
     const manifests = await writeManifests(project, workflowManifests(compiled, combined));
     await writeFile(join(project, "declarations.json"), JSON.stringify(combined));
     await writeFile(join(project, "dependencies.json"), await workflowBundleDependencies({
@@ -206,15 +145,11 @@ export async function preparedProject(settings) {
         repository: folders.repository,
         directory: join(dirname(project), "workflow-bundles"),
     });
-    const workflows = bundledListings({
-        product,
-        files,
-        manifests: bundled,
-        declarations,
-    });
-    workflows.push(...folders.workflows);
+    const modules = join(dirname(project), "workflow-bundles/node_modules");
+    await rm(modules, { force: true });
+    await symlink(join(project, "node_modules"), modules);
     return {
-        workflows,
+        workflows: folders.workflows,
         repository: folders.repository,
         bundleDigest,
         manifests,

package/dist/tools/self-host-runtime.js

@@ -45,7 +45,7 @@ export async function adoptRuntimeDirectory(input) {
 }
 async function belongsToRepository(directory, repository) {
     try {
-        const ids = (await readdir(directory)).filter((id) => id !== ".history");
+        const ids = (await readdir(directory)).filter((id) => id !== ".history" && id !== "node_modules");
         if (ids.length === 0)
             return false;
         for (const id of ids)