@llblab/pi-actors 0.44.0 → 0.45.1

package/dist/lib/recipes-references.js

@@ -5,15 +5,106 @@
  */
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, extname, resolve } from "node:path";
+import { basename, dirname, extname, isAbsolute, relative, resolve } from "node:path";
 import * as CommandTemplates from "./command-templates.js";
 import * as Paths from "./paths.js";
 import * as RecipeControl from "./recipe-control.js";
+import * as Schema from "./schema.js";
 const MAX_RECIPE_FILE_BYTES = 1024 * 1024;
 const MAX_RECIPE_IMPORT_DEPTH = 32;
+const RUNTIME_RECIPE_VALUE_NAMES = new Set(["recipe_dir", "skill_dir"]);
+const activeSkillRecipeRoots = new Map();
+export function setActiveSkillRecipeSources(skills) {
+    activeSkillRecipeRoots.clear();
+    for (const skill of skills) {
+        const name = skill.name.trim();
+        const skillDir = skill.baseDir
+            ? resolve(skill.baseDir)
+            : skill.filePath
+                ? dirname(resolve(skill.filePath))
+                : undefined;
+        if (!name || !skillDir)
+            continue;
+        const roots = activeSkillRecipeRoots.get(name) ?? new Set();
+        roots.add(resolve(skillDir, "recipes"));
+        activeSkillRecipeRoots.set(name, roots);
+    }
+}
+export function getActiveSkillRecipeNamespaces() {
+    return Object.fromEntries([...activeSkillRecipeRoots.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, roots]) => [name, [...roots].sort()]));
+}
+function qualifiedRecipeNameForFile(file) {
+    const path = resolve(file);
+    const stdRelation = relative(Paths.getPackagedRecipeRoot(), path);
+    if (stdRelation &&
+        !stdRelation.startsWith("..") &&
+        !isAbsolute(stdRelation)) {
+        return `std:${stdRelation.replace(/\.(?:json|md)$/u, "")}`;
+    }
+    for (const [skillName, roots] of activeSkillRecipeRoots) {
+        if (roots.size !== 1)
+            continue;
+        const root = [...roots][0];
+        const relation = relative(root, path);
+        if (relation && !relation.startsWith("..") && !isAbsolute(relation))
+            return `skill:${skillName}/${relation.replaceAll("\\", "/").replace(/\.(?:json|md)$/u, "")}`;
+    }
+    return undefined;
+}
+function qualifiedRecipeCandidates(value) {
+    if (value.startsWith("std:")) {
+        return recipeNameFiles(value.slice(4)).map((file) => resolve(Paths.getPackagedRecipeRoot(), file));
+    }
+    if (!value.startsWith("skill:"))
+        return undefined;
+    const qualified = value.slice(6);
+    const separator = qualified.indexOf("/");
+    if (separator <= 0 || separator === qualified.length - 1)
+        throw new Error(`Invalid Skill Recipe reference: ${value}`);
+    const skillName = qualified.slice(0, separator);
+    const recipeName = qualified.slice(separator + 1);
+    const roots = [...(activeSkillRecipeRoots.get(skillName) ?? [])];
+    if (roots.length === 0)
+        throw new Error(`Active Skill Recipe namespace not found: ${skillName}`);
+    if (roots.length > 1)
+        throw new Error(`Ambiguous active Skill Recipe namespace ${skillName}: ${roots.join(", ")}`);
+    const root = roots[0];
+    return recipeNameFiles(recipeName).map((file) => {
+        const candidate = resolve(root, file);
+        const relation = relative(root, candidate);
+        if (!relation || relation.startsWith("..") || isAbsolute(relation))
+            throw new Error(`Skill Recipe reference escapes its recipes root: ${value}`);
+        return candidate;
+    });
+}
 function hasWhitespace(value) {
     return /\s/.test(value);
 }
