agency-lang 0.10.0 → 0.11.0

package/dist/lib/agentTarget.d.ts

@@ -0,0 +1,52 @@
+/**
+ * How an agent target string is parsed and resolved. A target names an agent
+ * entry point: `path`, `path:node`, or a directory (meaning its main.agency).
+ * Consumed by the eval commands, the optimizer, and `agency test`.
+ */
+export declare function parseTarget(target: string): {
+    filename: string;
+    nodeName: string;
+};
+/** Resolve a target into the agent file, node (default "main"), and the
+ *  display label run results carry. */
+export declare function resolveEvalRunTarget(target: string): {
+    agentFile: string;
+    node: string;
+    label: string;
+};
+/** What runs as the agent, and what evidence it produces. `file` is the
+ *  classic seeded-and-compiled .agency target; `command` is a CLI run in the
+ *  workdir (Agency CLIs only — the statelog is the evidence contract). A
+ *  future non-Agency variant would be a third kind with a weaker record. */
+export type EvalTarget = {
+    kind: "file";
+    agentFile: string;
+    node: string;
+    label: string;
+} | {
+    kind: "command";
+    tokens: string[];
+    label: string;
+};
+/** Resolve the runner-side agent choice. Exactly one of --agent /
+ *  --agent-cmd; the command's {task} placeholder is validated here, before
+ *  any run. Commands come ONLY from these flags, never from suite content —
+ *  suites can be remote git sources, and a suite that named its own command
+ *  would be remote code execution. */
+export declare function resolveEvalTarget(opts: {
+    agent?: string;
+    agentCmd?: string;
+}): EvalTarget;
+/**
+ * Fail fast when the entry node cannot receive a task: eval delivers the
+ * input's task as the node's single positional parameter, so the node must
+ * take exactly one. The subprocess bootstrap enforces the same rule at run
+ * time (resolveNodeCallArgs), but by then a workdir has been seeded and the
+ * agent compiled — and the optimizer would pay that once per candidate.
+ * A misconfigured agent should cost one error, not a suite of run failures.
+ *
+ * Best-effort: an unreadable or unparseable file, or a node defined
+ * elsewhere than the entry file, is left for compile/run to report with
+ * better errors than a pre-parse could.
+ */
+export declare function assertEvalEntryNodeTakesOneParameter(agentFile: string, node: string): void;

