@a5c-ai/genty-platform 5.1.1-staging.0007199a1cb2

package/dist/harness/internal/createRun/planProcess/validation.js

@@ -0,0 +1,289 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProcessExport = validateProcessExport;
+exports._setDiscoverExternalAgentsForValidationTesting = _setDiscoverExternalAgentsForValidationTesting;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const node_url_1 = require("node:url");
+// SDK-owned: task registry reset needed before re-importing process definitions
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const global_1 = require("../../../../orchestration/global");
+const utils_1 = require("../utils");
+const delegation_1 = require("./delegation");
+const validationText_1 = require("./validationText");
+const validationSource_1 = require("./validationSource");
+let processValidationImportNonce = 0;
+async function discoverExternalAgentsViaProvider(opts) {
+    try {
+        const agents = await (0, global_1.getGlobalRegistry)().getAgentDiscovery().discoverAgents(opts.cwd ?? process.cwd());
+        return { available: agents.length > 0 };
+    }
+    catch {
+        return { available: false };
+    }
+}
+let discoverExternalAgentsForValidation = discoverExternalAgentsViaProvider;
+const dynamicImportModule = (() => {
+    if (process.env.VITEST) {
+        return (specifier) => Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    return new Function("specifier", "return import(specifier);");
+})();
+async function ensureSdkResolvable(workspaceDir) {
+    // SDK-owned: resolve SDK package location to symlink into workspace for process validation
+    const sdkPkg = path.dirname(require.resolve("@a5c-ai/babysitter-sdk/package.json"));
+    const targetNodeModules = path.join(workspaceDir, "node_modules");
+    const targetSdkDir = path.join(targetNodeModules, "@a5c-ai", "babysitter-sdk");
+    try {
+        await node_fs_1.promises.access(targetSdkDir);
+        return;
+    }
+    catch {
+        // create below
+    }
+    try {
+        await node_fs_1.promises.mkdir(path.join(targetNodeModules, "@a5c-ai"), { recursive: true });
+        const linkType = process.platform === "win32" ? "junction" : "dir";
+        await node_fs_1.promises.symlink(sdkPkg, targetSdkDir, linkType);
+    }
+    catch {
+        // best effort
+    }
+}
+async function validateProcessExport(filePath) {
+    const source = await node_fs_1.promises.readFile(path.resolve(filePath), "utf8");
+    const shellPatterns = [
+        { pattern: /<<['"]?EOF/m, name: "heredoc (<<EOF)" },
+        { pattern: /^cat\s+>/m, name: "shell cat redirect" },
+        { pattern: /^\s*#!\s*\/bin\/(ba)?sh/m, name: "shell shebang" },
+    ];
+    for (const { pattern, name } of shellPatterns) {
+        if (pattern.test(source)) {
+            throw new utils_1.BabysitterRuntimeError("InvalidProcessSyntaxError", `Process file at ${filePath} contains shell syntax (${name}). The file must be valid ESM JavaScript, not a shell script.`, {
+                category: utils_1.ErrorCategory.Validation,
+                nextSteps: [
+                    "Rewrite shell commands as JavaScript — use fs.writeFileSync for file creation, child_process.execSync for commands",
+                    "Express file contents as JavaScript strings or arrays joined with '\\n'",
+                    "The .mjs file must pass node --check as valid ESM",
+                ],
+            });
+        }
+    }
+    const syntaxCheck = await (0, delegation_1.execShellEffect)(process.execPath, ["--check", path.resolve(filePath)]);
+    if (syntaxCheck.exitCode !== 0) {
+        const diagnostic = [syntaxCheck.stdout, syntaxCheck.stderr]
+            .map((value) => value.trim())
+            .filter(Boolean)
+            .join("\n");
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSyntaxError", diagnostic
+            ? `Process file at ${filePath} failed \`node --check\`.\n${diagnostic}`
+            : `Process file at ${filePath} failed \`node --check\`.`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Rewrite the file so it is syntactically valid ESM before runtime import",
+                "If the process writes HTML/CSS/JS assets, do not embed raw nested template literals inside outer template literals",
+                "Prefer String.raw, arrays joined with \"\\n\", or escaped inner backticks and \\${...} sequences when embedding source files",
+            ],
+        });
+    }
+    if ((0, validationText_1.hasNamedProcessGlobalReferenceConflict)(source)) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} references \`process.\` inside the named 'process' export, which shadows Node's global process object`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "If the process needs the workspace root, resolve it from the module location with import.meta.url",
+                "If you need Node's global process object, use globalThis.process or import it under another name such as nodeProcess",
+            ],
+        });
+    }
+    if ((0, validationText_1.assumesRuntimeWorkspacePathWithoutModuleFallback)(source)) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} assumes ctx.workspaceDir or ctx.cwd exists, but the runtime process context does not provide workspace paths`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "When the process needs the workspace root, derive it from the module location with import.meta.url",
+                "For a generated process in the workspace root, use path.dirname(fileURLToPath(import.meta.url)) or an equivalent import.meta.url-based approach",
+            ],
+        });
+    }
+    const unresolvedPlaceholders = (0, validationSource_1.getUnresolvedTemplatePlaceholders)(source);
+    if (unresolvedPlaceholders.length > 0) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} contains unresolved template placeholders: ${unresolvedPlaceholders.join(", ")}`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Do not leave {{workspaceDir}}, {{gameRequest}}, or similar template placeholders in task prompts, shell commands, or node args",
+                "Build concrete prompt text and shell commands from defineTask(args, taskCtx) inputs when returning each TaskDef",
+                "If a task needs workspaceDir or request text, interpolate the actual args value into the returned TaskDef before runtime",
+            ],
+        });
+    }
+    await ensureSdkResolvable(path.dirname(path.resolve(filePath)));
+    const resolvedPath = path.resolve(filePath);
+    const moduleUrl = `${(0, node_url_1.pathToFileURL)(resolvedPath).href}?t=${Date.now()}-${++processValidationImportNonce}`;
+    (0, babysitter_sdk_1.resetGlobalTaskRegistry)();
+    let mod;
+    try {
+        mod = await dynamicImportModule(moduleUrl);
+    }
+    catch {
+        // ESM import with cache-bust query string may fail on some Node configs
+        // (CJS fallback doesn't support file:// URLs with query strings).
+        // Retry with plain require() after clearing the module cache.
+        try {
+            delete require.cache[require.resolve(resolvedPath)];
+        }
+        catch { /* not cached */ }
+        try {
+            mod = await dynamicImportModule((0, node_url_1.pathToFileURL)(resolvedPath).href);
+        }
+        catch {
+            // Last resort: CJS require
+            mod = require(resolvedPath);
+        }
+    }
+    finally {
+        (0, babysitter_sdk_1.resetGlobalTaskRegistry)();
+    }
+    const fn = mod.process ?? (typeof mod.default === "function" ? mod.default : undefined);
+    if (typeof fn !== "function") {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessExportError", `Process file at ${filePath} does not export a function named 'process'. Available exports: ${Object.keys(mod).join(", ") || "(none)"}`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Ensure the file exports: export async function process(inputs, ctx) { ... }",
+                "A default export is also accepted: export default async function(inputs, ctx) { ... }",
+            ],
+        });
+    }
+    if (!(0, validationSource_1.hasDefineTaskBlocks)(source)) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} does not define any babysitter tasks via defineTask(...)`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Create at least one task with const taskName = defineTask(\"task-id\", (args, taskCtx) => ({ ... }))",
+                "Move the main implementation and verification work into those tasks instead of doing it directly in process(inputs, ctx)",
+                "Have process(inputs, ctx) orchestrate the work by awaiting ctx.task(taskName, args)",
+            ],
+        });
+    }
+    const taskIdsMissingKind = (0, validationSource_1.getDefineTaskIdsMissingKind)(source);
+    if (taskIdsMissingKind.length > 0) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} defines task(s) without a top-level kind: ${taskIdsMissingKind.join(", ")}`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Every TaskDef returned from defineTask(...) must include a top-level kind string",
+                "Use kind: \"agent\" with agent: { ... }, kind: \"shell\" with shell: { command: ... }, or another supported effect kind that the agent will execute and post manually",
+            ],
+        });
+    }
+    if (!(0, validationSource_1.hasCtxTaskInvocation)(source)) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} does not invoke any babysitter tasks through ctx.task(...)`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "After defining tasks with defineTask(...), run them from process(inputs, ctx) via await ctx.task(taskName, args)",
+                "Do not perform the main implementation directly in process(inputs, ctx)",
+            ],
+        });
+    }
+    const taskKindShapeMismatches = (0, validationSource_1.getDefineTaskKindShapeMismatches)(source);
+    if (taskKindShapeMismatches.length > 0) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} has task definition kind mismatches: ${taskKindShapeMismatches
+            .map((mismatch) => `${mismatch.id} should use kind "${mismatch.expectedKind}"`)
+            .join(", ")}`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Match each task's kind to its body shape",
+                "Agent tasks must use kind: \"agent\" and shell tasks must use kind: \"shell\". Do not generate node task definitions in authored processes",
+            ],
+        });
+    }
+    const agentResponderTasksMissingAdapter = (0, validationSource_1.getAgentResponderTasksMissingAdapter)(source);
+    if (agentResponderTasksMissingAdapter.length > 0) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} defines agent responder task(s) without a non-empty adapter: ${agentResponderTasksMissingAdapter.join(", ")}`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Agent responder tasks must use kind: \"agent\" with agent.responderType: \"agent\"",
+                "Set agent.adapter to a non-empty adapters adapter name such as \"codex\" or \"claude-code\"",
+                "If adapter routing is optional, set fallbackType: \"internal\" but keep adapter present for the preferred agent responder",
+            ],
+        });
+    }
+    if ((0, validationSource_1.hasAgentResponderTasks)(source)) {
+        try {
+            const externalAgents = await discoverExternalAgentsForValidation({
+                cwd: path.dirname(path.resolve(filePath)),
+                timeout: 1000,
+            });
+            if (!externalAgents.available) {
+                console.warn("[babysitter] process uses agent responder tasks but adapters is not detected; validation will continue");
+            }
+        }
+        catch {
+            console.warn("[babysitter] process uses agent responder tasks but adapters discovery failed; validation will continue");
+        }
+    }
+    const agentTaskIds = (0, validationSource_1.getDefineTaskIdsByKind)(source, "agent");
+    if (agentTaskIds.length === 0) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} does not define any agent tasks`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Define at least one agent task with kind: \"agent\" for the main planning, implementation, or refinement work",
+                "Use shell tasks only for concrete runnable commands such as tests, builds, package installs, or linters",
+            ],
+        });
+    }
+    const nodeTaskIds = (0, validationSource_1.getDefineTaskIdsByKind)(source, "node");
+    if (nodeTaskIds.length > 0) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} defines forbidden node tasks: ${nodeTaskIds.join(", ")}`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Replace each node task with an agent or skill task",
+                "If the work is a concrete existing CLI command, use a shell task and have the orchestrating agent execute it and post the result",
+            ],
+        });
+    }
+    const invalidCtxTaskTargets = (0, validationSource_1.getInvalidCtxTaskTargets)(source);
+    if (invalidCtxTaskTargets.length > 0) {
+        throw new utils_1.BabysitterRuntimeError("InvalidProcessSourceError", `Process file at ${filePath} calls ctx.task(...) with values that are not DefinedTask bindings created via defineTask(...): ${invalidCtxTaskTargets.join(", ")}`, {
+            category: utils_1.ErrorCategory.Validation,
+            nextSteps: [
+                "Define each task with const taskName = defineTask(\"task-id\", (args, taskCtx) => ({ ... }))",
+                "Pass only those DefinedTask bindings to await ctx.task(taskName, args)",
+                "Do not pass plain object task definitions, inline literals, or ad-hoc task objects to ctx.task(...)",
+            ],
+        });
+    }
+}
+function _setDiscoverExternalAgentsForValidationTesting(fn) {
+    discoverExternalAgentsForValidation = fn ?? discoverExternalAgentsViaProvider;
+}

package/dist/harness/internal/createRun/planProcess/validationSource.d.ts

@@ -0,0 +1,13 @@
+export declare function hasDefineTaskBlocks(source: string): boolean;
+export declare function getDefineTaskIdsMissingKind(source: string): string[];
+export declare function getDefineTaskKindShapeMismatches(source: string): Array<{
+    id: string;
+    expectedKind: string;
+}>;
+export declare function getAgentResponderTasksMissingAdapter(source: string): string[];
+export declare function hasAgentResponderTasks(source: string): boolean;
+export declare function getInvalidCtxTaskTargets(source: string): string[];
+export declare function hasCtxTaskInvocation(source: string): boolean;
+export declare function getUnresolvedTemplatePlaceholders(source: string): string[];
+export declare function getDefineTaskIdsByKind(source: string, kind: "agent" | "shell" | "node"): string[];
+//# sourceMappingURL=validationSource.d.ts.map

package/dist/harness/internal/createRun/planProcess/validationSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationSource.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/validationSource.ts"],"names":[],"mappings":"AAeA,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE3D;AAyQD,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAIpE;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAgB5G;AAWD,wBAAgB,oCAAoC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAI7E;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBjE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ1E;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,CAOjG"}

package/dist/harness/internal/createRun/planProcess/validationSource.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDefineTaskBlocks = hasDefineTaskBlocks;
+exports.getDefineTaskIdsMissingKind = getDefineTaskIdsMissingKind;
+exports.getDefineTaskKindShapeMismatches = getDefineTaskKindShapeMismatches;
+exports.getAgentResponderTasksMissingAdapter = getAgentResponderTasksMissingAdapter;
+exports.hasAgentResponderTasks = hasAgentResponderTasks;
+exports.getInvalidCtxTaskTargets = getInvalidCtxTaskTargets;
+exports.hasCtxTaskInvocation = hasCtxTaskInvocation;
+exports.getUnresolvedTemplatePlaceholders = getUnresolvedTemplatePlaceholders;
+exports.getDefineTaskIdsByKind = getDefineTaskIdsByKind;
+function getDefineTaskBlocks(source) {
+    const normalized = source.replace(/\r\n/g, "\n");
+    const pattern = /defineTask\(\s*(['"`])([^'"`]+)\1\s*,\s*(?:async\s*)?\([^)]*\)\s*=>\s*\(\{([\s\S]*?)\}\)\s*(?:,\s*\{[\s\S]*?\}\s*)?\)/g;
+    const blocks = [];
+    let match;
+    while ((match = pattern.exec(normalized)) !== null) {
+        blocks.push({
+            id: match[2],
+            body: match[3] ?? "",
+        });
+    }
+    return blocks;
+}
+function hasDefineTaskBlocks(source) {
+    return getDefineTaskBlocks(source).length > 0;
+}
+function getTopLevelTaskProperties(body) {
+    const normalized = body.replace(/\r\n/g, "\n");
+    const properties = new Map();
+    let index = 0;
+    while (index < normalized.length) {
+        index = skipWhitespaceAndComments(normalized, index);
+        if (index >= normalized.length) {
+            break;
+        }
+        if (normalized[index] === ",") {
+            index += 1;
+            continue;
+        }
+        if (normalized.startsWith("...", index)) {
+            index = scanTopLevelValueEnd(normalized, index + 3);
+            continue;
+        }
+        const key = readTopLevelPropertyKey(normalized, index);
+        if (!key) {
+            index = scanTopLevelValueEnd(normalized, index);
+            if (normalized[index] === ",") {
+                index += 1;
+            }
+            continue;
+        }
+        index = key.nextIndex;
+        index = skipWhitespaceAndComments(normalized, index);
+        if (normalized[index] !== ":") {
+            index = scanTopLevelValueEnd(normalized, index);
+            if (normalized[index] === ",") {
+                index += 1;
+            }
+            continue;
+        }
+        const valueStart = index + 1;
+        const valueEnd = scanTopLevelValueEnd(normalized, valueStart);
+        properties.set(key.name, normalized.slice(valueStart, valueEnd).trim());
+        index = valueEnd;
+        if (normalized[index] === ",") {
+            index += 1;
+        }
+    }
+    return properties;
+}
+function readTopLevelPropertyKey(source, index) {
+    const ch = source[index] ?? "";
+    if (/[A-Za-z_$]/.test(ch)) {
+        let nextIndex = index + 1;
+        while (/[\w$]/.test(source[nextIndex] ?? "")) {
+            nextIndex += 1;
+        }
+        return {
+            name: source.slice(index, nextIndex),
+            nextIndex,
+        };
+    }
+    if (ch === "\"" || ch === "'" || ch === "`") {
+        let nextIndex = index + 1;
+        let name = "";
+        while (nextIndex < source.length) {
+            const current = source[nextIndex] ?? "";
+            if (current === "\\") {
+                name += current;
+                nextIndex += 1;
+                if (nextIndex < source.length) {
+                    name += source[nextIndex] ?? "";
+                    nextIndex += 1;
+                }
+                continue;
+            }
+            if (current === ch) {
+                return { name, nextIndex: nextIndex + 1 };
+            }
+            name += current;
+            nextIndex += 1;
+        }
+    }
+    return null;
+}
+function skipWhitespaceAndComments(source, start) {
+    let index = start;
+    while (index < source.length) {
+        const ch = source[index] ?? "";
+        const next = source[index + 1] ?? "";
+        if (/\s/.test(ch)) {
+            index += 1;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            index += 2;
+            while (index < source.length && source[index] !== "\n") {
+                index += 1;
+            }
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            index += 2;
+            while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
+                index += 1;
+            }
+            index = Math.min(index + 2, source.length);
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function scanTopLevelValueEnd(source, start) {
+    let index = start;
+    let depthParen = 0;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let state = "normal";
+    const templateExpressionBraceStack = [];
+    while (index < source.length) {
+        const ch = source[index] ?? "";
+        const next = source[index + 1] ?? "";
+        if (state === "line-comment") {
+            if (ch === "\n") {
+                state = "normal";
+            }
+            index += 1;
+            continue;
+        }
+        if (state === "block-comment") {
+            if (ch === "*" && next === "/") {
+                index += 2;
+                state = "normal";
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (state === "single") {
+            if (ch === "\\") {
+                index += 2;
+                continue;
+            }
+            if (ch === "'") {
+                state = "normal";
+            }
+            index += 1;
+            continue;
+        }
+        if (state === "double") {
+            if (ch === "\\") {
+                index += 2;
+                continue;
+            }
+            if (ch === "\"") {
+                state = "normal";
+            }
+            index += 1;
+            continue;
+        }
+        if (state === "template") {
+            if (ch === "\\") {
+                index += 2;
+                continue;
+            }
+            if (ch === "$" && next === "{") {
+                templateExpressionBraceStack.push(0);
+                index += 2;
+                state = "normal";
+                continue;
+            }
+            if (ch === "`") {
+                state = "normal";
+            }
+            index += 1;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            index += 2;
+            state = "line-comment";
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            index += 2;
+            state = "block-comment";
+            continue;
+        }
+        if (ch === "'") {
+            index += 1;
+            state = "single";
+            continue;
+        }
+        if (ch === "\"") {
+            index += 1;
+            state = "double";
+            continue;
+        }
+        if (ch === "`") {
+            index += 1;
+            state = "template";
+            continue;
+        }
+        if (ch === "," && depthParen === 0 && depthBracket === 0 && depthBrace === 0 && templateExpressionBraceStack.length === 0) {
+            return index;
+        }
+        if (ch === "(") {
+            depthParen += 1;
+        }
+        else if (ch === ")") {
+            depthParen = Math.max(0, depthParen - 1);
+        }
+        else if (ch === "[") {
+            depthBracket += 1;
+        }
+        else if (ch === "]") {
+            depthBracket = Math.max(0, depthBracket - 1);
+        }
+        else if (ch === "{") {
+            depthBrace += 1;
+            if (templateExpressionBraceStack.length > 0) {
+                templateExpressionBraceStack[templateExpressionBraceStack.length - 1] += 1;
+            }
+        }
+        else if (ch === "}") {
+            if (templateExpressionBraceStack.length > 0) {
+                const templateDepthIndex = templateExpressionBraceStack.length - 1;
+                if (templateExpressionBraceStack[templateDepthIndex] === 0) {
+                    templateExpressionBraceStack.pop();
+                    state = "template";
+                    index += 1;
+                    continue;
+                }
+                templateExpressionBraceStack[templateDepthIndex] -= 1;
+                depthBrace = Math.max(0, depthBrace - 1);
+            }
+            else {
+                depthBrace = Math.max(0, depthBrace - 1);
+            }
+        }
+        index += 1;
+    }
+    return index;
+}
+function getDefineTaskIdsMissingKind(source) {
+    return getDefineTaskBlocks(source)
+        .filter((block) => !getTopLevelTaskProperties(block.body).has("kind"))
+        .map((block) => block.id);
+}
+function getDefineTaskKindShapeMismatches(source) {
+    const mismatches = [];
+    for (const block of getDefineTaskBlocks(source)) {
+        const properties = getTopLevelTaskProperties(block.body);
+        const kindValue = properties.get("kind")?.trim();
+        if (properties.has("agent") && kindValue !== "\"agent\"" && kindValue !== "'agent'" && kindValue !== "`agent`") {
+            mismatches.push({ id: block.id, expectedKind: "agent" });
+        }
+        if (properties.has("shell") && kindValue !== "\"shell\"" && kindValue !== "'shell'" && kindValue !== "`shell`") {
+            mismatches.push({ id: block.id, expectedKind: "shell" });
+        }
+        if (properties.has("node") && kindValue !== "\"node\"" && kindValue !== "'node'" && kindValue !== "`node`") {
+            mismatches.push({ id: block.id, expectedKind: "node" });
+        }
+    }
+    return mismatches;
+}
+function isAgentResponderTaskBody(body) {
+    return /\bresponderType\s*:\s*["'`]agent["'`]/.test(body)
+        || /\bexternal\s*:\s*true\b/.test(body);
+}
+function hasNonEmptyAdapterLiteral(body) {
+    return /\badapter\s*:\s*["'`][^"'`\s][^"'`]*["'`]/.test(body);
+}
+function getAgentResponderTasksMissingAdapter(source) {
+    return getDefineTaskBlocks(source)
+        .filter((block) => isAgentResponderTaskBody(block.body) && !hasNonEmptyAdapterLiteral(block.body))
+        .map((block) => block.id);
+}
+function hasAgentResponderTasks(source) {
+    return getDefineTaskBlocks(source).some((block) => isAgentResponderTaskBody(block.body));
+}
+function getInvalidCtxTaskTargets(source) {
+    const normalized = source.replace(/\r\n/g, "\n");
+    const definedTaskBindings = new Set();
+    const defineTaskBindingPattern = /\b(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*defineTask\s*\(/g;
+    let defineTaskBindingMatch;
+    while ((defineTaskBindingMatch = defineTaskBindingPattern.exec(normalized)) !== null) {
+        definedTaskBindings.add(defineTaskBindingMatch[1]);
+    }
+    const invalidTargets = new Set();
+    const ctxTaskPattern = /\bctx\.task\s*\(\s*([^,\n]+?)\s*,/g;
+    let ctxTaskMatch;
+    while ((ctxTaskMatch = ctxTaskPattern.exec(normalized)) !== null) {
+        const target = (ctxTaskMatch[1] ?? "").trim();
+        if (!target) {
+            continue;
+        }
+        if (/^[A-Za-z_$][\w$]*$/.test(target) && definedTaskBindings.has(target)) {
+            continue;
+        }
+        invalidTargets.add(target.replace(/\s+/g, " ").slice(0, 80));
+    }
+    return Array.from(invalidTargets);
+}
+function hasCtxTaskInvocation(source) {
+    return /\bctx\.task\s*\(/.test(source.replace(/\r\n/g, "\n"));
+}
+function getUnresolvedTemplatePlaceholders(source) {
+    const normalized = source.replace(/\r\n/g, "\n");
+    const matches = normalized.match(/\{\{\s*[A-Za-z_$][\w$.]*\s*\}\}/g) ?? [];
+    const unique = new Set();
+    for (const match of matches) {
+        unique.add(match.replace(/\s+/g, ""));
+    }
+    return Array.from(unique).slice(0, 8);
+}
+function getDefineTaskIdsByKind(source, kind) {
+    return getDefineTaskBlocks(source)
+        .filter((block) => {
+        const kindValue = getTopLevelTaskProperties(block.body).get("kind")?.trim();
+        return kindValue === `"${kind}"` || kindValue === `'${kind}'` || kindValue === `\`${kind}\``;
+    })
+        .map((block) => block.id);
+}

package/dist/harness/internal/createRun/planProcess/validationText.d.ts

@@ -0,0 +1,3 @@
+export declare function hasNamedProcessGlobalReferenceConflict(source: string): boolean;
+export declare function assumesRuntimeWorkspacePathWithoutModuleFallback(source: string): boolean;
+//# sourceMappingURL=validationText.d.ts.map

package/dist/harness/internal/createRun/planProcess/validationText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationText.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/validationText.ts"],"names":[],"mappings":"AAkJA,wBAAgB,sCAAsC,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAM9E;AAED,wBAAgB,gDAAgD,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CASxF"}