+function findOwningSkillDir(recipeFile) {
+    let current = dirname(recipeFile);
+    while (true) {
+        if (existsSync(resolve(current, "SKILL.md")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function assertRuntimeRecipeValuesNotDeclared(raw) {
+    const args = Array.isArray(raw.args)
+        ? Schema.getExplicitToolArgNames(raw.args.map(String))
+        : [];
+    for (const name of RUNTIME_RECIPE_VALUE_NAMES) {
+        if (args.includes(name) ||
+            (isRecord(raw.defaults) && Object.hasOwn(raw.defaults, name)) ||
+            (isRecord(raw.values) && Object.hasOwn(raw.values, name))) {
+            throw new Error(`Recipe runtime value is reserved: ${name}`);
+        }
+    }
+}
 export function resolveRecipePath(value, recipeRoot = Paths.getRecipeRoot()) {
     const trimmed = value.trim();
     const repoRoot = resolve(recipeRoot, "..");
@@ -42,6 +133,9 @@ function recipeNameFiles(value) {
     return [`${trimmed}.json`, `${trimmed}.md`];
 }
 function recipeCandidatePaths(value, currentRecipeRoot) {
+    const qualified = qualifiedRecipeCandidates(value.trim());
+    if (qualified)
+        return qualified;
     if (!isBareRecipeName(value))
         return [resolveRecipePath(value, currentRecipeRoot)];
     const roots = [
@@ -495,11 +589,46 @@ function mergeDefaults(...items) {
     const merged = Object.assign({}, ...items.filter(Boolean));
     return Object.keys(merged).length > 0 ? merged : undefined;
 }
+function assertRecipeDefaultsDeclared(args, defaults, label) {
+    const spec = Schema.parseToolArgDeclarationList(args ?? []);
+    if (spec.error)
+        throw new Error(spec.error);
+    if (spec.args.length === 0)
+        return;
+    const declared = new Set(spec.args);
+    for (const key of Object.keys(defaults ?? {})) {
+        if (!declared.has(key))
+            throw new Error(`Unknown ${label} argument: ${key}`);
+    }
+}
+function assertRecipeArgumentContract(config, label = "Recipe default") {
+    assertRecipeDefaultsDeclared(config.args, config.defaults, label);
+    const spec = Schema.parseToolArgDeclarationList(config.args ?? []);
+    if (spec.error)
+        throw new Error(spec.error);
+    Schema.assertCompatibleToolArgTypes(spec.argTypes, Schema.getTemplateArgTypes({ template: config.template }));
+    const staticValues = Object.fromEntries(Object.entries({ ...config.defaults, ...config.values }).filter(([, value]) => typeof value !== "string" || !/\{[^{}]+\}/.test(value)));
+    Schema.normalizeRuntimeValues(staticValues, spec.argTypes);
+}
+function resolveRecipeValueLayers(args, ...layers) {
+    const spec = Schema.parseToolArgDeclarationList(args ?? []);
+    if (spec.error)
+        throw new Error(spec.error);
+    const merged = mergeDefaults(spec.defaults, ...layers);
+    if (!merged)
+        return undefined;
+    const staticValues = Object.fromEntries(Object.entries(merged).filter(([, value]) => typeof value !== "string" || !/\{[^{}]+\}/.test(value)));
+    return {
+        ...merged,
+        ...Schema.normalizeRuntimeValues(staticValues, spec.argTypes),
+    };
+}
 function applyDefaultsToTemplate(template, defaults, overrides) {
     const cleanOverrides = { ...overrides };
     delete cleanOverrides.name;
     delete cleanOverrides.template;
     delete cleanOverrides.values;
+    delete cleanOverrides.defaults;
     if (typeof template === "object" && !Array.isArray(template)) {
         return {
             ...template,
@@ -537,7 +666,15 @@ function loadDelegatedRecipe(value, currentRecipeFile, stack, options) {
     return config;
 }
 function applyDelegatedRecipeToNode(delegated, overrides = {}) {
-    return applyDefaultsToTemplate(delegated.template, delegated.values, overrides);
+    const nodeDefaults = isRecord(overrides.defaults)
+        ? overrides.defaults
+        : undefined;
+    const nodeValues = isRecord(overrides.values) ? overrides.values : undefined;
+    const values = resolveRecipeValueLayers(delegated.args, delegated.defaults, delegated.values, nodeDefaults, nodeValues, {
+        ...(delegated.recipe_dir ? { recipe_dir: delegated.recipe_dir } : {}),
+        ...(delegated.skill_dir ? { skill_dir: delegated.skill_dir } : {}),
+    });
+    return applyDefaultsToTemplate(delegated.template, values, overrides);
 }
 function expandRecipeDelegations(value, currentRecipeFile, stack, options = {}) {
     if (typeof value === "string") {
@@ -593,7 +730,7 @@ function expandImportNodes(value, imports, options = {}) {
             ? record.defaults
             : undefined;
         const nodeValues = isRecord(record.values) ? record.values : undefined;
-        const defaults = mergeDefaults(imported.defaults, imported.values, nodeDefaults, nodeValues);
+        const defaults = resolveRecipeValueLayers(imported.config.args, imported.defaults, imported.values, nodeDefaults, nodeValues);
         const expanded = applyDefaultsToTemplate(imported.config.template, defaults, record);
         return options.includeActorRecipeContext
             ? withActorRecipeContext(expanded, {
@@ -631,6 +768,8 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
     if (!raw || !Object.hasOwn(raw, "template"))
         return undefined;
     RecipeControl.assertRecipeHasNoMailbox(raw);
+    assertRuntimeRecipeValuesNotDeclared(raw);
+    assertRecipeArgumentContract(raw);
     const imports = {};
     for (const [alias, binding] of Object.entries(getRecipeImports(raw))) {
         const importPath = resolveRecipeImportPath(getImportFrom(binding), dirname(path));
@@ -639,13 +778,18 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
             throw new Error(`Recipe import not found: ${alias}`);
         const bindingDefaults = typeof binding === "string" ? undefined : binding.defaults;
         const bindingValues = typeof binding === "string" ? undefined : binding.values;
+        assertRecipeDefaultsDeclared(config.args, bindingDefaults, `Recipe import ${alias} default`);
         imports[alias] = {
             alias,
             file: importPath,
             name: config.name ?? alias,
             config,
             defaults: { ...(config.defaults ?? {}), ...(bindingDefaults ?? {}) },
-            values: { ...(bindingValues ?? {}) },
+            values: {
+                ...(bindingValues ?? {}),
+                ...(config.recipe_dir ? { recipe_dir: config.recipe_dir } : {}),
+                ...(config.skill_dir ? { skill_dir: config.skill_dir } : {}),
+            },
         };
     }
     const substituted = substituteImportRefs(raw, imports);
@@ -661,6 +805,17 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
             : {})
         : expandRecipeDelegations(expandedImportsTemplate, path, stack, options);
     const recipeName = getRecipeIdFromPath(path);
+    const recipeDir = dirname(path);
+    const skillDir = findOwningSkillDir(path);
+    if (!skillDir &&
+        JSON.stringify({
+            artifacts: substituted.artifacts,
+            defaults: substituted.defaults,
+            template: substituted.template,
+            values: substituted.values,
+        }).includes("{skill_dir}")) {
+        throw new Error(`Recipe uses {skill_dir} outside an owning Skill directory: ${path}`);
+    }
     const templateWithContext = options.includeActorRecipeContext
         ? withActorRecipeContext(expandedTemplate, {
             file: path,
@@ -678,6 +833,8 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
         : delegated?.control);
     return {
         name: recipeName,
+        recipe_dir: recipeDir,
+        ...(skillDir ? { skill_dir: skillDir } : {}),
         ...(typeof substituted.description === "string" &&
             substituted.description.trim()
             ? { description: substituted.description.trim() }
@@ -765,7 +922,11 @@ export function readResolvedRecipeConfig(file, stack = [], options = {}) {
         ...(typeof substituted.repeat === "number"
             ? { repeat: substituted.repeat }
             : {}),
-        ...(isRecord(substituted.values) ? { values: substituted.values } : {}),
+        values: {
+            ...(isRecord(substituted.values) ? substituted.values : {}),
+            recipe_dir: recipeDir,
+            ...(skillDir ? { skill_dir: skillDir } : {}),
+        },
         ...(isRecord(substituted.usage) ? { usage: substituted.usage } : {}),
     };
 }
@@ -780,12 +941,14 @@ function collectRecipeContextRecords(file, stack, importPath, alias) {
     const raw = readRawRecipeConfig(path);
     if (!raw || !Object.hasOwn(raw, "template"))
         return [];
+    const qualifiedName = qualifiedRecipeNameForFile(path);
     const record = {
         ...(alias ? { alias } : {}),
         depth: stack.length,
         file: path,
         import_path: importPath,
         name: getRecipeIdFromPath(path),
+        ...(qualifiedName ? { qualified_name: qualifiedName } : {}),
         recipe: raw,
         role: stack.length === 0 ? "entry" : "import",
     };

package/dist/lib/schema.d.ts

@@ -44,14 +44,17 @@ export declare function objectSchema(properties: Record<string, JsonSchema>, req
 export declare function looseObjectSchema(description: string): JsonSchema;
 export declare function parseToolArgToken(value: string): ParsedToolArgToken;
 export declare function parseToolArgDeclarations(value: string): ToolArgSpec;
+export declare function parseToolArgDeclarationList(value: unknown[]): ToolArgSpec;
 export declare function normalizeStoredToolArgDeclarations(argsValue: unknown, defaultsValue: unknown): ToolArgSpec & {
     changed: boolean;
     provided: boolean;
 };
 export declare function formatToolArgs(args: string[]): string;
 export declare function getTemplatePlaceholderNames(config: CommandTemplates.CommandTemplateConfig): string[];
+export declare function assertCompatibleToolArgTypes(...sources: Array<Record<string, ToolArgType> | undefined>): void;
 export declare function getTemplateArgTypes(config: CommandTemplates.CommandTemplateConfig): Record<string, ToolArgType>;
 export declare function getExplicitToolArgNames(args: string[] | undefined): string[];
+export declare function getExplicitToolArgDefaults(args: string[] | string | undefined): Record<string, string>;
 export declare function getToolArgNames(config: CommandTemplates.CommandTemplateConfig): string[];
 export declare function getRequiredToolArgNames(config: CommandTemplates.CommandTemplateConfig): Set<string>;
 export declare function normalizeRuntimeValues(values: Record<string, unknown>, argTypes: Record<string, ToolArgType> | undefined): Record<string, unknown>;

package/dist/lib/schema.js

@@ -147,7 +147,10 @@ function isValidDefault(type, value) {
     }
 }
 export function parseToolArgDeclarations(value) {
-    const source = splitArgDeclarations(value);
+    return parseToolArgDeclarationList(splitArgDeclarations(value));
+}
+export function parseToolArgDeclarationList(value) {
+    const source = value.map(String);
     const seen = new Set();
     const duplicates = new Set();
     const args = [];
@@ -272,6 +275,8 @@ function collectCommandTemplateConfigDeclarations(config, declarations) {
         collectTemplatePlaceholderDeclarations(config, declarations);
         return;
     }
+    if (!config || typeof config !== "object")
+        return;
     if (Array.isArray(config)) {
         for (const step of config)
             collectCommandTemplateConfigDeclarations(step, declarations);
@@ -296,9 +301,30 @@ function getTemplatePlaceholderDeclarations(config) {
 export function getTemplatePlaceholderNames(config) {
     return mergeUnique(getTemplatePlaceholderDeclarations(config).map((item) => item.arg));
 }
+function toolArgTypesEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function assertCompatibleToolArgTypes(...sources) {
+    const seen = {};
+    for (const source of sources) {
+        for (const [name, type] of Object.entries(source ?? {})) {
+            const previous = seen[name];
+            if (previous && !toolArgTypesEqual(previous, type)) {
+                throw new Error(`Conflicting argument type for ${name}: ${canonicalArgDeclaration(name, previous)} vs ${canonicalArgDeclaration(name, type)}`);
+            }
+            seen[name] = type;
+        }
+    }
+}
 export function getTemplateArgTypes(config) {
     const argTypes = {};
     for (const declaration of getTemplatePlaceholderDeclarations(config)) {
+        const previous = argTypes[declaration.arg];
+        if (previous &&
+            declaration.type.kind !== "string" &&
+            !toolArgTypesEqual(previous, declaration.type)) {
+            throw new Error(`Conflicting argument type for ${declaration.arg}: ${canonicalArgDeclaration(declaration.arg, previous)} vs ${declaration.declaration}`);
+        }
         if (declaration.type.kind !== "string")
             argTypes[declaration.arg] = declaration.type;
     }
@@ -307,6 +333,13 @@ export function getTemplateArgTypes(config) {
 export function getExplicitToolArgNames(args) {
     return mergeUnique((args ?? []).map((item) => parseToolArgToken(String(item)).arg));
 }
+export function getExplicitToolArgDefaults(args) {
+    const declarations = typeof args === "string" ? splitArgDeclarations(args) : (args ?? []);
+    return Object.fromEntries(declarations
+        .map((item) => parseToolArgToken(String(item)))
+        .filter((item) => item.defaultValue !== undefined)
+        .map((item) => [item.arg, item.defaultValue]));
+}
 export function getToolArgNames(config) {
     const normalizedConfig = CommandTemplates.normalizeCommandTemplateConfig(config);
     const declaredArgs = Array.isArray(normalizedConfig.args)

package/dist/lib/tools-inspect.js

@@ -12,6 +12,7 @@ import * as Limits from "./limits.js";
 import { computeRunControlCapacity } from "./run-evidence-policy.js";
 import * as Paths from "./paths.js";
 import * as RecipesDiscovery from "./recipes-discovery.js";
+import * as RecipesReferences from "./recipes-references.js";
 import * as ReviewDiagnostics from "./review-diagnostics.js";
 import * as RunsControls from "./runs-controls.js";
 import * as RunControlDelivery from "./runs-control-delivery.js";
@@ -172,8 +173,17 @@ function inspectRecipes(view, deps) {
         { root: recipeRoot, defaultTool: true, mutableUsage: true },
         { root: deps.packagedRecipeRoot ?? Paths.getPackagedRecipeRoot() },
     ]);
+    const skillRecipeNamespaces = RecipesReferences.getActiveSkillRecipeNamespaces();
     const summary = {
         ...RecipesDiscovery.summarizeDiscovery(discovered),
+        skill_recipe_namespaces: skillRecipeNamespaces,
+        skill_recipe_namespace_diagnostics: Object.entries(skillRecipeNamespaces)
+            .filter(([, roots]) => roots.length > 1)
+            .map(([name, roots]) => ({
+            name,
+            roots,
+            error: `Ambiguous active Skill Recipe namespace ${name}`,
+        })),
         drafts: RecipesDiscovery.listDraftRecipes(join(recipeRoot, "drafts")),
     };
     return {

package/dist/lib/tools-local.js

@@ -45,11 +45,16 @@ function shouldAddRuntimeToolUsageHint(error) {
 }
 function formatRuntimeToolUsageHint(cfg, required, includeRunId) {
     const optional = cfg.args.filter((arg) => !required.includes(arg));
+    const exampleDefaults = {
+        ...Schema.getExplicitToolArgDefaults(cfg.recipe?.args),
+        ...cfg.defaults,
+        ...(cfg.recipe?.values ?? {}),
+    };
     const example = {};
     for (const arg of required)
-        example[arg] = sampleValueForArg(arg, cfg.argTypes?.[arg], cfg.defaults);
+        example[arg] = sampleValueForArg(arg, cfg.argTypes?.[arg], exampleDefaults);
     for (const arg of optional)
-        example[arg] = sampleValueForArg(arg, cfg.argTypes?.[arg], cfg.defaults);
+        example[arg] = sampleValueForArg(arg, cfg.argTypes?.[arg], exampleDefaults);
     if (includeRunId)
         example.run_id = `${cfg.name}-1`;
     const lines = [
@@ -62,6 +67,21 @@ function formatRuntimeToolUsageHint(cfg, required, includeRunId) {
         lines.push(`Optional: ${[...optional, ...(includeRunId ? ["run_id"] : [])].join(", ")}`);
     return lines.join("\n");
 }
+function resolveRecipeToolValues(cfg, callerValues, ctx) {
+    const recipeRuntimeValues = {
+        ...(cfg.recipe?.recipe_dir
+            ? { recipe_dir: cfg.recipe.recipe_dir }
+            : {}),
+        ...(cfg.recipe?.skill_dir ? { skill_dir: cfg.recipe.skill_dir } : {}),
+    };
+    return Schema.normalizeRuntimeValues(ModelContext.withCurrentModelValues({
+        ...Schema.getExplicitToolArgDefaults(cfg.recipe?.args),
+        ...cfg.defaults,
+        ...(cfg.recipe?.values ?? {}),
+        ...callerValues,
+        ...recipeRuntimeValues,
+    }, ctx), cfg.argTypes);
+}
 function formatRuntimeToolArgumentError(cfg, error, required, includeRunId) {
     const message = error instanceof Error ? error.message : String(error);
     if (!shouldAddRuntimeToolUsageHint(error))
@@ -87,8 +107,10 @@ export function createRuntimeToolDefinition(cfg, exec) {
             defaults: cfg.defaults,
             template: requiredTemplate,
         };
+    const recipeInlineDefaults = Schema.getExplicitToolArgDefaults(cfg.recipe?.args);
     const requiredArgs = isRecipe && cfg.storedArgs !== undefined
-        ? new Set(cfg.args.filter((arg) => !Object.hasOwn(cfg.defaults, arg)))
+        ? new Set(cfg.args.filter((arg) => !Object.hasOwn(cfg.defaults, arg) &&
+            !Object.hasOwn(recipeInlineDefaults, arg)))
         : RecipesReferences.isRecipeReference(cfg.template) && !recipeTemplate
             ? new Set(cfg.args.filter((arg) => !Object.hasOwn(cfg.defaults, arg)))
             : Schema.getRequiredToolArgNames(requiredTemplateConfig);
@@ -137,7 +159,7 @@ export function createRuntimeToolDefinition(cfg, exec) {
                         run_id: runId,
                         tool: cfg.name,
                         policy_values: ModelContext.withCurrentModelValues({ ...(cfg.recipe?.values ?? {}), ...values }, ctx),
-                        values: Schema.normalizeRuntimeValues(ModelContext.withCurrentModelValues({ ...(cfg.recipe?.values ?? {}), ...cfg.defaults, ...values }, ctx), cfg.argTypes),
+                        values: resolveRecipeToolValues(cfg, values, ctx),
                     }, ctx.cwd);
                     return {
                         content: [
@@ -150,12 +172,7 @@ export function createRuntimeToolDefinition(cfg, exec) {
                     };
                 }
                 if (isRecipe && recipeTemplate) {
-                    const paramsWithDefaults = ModelContext.withCurrentModelValues({
-                        ...(cfg.recipe?.values ?? {}),
-                        ...cfg.defaults,
-                        ...params,
-                    }, ctx);
-                    return await Execution.executeRegisteredTool({ ...cfg, template: recipeTemplate }, Schema.normalizeRuntimeValues(paramsWithDefaults, cfg.argTypes), exec, ctx.cwd, signal);
+                    return await Execution.executeRegisteredTool({ ...cfg, template: recipeTemplate }, resolveRecipeToolValues(cfg, params, ctx), exec, ctx.cwd, signal);
                 }
                 return await Execution.executeRegisteredTool(cfg, Schema.normalizeRuntimeValues(ModelContext.withCurrentModelValues(params, ctx), cfg.argTypes), exec, ctx.cwd, signal);
             }

package/dist/lib/tools-spawn.js

@@ -90,8 +90,8 @@ export function createSpawnToolDefinition() {
         parameters: Schema.objectSchema({
             artifacts: Schema.looseObjectSchema("Optional named artifact paths for the spawned Run."),
             as: Schema.stringSchema("Optional Run identity in exact run:<id> form."),
-            file: Schema.stringSchema("Optional template recipe JSON file. Bare names resolve under ~/.pi/agent/recipes."),
-            recipe: Schema.stringSchema("Alias for file; template recipe JSON file/name to spawn."),
+            file: Schema.stringSchema("Optional template Recipe reference. Supports paths, bare user/adjacent/std names, std:<name>, and skill:<skill>/<recipe>."),
+            recipe: Schema.stringSchema("Alias for file; qualified Skill/std or ordinary Recipe reference to spawn."),
             template: Schema.unionSchema([
                 Schema.stringSchema("Inline command template string"),
                 Schema.arraySchema("Inline command-template sequence or parallel tree"),

package/dist/scripts/async-runner.mjs

@@ -74,7 +74,6 @@ function summarizeCommandDetail(commandDetail) {
 
 export async function runAsyncRunner(stateDir = process.argv[2]) {
   if (!stateDir) throw new Error("missing state dir");
-
   const runPath = join(stateDir, "run.json");
   const progressPath = join(stateDir, "progress.json");
   const resultPath = join(stateDir, "result.json");
@@ -83,11 +82,9 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
   const stderrPath = join(stateDir, "stderr.log");
   const executionPath = join(stateDir, "execution.json");
   const meta = JSON.parse(readFileSync(runPath, "utf8"));
-
   function event(kind, data = {}) {
     appendRunTraceEvent(stateDir, { kind, data });
   }
-
   function observation(kind, summary, data = {}, delivery = "log", level = "info") {
     appendRunTraceEvent(stateDir, {
       kind,
@@ -97,7 +94,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       ...(level === "error" ? { level: "error" } : {}),
     });
   }
-
   function progress(phase, extra = {}) {
     writeJsonAtomic(progressPath, {
       ...(meta.model_policy ? { model_policy: meta.model_policy } : {}),
@@ -106,7 +102,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       ...extra,
     });
   }
-
   let activeSubagents = 0;
   let completedSubagents = 0;
   let promptCounter = 0;
@@ -115,7 +110,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
   const evidenceRecords = [];
   const stageOccurrences = new Map();
   let reportEvidence;
-
   function writeExecutionManifest(status) {
     writeJsonAtomic(executionPath, {
       version: 1,
@@ -129,7 +123,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       updated_at: new Date().toISOString(),
     });
   }
-
   function commandSessionFiles(sessionDir) {
     if (!sessionDir) return [];
     try {
@@ -141,7 +134,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       return [];
     }
   }
-
   function commandEvidenceStartRecord({
     commandDetail,
     commandId,
@@ -181,7 +173,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
           : "not_required",
     };
   }
-
   function commandEvidenceRecord({
     captureDir,
     commandDetail,
@@ -273,7 +264,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
             : "rejected",
     };
   }
-
   function auditReviewReport(text) {
     const required = evidenceRecords
       .filter((record) =>
@@ -294,11 +284,9 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       complete_allowed: missing.length === 0,
     };
   }
-
   function getCommandDoneDelivery(result) {
     return result.code !== 0 || activeSubagents > 0 ? "followup" : "log";
   }
-
   function progressRunning() {
     progress("running", {
       activeSubagents,
@@ -306,14 +294,12 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       failures: subagentFailures,
     });
   }
-
   function promptFilePath() {
     promptCounter += 1;
     const dir = join(stateDir, "prompts");
     mkdirSync(dir, { recursive: true });
     return join(dir, `command-${String(promptCounter).padStart(3, "0")}.md`);
   }
-
   function readPromptText(promptFile) {
     if (!promptFile) return undefined;
     try {
@@ -322,7 +308,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
       return undefined;
     }
   }
-
   async function observedExec(command, args, options) {
     captureCounter += 1;
     const commandId = `command-${String(captureCounter).padStart(3, "0")}`;
@@ -485,7 +470,6 @@ export async function runAsyncRunner(stateDir = process.argv[2]) {
     progressRunning();
     return result;
   }
-
   try {
     event("run.runner.start", { pid: process.pid });
     progressRunning();

package/dist/scripts/executable-block-style.d.mts

@@ -0,0 +1 @@
+export function executableBlockBlankLines(source: string): number[];

package/dist/scripts/executable-block-style.mjs

@@ -0,0 +1,73 @@
+/** Detect blank lines inside executable JavaScript and TypeScript blocks. */
+
+export function executableBlockBlankLines(source) {
+  const lines = source.split(/\r?\n/u);
+  const blanks = [];
+  const stack = [];
+  let blockComment = false;
+  let currentExecutableDepth = 0;
+  let previousCode = "";
+  let quote;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (
+      /^\s*$/u.test(line) &&
+      currentExecutableDepth > 0 &&
+      quote !== "`"
+    )
+      blanks.push(lineIndex + 1);
+    let code = "";
+    let regularExpression = false;
+    for (let index = 0; index < line.length; index += 1) {
+      const char = line[index];
+      const next = line[index + 1];
+      if (blockComment) {
+        if (char === "*" && next === "/") {
+          blockComment = false;
+          index += 1;
+        }
+        continue;
+      }
+      if (quote) {
+        if (char === "\\") index += 1;
+        else if (char === quote) quote = undefined;
+        continue;
+      }
+      if (regularExpression) {
+        if (char === "\\") index += 1;
+        else if (char === "/") regularExpression = false;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        blockComment = true;
+        index += 1;
+        continue;
+      }
+      if (char === "/" && next === "/") break;
+      if (
+        char === "/" &&
+        /^(?:|.*(?:[=(,:;!&|?{}]|\b(?:return|case|throw)))\s*$/u.test(code)
+      ) {
+        regularExpression = true;
+        continue;
+      }
+      if (char === '"' || char === "'" || char === "`") {
+        quote = char;
+        continue;
+      }
+      if (char === "{") {
+        const prefix = code.trimEnd() || previousCode;
+        const executable =
+          /\)\s*$|=>\s*$|\b(?:else|try|finally|do)\s*$/u.test(prefix);
+        stack.push(executable);
+        if (executable) currentExecutableDepth += 1;
+      } else if (char === "}") {
+        if (stack.pop()) currentExecutableDepth -= 1;
+      }
+      code += char;
+    }
+    if (quote !== "`") quote = undefined;
+    if (code.trim()) previousCode = code.trim();
+  }
+  return blanks;
+}