package/dist/lib/agentTarget.js

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import * as path from "path";
+import { MISSING_TASK_PLACEHOLDER_ERROR, TASK_PLACEHOLDER, tokenizeCommand } from "./eval/run/commandLine.js";
+import { parseAgency } from "./parser.js";
+/**
+ * How an agent target string is parsed and resolved. A target names an agent
+ * entry point: `path`, `path:node`, or a directory (meaning its main.agency).
+ * Consumed by the eval commands, the optimizer, and `agency test`.
+ */
+export function parseTarget(target) {
+    const colonIndex = target.lastIndexOf(":");
+    if (colonIndex === -1) {
+        return { filename: target, nodeName: "" };
+    }
+    const filename = target.slice(0, colonIndex);
+    const nodeName = target.slice(colonIndex + 1);
+    return { filename, nodeName };
+}
+/** Resolve a target into the agent file, node (default "main"), and the
+ *  display label run results carry. */
+export function resolveEvalRunTarget(target) {
+    const parsed = parseTarget(target);
+    const resolved = path.resolve(parsed.filename);
+    const agentFile = fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()
+        ? path.join(resolved, "main.agency")
+        : resolved;
+    const node = parsed.nodeName || "main";
+    return { agentFile, node, label: `${agentFile}:${node}` };
+}
+/** Resolve the runner-side agent choice. Exactly one of --agent /
+ *  --agent-cmd; the command's {task} placeholder is validated here, before
+ *  any run. Commands come ONLY from these flags, never from suite content —
+ *  suites can be remote git sources, and a suite that named its own command
+ *  would be remote code execution. */
+export function resolveEvalTarget(opts) {
+    if ((opts.agent ? 1 : 0) + (opts.agentCmd ? 1 : 0) !== 1) {
+        throw new Error("Provide exactly one of --agent or --agent-cmd");
+    }
+    if (opts.agentCmd) {
+        const tokens = tokenizeCommand(opts.agentCmd);
+        if (!tokens.some((t) => t.includes(TASK_PLACEHOLDER))) {
+            throw new Error(MISSING_TASK_PLACEHOLDER_ERROR);
+        }
+        return { kind: "command", tokens, label: opts.agentCmd };
+    }
+    return { kind: "file", ...resolveEvalRunTarget(opts.agent) };
+}
+/**
+ * Fail fast when the entry node cannot receive a task: eval delivers the
+ * input's task as the node's single positional parameter, so the node must
+ * take exactly one. The subprocess bootstrap enforces the same rule at run
+ * time (resolveNodeCallArgs), but by then a workdir has been seeded and the
+ * agent compiled — and the optimizer would pay that once per candidate.
+ * A misconfigured agent should cost one error, not a suite of run failures.
+ *
+ * Best-effort: an unreadable or unparseable file, or a node defined
+ * elsewhere than the entry file, is left for compile/run to report with
+ * better errors than a pre-parse could.
+ */
+export function assertEvalEntryNodeTakesOneParameter(agentFile, node) {
+    let source;
+    try {
+        source = fs.readFileSync(agentFile, "utf-8");
+    }
+    catch {
+        return;
+    }
+    const parsed = parseAgency(source, {}, false);
+    if (!parsed.success)
+        return;
+    for (const candidate of parsed.result.nodes) {
+        if (candidate.type !== "graphNode" || candidate.nodeName !== node)
+            continue;
+        const count = candidate.parameters.length;
+        if (count !== 1) {
+            const detail = count === 0
+                ? `takes none — add one (it may go unused: \`node ${node}(task: string) { ... }\`)`
+                : `takes ${count} (${candidate.parameters.map((p) => p.name).join(", ")}) — add a one-parameter adapter node`;
+            throw new Error(`eval delivers the input's task as the entry node's single parameter, ` +
+                `but node "${node}" in ${agentFile} ${detail}.`);
+        }
+    }
+}

package/dist/lib/agentTarget.test.js

@@ -0,0 +1,76 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { assertEvalEntryNodeTakesOneParameter, parseTarget, resolveEvalRunTarget, resolveEvalTarget } from "./agentTarget.js";
+const dirs = [];
+afterEach(() => {
+    // Raw rmSync, not safeDelete: mkdtemp paths sit outside any project root,
+    // which safeDelete refuses by design. Same reasoning as runArtifacts.ts.
+    for (const tempDir of dirs.splice(0)) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+});
+describe("agent targets", () => {
+    it("splits path from node on the last colon", () => {
+        expect(parseTarget("a.agency:main")).toEqual({ filename: "a.agency", nodeName: "main" });
+        expect(parseTarget("a.agency")).toEqual({ filename: "a.agency", nodeName: "" });
+    });
+    it("resolves file and directory agent targets", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-target-"));
+        dirs.push(tmpDir);
+        const file = path.join(tmpDir, "agent.agency");
+        fs.writeFileSync(file, "node main() {}\n");
+        const dir = path.join(tmpDir, "agent-dir");
+        fs.mkdirSync(dir);
+        fs.writeFileSync(path.join(dir, "main.agency"), "node main() {}\n");
+        expect(resolveEvalRunTarget(`${file}:evalMain`)).toEqual({ agentFile: file, node: "evalMain", label: `${file}:evalMain` });
+        expect(resolveEvalRunTarget(file)).toEqual({ agentFile: file, node: "main", label: `${file}:main` });
+        expect(resolveEvalRunTarget(dir)).toEqual({ agentFile: path.join(dir, "main.agency"), node: "main", label: `${path.join(dir, "main.agency")}:main` });
+    });
+});
+describe("resolveEvalTarget", () => {
+    it("resolves --agent into a file target", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "target-"));
+        dirs.push(tmpDir);
+        const file = path.join(tmpDir, "a.agency");
+        fs.writeFileSync(file, "node main(task: string) {}\n");
+        expect(resolveEvalTarget({ agent: `${file}:main` }))
+            .toEqual({ kind: "file", agentFile: file, node: "main", label: `${file}:main` });
+    });
+    it("resolves --agent-cmd into a command target with the placeholder intact", () => {
+        expect(resolveEvalTarget({ agentCmd: `agency agent -p -- {task}` }))
+            .toEqual({ kind: "command", tokens: ["agency", "agent", "-p", "--", "{task}"], label: "agency agent -p -- {task}" });
+    });
+    it("rejects both, neither, and a command without {task}", () => {
+        expect(() => resolveEvalTarget({ agent: "a.agency", agentCmd: "x {task}" })).toThrow(/exactly one of/);
+        expect(() => resolveEvalTarget({})).toThrow(/exactly one of/);
+        expect(() => resolveEvalTarget({ agentCmd: "agency agent -p hello" })).toThrow(/\{task\}/);
+    });
+});
+describe("assertEvalEntryNodeTakesOneParameter", () => {
+    function agentWith(source) {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-shape-"));
+        dirs.push(tmpDir);
+        const file = path.join(tmpDir, "agent.agency");
+        fs.writeFileSync(file, source);
+        return file;
+    }
+    it("accepts a one-parameter node, default value or not", () => {
+        expect(() => assertEvalEntryNodeTakesOneParameter(agentWith("node main(task: string) {}\n"), "main")).not.toThrow();
+        expect(() => assertEvalEntryNodeTakesOneParameter(agentWith('node main(task: string = "") {}\n'), "main")).not.toThrow();
+    });
+    it("rejects a zero-parameter node with the add-one hint", () => {
+        expect(() => assertEvalEntryNodeTakesOneParameter(agentWith("node main() {}\n"), "main"))
+            .toThrow(/takes none — add one/);
+    });
+    it("rejects a two-parameter node, naming the parameters", () => {
+        expect(() => assertEvalEntryNodeTakesOneParameter(agentWith("node main(a: string, b: string) {}\n"), "main"))
+            .toThrow(/takes 2 \(a, b\)/);
+    });
+    it("stays quiet on unparseable files and absent nodes — compile/run report those better", () => {
+        expect(() => assertEvalEntryNodeTakesOneParameter(agentWith("this is not agency"), "main")).not.toThrow();
+        expect(() => assertEvalEntryNodeTakesOneParameter(agentWith("node other(x: string) {}\n"), "main")).not.toThrow();
+        expect(() => assertEvalEntryNodeTakesOneParameter(path.join(os.tmpdir(), "does-not-exist.agency"), "main")).not.toThrow();
+    });
+});

package/dist/lib/agents/agency-agent/agent.js

@@ -725,7 +725,7 @@ async function __oneShotAgent_impl(target, prompt) {
           __stack.locals.__scrutinee_5 = __stack.locals.result;
         });
         await runner2.step(2, async (runner3) => {
-          __stack.locals.__hoist_0 = await isSuccess(__stack.locals.__scrutinee_5);
+          __stack.locals.__hoist_0 = await isSuccess(__stack.locals.result);
           if (hasInterrupts(__stack.locals.__hoist_0)) {
             await getRuntimeContext().ctx.pendingPromises.awaitAll();
             runner3.halt(__stack.locals.__hoist_0);
@@ -741,7 +741,7 @@ async function __oneShotAgent_impl(target, prompt) {
             condition: async () => __stack.locals.__hoist_0,
             body: async (runner3) => {
               await runner3.step(0, async (runner4) => {
-                __stack.locals.r = __stack.locals.__scrutinee_5.value;
+                __stack.locals.r = __stack.locals.result.value;
               });
               await runner3.step(1, async (runner4) => {
                 __stack.locals.__armval_3 = __stack.locals.r;
@@ -754,7 +754,7 @@ async function __oneShotAgent_impl(target, prompt) {
           }
         ], async (runner3) => {
           await runner3.step(3, async (runner4) => {
-            __stack.locals.__hoist_1 = await isFailure(__stack.locals.__scrutinee_5);
+            __stack.locals.__hoist_1 = await isFailure(__stack.locals.result);
             if (hasInterrupts(__stack.locals.__hoist_1)) {
               await getRuntimeContext().ctx.pendingPromises.awaitAll();
               runner4.halt(__stack.locals.__hoist_1);
@@ -770,7 +770,7 @@ async function __oneShotAgent_impl(target, prompt) {
               condition: async () => __stack.locals.__hoist_1,
               body: async (runner4) => {
                 await runner4.step(0, async (runner5) => {
-                  __stack.locals.f = __stack.locals.__scrutinee_5.error;
+                  __stack.locals.f = __stack.locals.result.error;
                 });
                 await runner4.step(1, async (runner5) => {
                   __stack.locals.__armval_4 = await __call(formatTurnFailure, {
@@ -1588,6 +1588,10 @@ async function main({ messages, callbacks } = {}) {
 }
 const __mainNodeParams = [];
 if (__process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (__process.argv.length > 2) {
+    console.error(`main() takes 0 argument(s) but got ${__process.argv.length - 2}; extra: ${__process.argv.slice(2).join(" ")}`);
+    __process.exit(1);
+  }
   try {
     const initialState = {
       messages: new ThreadStore(),

package/dist/lib/agents/agency-agent/lib/coordinator.js

@@ -2038,7 +2038,7 @@ async function __runTurn_impl(agentName, userMsg) {
           __stack.locals.__scrutinee_14 = __stack.locals.result;
         });
         await runner2.step(4, async (runner3) => {
-          __stack.locals.__hoist_2 = await isSuccess(__stack.locals.__scrutinee_14);
+          __stack.locals.__hoist_2 = await isSuccess(__stack.locals.result);
           if (hasInterrupts(__stack.locals.__hoist_2)) {
             await getRuntimeContext().ctx.pendingPromises.awaitAll();
             runner3.halt(__stack.locals.__hoist_2);
@@ -2054,7 +2054,7 @@ async function __runTurn_impl(agentName, userMsg) {
             condition: async () => __stack.locals.__hoist_2,
             body: async (runner3) => {
               await runner3.step(0, async (runner4) => {
-                __stack.locals.reply = __stack.locals.__scrutinee_14.value;
+                __stack.locals.reply = __stack.locals.result.value;
               });
               await runner3.step(1, async (runner4) => {
                 __stack.locals.__armval_13 = __stack.locals.reply;
@@ -2067,7 +2067,7 @@ async function __runTurn_impl(agentName, userMsg) {
           }
         ], async (runner3) => {
           await runner3.step(3, async (runner4) => {
-            __stack.locals.__hoist_3 = await isFailure(__stack.locals.__scrutinee_14);
+            __stack.locals.__hoist_3 = await isFailure(__stack.locals.result);
             if (hasInterrupts(__stack.locals.__hoist_3)) {
               await getRuntimeContext().ctx.pendingPromises.awaitAll();
               runner4.halt(__stack.locals.__hoist_3);
@@ -2083,7 +2083,7 @@ async function __runTurn_impl(agentName, userMsg) {
               condition: async () => __stack.locals.__hoist_3,
               body: async (runner4) => {
                 await runner4.step(0, async (runner5) => {
-                  __stack.locals.f = __stack.locals.__scrutinee_14.error;
+                  __stack.locals.f = __stack.locals.result.error;
                 });
                 await runner4.step(1, async (runner5) => {
                   __stack.locals.dimension = `cost`;

package/dist/lib/agents/agency-agent/lib/policy.js

@@ -851,7 +851,7 @@ async function __getPolicyForAgent_impl(_policyArg, interactive) {
                 __stack.locals.__scrutinee_7 = __stack.locals.loaded;
               });
               await runner3.step(2, async (runner4) => {
-                __stack.locals.__hoist_6 = await isSuccess(__stack.locals.__scrutinee_7);
+                __stack.locals.__hoist_6 = await isSuccess(__stack.locals.loaded);
                 if (hasInterrupts(__stack.locals.__hoist_6)) {
                   await getRuntimeContext().ctx.pendingPromises.awaitAll();
                   runner4.halt(__stack.locals.__hoist_6);
@@ -867,7 +867,7 @@ async function __getPolicyForAgent_impl(_policyArg, interactive) {
                   condition: async () => __stack.locals.__hoist_6,
                   body: async (runner4) => {
                     await runner4.step(0, async (runner5) => {
-                      __stack.locals._ = __stack.locals.__scrutinee_7.value;
+                      __stack.locals._ = __stack.locals.loaded.value;
                     });
                     await runner4.step(1, async (runner5) => {
                       __stack.locals.__armval_6 = __stack.args._policyArg;
@@ -880,7 +880,7 @@ async function __getPolicyForAgent_impl(_policyArg, interactive) {
                 }
               ], async (runner4) => {
                 await runner4.step(3, async (runner5) => {
-                  __stack.locals.__hoist_7 = await isFailure(__stack.locals.__scrutinee_7);
+                  __stack.locals.__hoist_7 = await isFailure(__stack.locals.loaded);
                   if (hasInterrupts(__stack.locals.__hoist_7)) {
                     await getRuntimeContext().ctx.pendingPromises.awaitAll();
                     runner5.halt(__stack.locals.__hoist_7);
@@ -896,7 +896,7 @@ async function __getPolicyForAgent_impl(_policyArg, interactive) {
                     condition: async () => __stack.locals.__hoist_7,
                     body: async (runner5) => {
                       await runner5.step(0, async (runner6) => {
-                        __stack.locals.f = __stack.locals.__scrutinee_7.error;
+                        __stack.locals.f = __stack.locals.loaded.error;
                       });
                       await runner5.step(1, async (runner6) => {
                         __stack.locals.__hoist_8 = await __call(builtinPolicyNames, {

package/dist/lib/agents/agency-agent/prompts/codeSample.js

@@ -762,6 +762,10 @@ async function createMeals({ messages, callbacks } = {}) {
 }
 const __createMealsNodeParams = [];
 if (__process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (__process.argv.length > 2) {
+    console.error(`main() takes 0 argument(s) but got ${__process.argv.length - 2}; extra: ${__process.argv.slice(2).join(" ")}`);
+    __process.exit(1);
+  }
   try {
     const initialState = {
       messages: new ThreadStore(),

package/dist/lib/agents/eval/goalJudge.js

@@ -314,12 +314,16 @@ async function main(goal, output, expected, { messages, callbacks } = {}) {
 }
 const __mainNodeParams = ["goal", "output", "expected"];
 if (__process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (__process.argv.length > 5) {
+    console.error(`main() takes 3 argument(s) but got ${__process.argv.length - 2}; extra: ${__process.argv.slice(5).join(" ")}`);
+    __process.exit(1);
+  }
   try {
     const initialState = {
       messages: new ThreadStore(),
       data: {}
     };
-    const __result = await main(initialState);
+    const __result = await main(__process.argv[2], __process.argv[3], __process.argv[4], initialState);
     await resolveCliInterrupts(__result, respondToInterrupts);
   } catch (__error) {
     reportBudgetExceededAndExit(__error);

package/dist/lib/agents/policy/agent.js

@@ -2067,6 +2067,10 @@ async function main({ messages, callbacks } = {}) {
 }
 const __mainNodeParams = [];
 if (__process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (__process.argv.length > 2) {
+    console.error(`main() takes 0 argument(s) but got ${__process.argv.length - 2}; extra: ${__process.argv.slice(2).join(" ")}`);
+    __process.exit(1);
+  }
   try {
     const initialState = {
       messages: new ThreadStore(),

package/dist/lib/agents/review/agent.js

@@ -802,6 +802,10 @@ async function end({ messages, callbacks } = {}) {
 }
 const __endNodeParams = [];
 if (__process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (__process.argv.length > 2) {
+    console.error(`main() takes 0 argument(s) but got ${__process.argv.length - 2}; extra: ${__process.argv.slice(2).join(" ")}`);
+    __process.exit(1);
+  }
   try {
     const initialState = {
       messages: new ThreadStore(),

package/dist/lib/analysis/closure.d.ts

@@ -0,0 +1,26 @@
+import type { AgencyProgram } from "../types.js";
+/** One file of an agent's .agency import closure, parsed exactly once.
+ *  Two consumers: seeding reads only `absoluteFile`; the optimizer's target
+ *  discovery reads `source` (content hashes for safe writeback) and
+ *  `program` (finding optimize-marked declarations). */
+export type ParsedSourceFile = {
+    absoluteFile: string;
+    source: string;
+    program: AgencyProgram;
+};
+/** Walk the local .agency import closure of `absoluteEntryFile`, parsing each
+ *  file once. The single parse pass target discovery and seeding both share. */
+export declare function walkAgencyClosure(absoluteEntryFile: string): ParsedSourceFile[];
+/** Absolute base directory a closure's relative paths hang off: the files'
+ *  common ancestor, unless that lies inside the current working directory, in
+ *  which case cwd wins. */
+export declare function closureBaseDir(absoluteFiles: string[]): string;
+/** The entry file's full local closure: every .agency file the walk reaches,
+ *  plus the transitive local TS/JS files their interop imports need. baseDir
+ *  is computed from the .agency files only, so adding TS deps can never
+ *  shift it. */
+export declare function agentClosure(entryFile: string): {
+    baseDir: string;
+    files: string[];
+};
+export declare function agentClosureBaseDir(entryFile: string): string;

package/dist/lib/analysis/closure.js

@@ -0,0 +1,99 @@
+import fs from "fs";
+import path from "path";
+import { buildSync } from "esbuild";
+import { agencyImportTargets, nonAgencyLocalImportTargets, resolveAgencyImportPath } from "../importPaths.js";
+import { parseAgency } from "../parser.js";
+/** Walk the local .agency import closure of `absoluteEntryFile`, parsing each
+ *  file once. The single parse pass target discovery and seeding both share. */
+export function walkAgencyClosure(absoluteEntryFile) {
+    const parsedFiles = [];
+    visitFile(absoluteEntryFile, {}, parsedFiles);
+    return parsedFiles;
+}
+function visitFile(absoluteFile, visited, parsedFiles) {
+    const canonicalFile = fs.realpathSync(absoluteFile);
+    if (visited[canonicalFile])
+        return;
+    visited[canonicalFile] = true;
+    const source = fs.readFileSync(canonicalFile, "utf8");
+    const parseResult = parseAgency(source, {}, false);
+    if (!parseResult.success) {
+        throw new Error(`Failed to parse ${canonicalFile}: ${parseResult.message ?? "parse error"}`);
+    }
+    parsedFiles.push({ absoluteFile: canonicalFile, source, program: parseResult.result });
+    for (const importPath of agencyImportTargets(parseResult.result, { localOnly: true })) {
+        visitFile(resolveAgencyImportPath(importPath, canonicalFile), visited, parsedFiles);
+    }
+}
+/** Absolute base directory a closure's relative paths hang off: the files'
+ *  common ancestor, unless that lies inside the current working directory, in
+ *  which case cwd wins. */
+export function closureBaseDir(absoluteFiles) {
+    const ancestor = commonAncestor(absoluteFiles.map((file) => path.dirname(file)));
+    const cwd = fs.realpathSync(process.cwd());
+    return isInsideOrSame(ancestor, cwd) ? cwd : ancestor;
+}
+function commonAncestor(paths) {
+    if (paths.length === 0)
+        return process.cwd();
+    const [first, ...rest] = paths.map((candidate) => path.resolve(candidate).split(path.sep));
+    const prefix = [];
+    for (let index = 0; index < first.length; index += 1) {
+        const segment = first[index];
+        if (rest.some((candidate) => candidate[index] !== segment))
+            break;
+        prefix.push(segment);
+    }
+    const joined = prefix.join(path.sep);
+    return joined === "" ? path.sep : joined;
+}
+function isInsideOrSame(candidate, parent) {
+    const relative = path.relative(parent, path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+/** The entry file's full local closure: every .agency file the walk reaches,
+ *  plus the transitive local TS/JS files their interop imports need. baseDir
+ *  is computed from the .agency files only, so adding TS deps can never
+ *  shift it. */
+export function agentClosure(entryFile) {
+    const absoluteEntryFile = fs.realpathSync(path.resolve(entryFile));
+    const parsedFiles = walkAgencyClosure(absoluteEntryFile);
+    const agencyFiles = parsedFiles.map((parsed) => parsed.absoluteFile);
+    const interopEntries = parsedFiles.flatMap((parsed) => nonAgencyLocalImportTargets(parsed.program).map((specifier) => resolveInteropEntry(path.dirname(parsed.absoluteFile), specifier)));
+    const interopFiles = interopEntries.flatMap((interopEntry) => transitiveTsFiles(interopEntry));
+    const files = uniqueSorted([...agencyFiles, ...interopFiles].sort());
+    return { baseDir: closureBaseDir(agencyFiles), files };
+}
+/** `./greet.js` on disk may be greet.ts (the guide says to write .js even for
+ *  TypeScript sources). Prefer the file that exists; .ts when both do not. */
+function resolveInteropEntry(fromDir, specifier) {
+    const asWritten = path.resolve(fromDir, specifier);
+    if (fs.existsSync(asWritten))
+        return asWritten;
+    const asTs = asWritten.replace(/\.js$/, ".ts");
+    if (fs.existsSync(asTs))
+        return asTs;
+    return asWritten; // let esbuild produce the resolution error, which names the importer
+}
+/** The transitive local file set of one TS/JS entry, from esbuild's metafile.
+ *  Bare (package) imports stay external, so only relative files appear. */
+function transitiveTsFiles(interopEntry) {
+    const result = buildSync({
+        entryPoints: [interopEntry],
+        bundle: true,
+        write: false,
+        metafile: true,
+        packages: "external",
+        logLevel: "silent",
+    });
+    return Object.keys(result.metafile.inputs).map((inputPath) => path.resolve(inputPath));
+}
+/** Remove duplicates from a sorted list (equal items are adjacent). Dupes
+ *  arise when two .agency files import the same TS helper, or two TS entries
+ *  share transitive files. */
+function uniqueSorted(sorted) {
+    return sorted.filter((item, index) => index === 0 || item !== sorted[index - 1]);
+}
+export function agentClosureBaseDir(entryFile) {
+    return agentClosure(entryFile).baseDir;
+}

package/dist/lib/analysis/closure.test.js

@@ -0,0 +1,43 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { describe, expect, it } from "vitest";
+import { agentClosure, agentClosureBaseDir } from "./closure.js";
+describe("agentClosure", () => {
+    function closureProject() {
+        const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "closure-"));
+        fs.mkdirSync(path.join(projectDir, "lib"), { recursive: true });
+        fs.writeFileSync(path.join(projectDir, "lib", "helper.agency"), "export def helper(): string { return \"hi\" }\n");
+        fs.writeFileSync(path.join(projectDir, "agent.agency"), "import { helper } from \"./lib/helper.agency\"\nnode main() {}\n");
+        fs.writeFileSync(path.join(projectDir, "unrelated.agency"), "node main() {}\n");
+        return projectDir;
+    }
+    it("returns the entry plus every transitively imported .agency file, and agrees with agentClosureBaseDir", () => {
+        const projectDir = closureProject();
+        const closure = agentClosure(path.join(projectDir, "agent.agency"));
+        const rels = closure.files.map((file) => path.relative(closure.baseDir, file)).sort();
+        expect(rels).toEqual(["agent.agency", path.join("lib", "helper.agency")]);
+        expect(closure.baseDir).toBe(agentClosureBaseDir(path.join(projectDir, "agent.agency")));
+        fs.rmSync(projectDir, { recursive: true, force: true });
+    });
+    it("includes TypeScript interop files, transitively, resolving ./x.js to x.ts", () => {
+        const projectDir = closureProject();
+        // agent imports ./greet.js (the interop form); greet.ts exists and imports ./util.ts
+        fs.writeFileSync(path.join(projectDir, "agent.agency"), "import { helper } from \"./lib/helper.agency\"\nimport { greet } from \"./greet.js\"\nnode main() {}\n");
+        fs.writeFileSync(path.join(projectDir, "greet.ts"), "import { upper } from \"./util.js\";\nexport function greet(name: string): string { return upper(name); }\n");
+        fs.writeFileSync(path.join(projectDir, "util.ts"), "export function upper(value: string): string { return value.toUpperCase(); }\n");
+        const closure = agentClosure(path.join(projectDir, "agent.agency"));
+        const rels = closure.files.map((file) => path.relative(closure.baseDir, file)).sort();
+        expect(rels).toEqual(["agent.agency", "greet.ts", path.join("lib", "helper.agency"), "util.ts"]);
+        fs.rmSync(projectDir, { recursive: true, force: true });
+    });
+    it("leaves bare package imports external (no node_modules files in the closure)", () => {
+        const projectDir = closureProject();
+        fs.writeFileSync(path.join(projectDir, "agent.agency"), "import { z } from \"./schema.js\"\nnode main() {}\n");
+        fs.writeFileSync(path.join(projectDir, "schema.ts"), "import { z } from \"zod\";\nexport { z };\n");
+        const closure = agentClosure(path.join(projectDir, "agent.agency"));
+        const rels = closure.files.map((file) => path.relative(closure.baseDir, file)).sort();
+        expect(rels).toEqual(["agent.agency", "schema.ts"]);
+        fs.rmSync(projectDir, { recursive: true, force: true });
+    });
+});

package/dist/lib/analysis/imports.d.ts

@@ -0,0 +1,10 @@
+import { AgencyProgram } from "../types.js";
+/** The agency-file imports a program declares: import-node statements plus
+ *  `import ... from "<agency path>"` statements. Filters out npm/Node module
+ *  imports — see compile.ts's getAllImports for the unfiltered walk. */
+export declare function getImports(program: AgencyProgram): string[];
+export type AnyImport = {
+    path: string;
+    kind: "module" | "node";
+};
+export declare function getAllImports(program: AgencyProgram): AnyImport[];

package/dist/lib/analysis/imports.js

@@ -0,0 +1,25 @@
+import { isAgencyImport } from "../importPaths.js";
+/** The agency-file imports a program declares: import-node statements plus
+ *  `import ... from "<agency path>"` statements. Filters out npm/Node module
+ *  imports — see compile.ts's getAllImports for the unfiltered walk. */
+export function getImports(program) {
+    const toolAndNodeImports = program.nodes
+        .filter((node) => node.type === "importNodeStatement")
+        .map((node) => node.agencyFile.trim());
+    // this makes compile() try to parse non-agency files
+    const importStatements = program.nodes
+        .filter((node) => node.type === "importStatement" && isAgencyImport(node.modulePath))
+        .map((node) => node.modulePath.trim());
+    return [...toolAndNodeImports, ...importStatements];
+}
+export function getAllImports(program) {
+    return program.nodes.flatMap((node) => {
+        if (node.type === "importStatement") {
+            return [{ path: node.modulePath.trim(), kind: "module" }];
+        }
+        if (node.type === "importNodeStatement") {
+            return [{ path: node.agencyFile.trim(), kind: "node" }];
+        }
+        return [];
+    });
+}

package/dist/lib/backends/agencyGenerator.d.ts

@@ -44,7 +44,6 @@ export declare class AgencyGenerator {
     protected importAttachedComments: Map<ImportStatement | ImportNodeStatement, AgencyNode[]>;
     protected functionDefinitions: Record<string, FunctionDefinition>;
     protected currentScope: Scope[];
-    protected program: AgencyProgram | null;
     protected agencyConfig: AgencyConfig;
     private indentLevel;
     private indentSize;
@@ -201,6 +200,20 @@ export declare class AgencyGenerator {
     protected processCodeLiteral(node: CodeLiteral): string;
     protected asyncAwaitPrefix(code: string, async?: boolean): string;
     protected processMatchBlock(node: MatchBlock): string;
+    /** Whether a one-statement arm body may print inline (`=> stmt`)
+     *  rather than as a `{ ... }` block.
+     *
+     *  The author's form wins: an arm written as a block prints as a block
+     *  (`blockBody`, set by the parser), an arm written inline prints
+     *  inline. The shape tests below only decide for cases with NO
+     *  recorded form — ASTs built programmatically — where inline is only
+     *  safe for the shapes the single-statement arm grammar accepts;
+     *  anything else must take block form or the printed arm will not
+     *  re-parse (#708). */
+    protected armPrintsInline(caseNode: {
+        body: AgencyNode[];
+        blockBody?: true;
+    }): boolean;
     protected processForLoop(node: ForLoop): string;
     protected processWhileLoop(node: WhileLoop): string;
     protected processIfElse(node: IfElse): string;