@vimhead.dev/norn-cli 0.1.0-tip.35359392805.1 → 0.1.0-tip.35436871363.1

package/assets/packages/cli/src/cli.ts

@@ -12,14 +12,16 @@ import { Value } from "typebox/value";
 import { NORN_BUILD_INFO, type NornBuildInfo, type NornGithubReleaseBinaryBuildInfo } from "./build-info.ts";
 import { renderNornDocumentationIntro, resolveDocumentationCacheRoot, resolveNornDocumentation, type NornDocumentationSource } from "./documentation.ts";
 import { NornEngine } from "./internal/engine.ts";
+import { resolveNornAgentDirectory } from "./internal/agent-directory.ts";
 import { errorMessage, NornProjectLoadError, NornRunStoppedError } from "./internal/errors.ts";
 import { clearRunResumeRequest, readRunLaunchRequest, readRunResumeRequest, writeRunLaunchRequest, writeRunResumeRequest, type NornRunResumeRequest } from "./internal/launch-request.ts";
 import { readRunMetrics } from "./internal/metrics.ts";
 import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.ts";
 import { generateRunName } from "./internal/run-names.ts";
-import { getRunInfo, listRuns, mergeInterruptedWorkflowParams, resolveRunRoot } from "./internal/run-state.ts";
+import { assertRunVersion, getRunInfo, listRuns, mergeInterruptedWorkflowArgs, resolveRunRoot } from "./internal/run-state.ts";
 import { NornRunStore } from "./internal/run-store.ts";
-import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./plugin-loader.ts";
+import { prepareRunWorkerDirectory } from "./internal/worker-directory.ts";
+import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./workflow-loader.ts";
 
 const RUNS_ROOT = join(".norn", "runs");
 const RUN_WAIT_INTERVAL_MS = 1000;
@@ -110,9 +112,9 @@ const COMMANDS: readonly CliCommand[] = [
 	{
 		id: "project.inspect",
 		path: ["project", "inspect"],
-		description: "Use when discovering the active Norn project, plugins, and workflow sources.",
+		description: "Use when discovering the active Norn project, configuration, and workflow sources.",
 		usage: "norn project inspect",
-		output: "JSON object with project metadata under project, isComplete, and plugin diagnostics. Incomplete discovery does not permit execution.",
+		output: "JSON object with project metadata under project, isComplete, and registration diagnostics. Incomplete discovery does not permit execution.",
 		examples: ["norn project inspect"],
 		execute: async (args) => {
 			assertNoExtraArgs("project inspect", args);
@@ -125,17 +127,17 @@ const COMMANDS: readonly CliCommand[] = [
 		description: "Use when selecting a Norn workflow for a user task; defaults to entrypoint workflows.",
 		usage: "norn workflows list [--entrypoints|--all]",
 		options: ["--entrypoints: list entrypoint workflows", "--all: include internal workflow steps"],
-		output: "JSON object with workflow summaries under workflows, isComplete, and plugin diagnostics. Successful discovery can be incomplete; start/resume remain strict.",
+		output: "JSON object with workflow summaries under workflows, isComplete, and registration diagnostics. Successful discovery can be incomplete; start/resume remain strict.",
 		examples: ["norn workflows list", "norn workflows list --all"],
 		execute: listWorkflows,
 	},
 	{
 		id: "workflows.inspect",
 		path: ["workflows", "inspect"],
-		description: "Use when reading a workflow's instructions, params schema, gate contract, and source plugin before starting or editing it.",
+		description: "Use when reading a workflow's instructions, args schema, gate contract, and registration source before starting or editing it.",
 		usage: "norn workflows inspect <workflow-id>",
 		arguments: ["workflow-id: fully qualified workflow id"],
-		output: "JSON object with workflow details, isComplete, and plugin diagnostics. workflow is null if unavailable in an incomplete catalog or its schema cannot be inspected; an unknown id in a complete catalog is an error.",
+		output: "JSON object with workflow details, isComplete, and registration diagnostics. workflow is null if unavailable in an incomplete catalog or its schema cannot be inspected; an unknown id in a complete catalog is an error.",
 		examples: ["norn workflows inspect example.plan"],
 		execute: async (args) => {
 			const workflowId = requiredArg("workflows inspect", args, 0, "workflow id");
@@ -146,12 +148,12 @@ const COMMANDS: readonly CliCommand[] = [
 	{
 		id: "runs.start",
 		path: ["runs", "start"],
-		description: "Use when starting a Norn workflow run after the workflow id and params are known.",
+		description: "Use when starting a Norn workflow run after the workflow id and args are known.",
 		usage: "norn runs start <workflow-id>",
 		arguments: ["workflow-id: fully qualified workflow id to start"],
-		stdin: "Optional JSON object: {\"params\":{...},\"config\":{\"pluginId\":{...}}}.",
+		stdin: "Optional JSON object: {\"args\":{...},\"config\":{\"workflowOrScopeId\":{...}}}.",
 		output: "JSON object with started run info under run.",
-		examples: ["printf '{\"params\":{\"task\":\"Add tests\"}}' | norn runs start example.plan"],
+		examples: ["printf '{\"args\":{\"task\":\"Add tests\"}}' | norn runs start example.plan"],
 		execute: async (args) => {
 			const workflowId = requiredArg("runs start", args, 0, "workflow id");
 			await startRun(workflowId, args.slice(1));
@@ -163,9 +165,9 @@ const COMMANDS: readonly CliCommand[] = [
 		description: "Use when resuming an interrupted gate or a checkpoint restored for retry.",
 		usage: "norn runs resume <run>",
 		arguments: ["run: run id, generated name, or run path"],
-		stdin: "Optional JSON object: {\"params\":{...}}. Interrupted runs require a patch containing only editable gate fields; pending-resume runs do not accept params.",
+		stdin: "Optional JSON object: {\"args\":{...}}. Interrupted runs require a patch containing only editable gate fields; pending-resume runs do not accept args.",
 		output: "JSON object with resumed run info under run.",
-		examples: ["printf '{\"params\":{\"decision\":\"accept\"}}' | norn runs resume quiet-river-lantern"],
+		examples: ["printf '{\"args\":{\"decision\":\"accept\"}}' | norn runs resume quiet-river-lantern"],
 		execute: async (args) => {
 			const run = requiredArg("runs resume", args, 0, "run");
 			await resumeRun(run, args.slice(1));
@@ -753,7 +755,7 @@ async function initProject(): Promise<void> {
 	const projectPath = resolve(projectRoot, NORN_PROJECT_FILE_NAME);
 	if (await isFile(projectPath)) throw new Error(`Norn project already exists: ${projectPath}`);
 	await mkdir(resolve(projectRoot, RUNS_ROOT), { recursive: true });
-	await writeFile(projectPath, `${JSON.stringify({ version: 1, plugins: [], includes: [], config: {} }, null, 2)}\n`, "utf8");
+	await writeFile(projectPath, `${JSON.stringify({ version: 1, workflows: [], includes: [], config: {} }, null, 2)}\n`, "utf8");
 	await ensureGitignoreExcludesRunState(projectRoot);
 	writeJson({ project: { path: projectPath, root: projectRoot, runsRoot: resolve(projectRoot, RUNS_ROOT) } });
 }
@@ -768,23 +770,23 @@ async function inspectProject(): Promise<void> {
 	writeJson({ project, isComplete, diagnostics });
 }
 
-async function startRun(workflowId: string, args: readonly string[]): Promise<void> {
-	assertNoStructuredInputArgs("runs start", args);
+async function startRun(workflowId: string, commandArgs: readonly string[]): Promise<void> {
+	assertNoStructuredInputArgs("runs start", commandArgs);
 	const project = await loadNornProject(process.cwd());
 	const workflow = project.registry.workflowById(workflowId);
 	if (!workflow) throw new Error(`Unknown workflow: ${workflowId}`);
 	const input = parseStartRunInput(await readStdinJson());
-	const params = input.params === undefined ? {} : input.params;
-	Value.Decode(workflow.params, params);
+	const args = input.args === undefined ? {} : input.args;
+	Value.Decode(workflow.args, args);
 	const configOverride = input.config;
 	const id = randomUUID();
 	const name = generateRunName(new Set((await listRuns(project.projectRoot)).map((run) => run.name)));
 	const runRoot = resolve(project.projectRoot, RUNS_ROOT, id);
 	await mkdir(runRoot, { recursive: true });
 	const createdAt = new Date().toISOString();
-	await writeRunLaunchRequest(runRoot, { version: 1, type: "run", id, name, workflowId, params, configOverride, createdAt });
+	await writeRunLaunchRequest(runRoot, { version: 2, type: "run", id, name, workflowId, args, configOverride, createdAt });
 	await startDetachedExecuteRun(id, project.projectRoot);
-	writeJson({ run: startedRunInfo({ id, name, workflow, runRoot, createdAt }) });
+	writeJson({ run: startedRunInfo({ id, name, workflow, runRoot, projectRoot: project.projectRoot, createdAt }) });
 }
 
 async function resumeRun(run: string, args: readonly string[]): Promise<void> {
@@ -796,8 +798,9 @@ async function resumeRun(run: string, args: readonly string[]): Promise<void> {
 	let request: NornRunResumeRequest;
 	try {
 		const runInfo = await getRunInfo(runRoot);
-		const params = await parseResumeParams(runInfo, input.params);
-		request = { version: 1, type: "resume", id: runInfo.id, requestId: randomUUID(), params, createdAt: new Date().toISOString() };
+		assertRunVersion(runInfo.version);
+		const args = await parseResumeArgs(runInfo, input.args);
+		request = { version: 2, type: "resume", id: runInfo.id, requestId: randomUUID(), args, createdAt: new Date().toISOString() };
 		await writeRunResumeRequest(runRoot, request);
 	} finally {
 		await lease.release();
@@ -811,18 +814,18 @@ async function resumeRun(run: string, args: readonly string[]): Promise<void> {
 	writeJson({ run: await getRunInfo(runRoot) });
 }
 
-async function parseResumeParams(runInfo: NornRunInfo, params: unknown): Promise<unknown> {
+async function parseResumeArgs(runInfo: NornRunInfo, args: unknown): Promise<unknown> {
 	if (runInfo.status === "interrupted") {
-		if (params === undefined) throw new Error(`Interrupted workflow resume requires params: ${runInfo.name}`);
+		if (args === undefined) throw new Error(`Interrupted workflow resume requires args: ${runInfo.name}`);
 		if (!runInfo.currentWorkflowId) throw new Error(`Run has no current workflow: ${runInfo.name}`);
 		const project = await loadNornProject(process.cwd());
 		const workflow = project.registry.workflowById(runInfo.currentWorkflowId);
 		if (!workflow) throw new Error(`Unknown workflow for resumed run: ${runInfo.currentWorkflowId}`);
-		Value.Decode(workflow.params, mergeInterruptedWorkflowParams(runInfo.interruption?.params, params, runInfo.interruption?.fields));
-		return params;
+		Value.Decode(workflow.args, mergeInterruptedWorkflowArgs(runInfo.interruption?.args, args, runInfo.interruption?.fields));
+		return args;
 	}
 	if (runInfo.status === "pendingResume") {
-		if (params !== undefined) throw new Error(`Pending-resume workflows do not accept params: ${runInfo.name}`);
+		if (args !== undefined) throw new Error(`Pending-resume workflows do not accept args: ${runInfo.name}`);
 		return undefined;
 	}
 	throw new Error(`Run must be rolled back before resuming: ${runInfo.name}`);
@@ -898,13 +901,15 @@ async function executeRun(runId: string): Promise<void> {
 	const runRoot = resolve(location.projectRoot, RUNS_ROOT, runId);
 	const request = await readOptionalRunLaunchRequest(runRoot) ?? await readRunResumeRequest(runRoot);
 	try {
-		const project = await loadNornProject(process.cwd());
-		const engine = new NornEngine({ cwd: project.projectRoot, signal: abortController.signal, gateMode: "pause", config: project.projectConfig });
-		for (const plugin of project.plugins) engine.registerPlugin(plugin);
+		const agentDir = resolveNornAgentDirectory({ home: homedir(), environment: process.env });
+		process.chdir(await prepareRunWorkerDirectory(runRoot));
+		const project = await loadNornProject(location.projectRoot);
+		const engine = new NornEngine({ cwd: project.projectRoot, agentDir, signal: abortController.signal, gateMode: "pause", config: project.projectConfig });
+		engine.registerWorkflows(project.definitions);
 		if (request.type === "run") {
 			const workflow = project.registry.workflowById(request.workflowId);
 			if (!workflow) throw new Error(`Unknown workflow: ${request.workflowId}`);
-			await engine.runWorkflow(workflow, request.params, { id: request.id, name: request.name, configOverride: request.configOverride });
+			await engine.runWorkflow(workflow, request.args, { id: request.id, name: request.name, configOverride: request.configOverride });
 		} else {
 			await engine.resumeRequestedWorkflow({ runRoot, request });
 		}
@@ -999,6 +1004,7 @@ function detachedExecuteRunArgs(runId: string): readonly string[] {
 }
 
 function startedRunInfo(input: {
+	readonly projectRoot: string;
 	readonly id: string;
 	readonly name: string;
 	readonly workflow: NornAnyWorkflowDeclaration;
@@ -1006,10 +1012,11 @@ function startedRunInfo(input: {
 	readonly createdAt: string;
 }): NornRunInfo {
 	return {
-		version: 1,
+		version: 2,
 		id: input.id,
 		name: input.name,
 		path: input.runRoot,
+		paths: { project: input.projectRoot, workspace: join(input.runRoot, "current", "workspace") },
 		entrypointWorkflowId: input.workflow.id,
 		currentWorkflowId: input.workflow.id,
 		status: "running",
@@ -1058,18 +1065,18 @@ async function readStdin(): Promise<string> {
 	});
 }
 
-function parseStartRunInput(value: unknown): { readonly params?: unknown; readonly config?: unknown } {
+function parseStartRunInput(value: unknown): { readonly args?: unknown; readonly config?: unknown } {
 	if (value === undefined) return {};
 	const input = parseStructuredInputObject("runs start", value);
-	assertStructuredInputKeys("runs start", input, ["params", "config"]);
-	return { params: input.params, config: input.config };
+	assertStructuredInputKeys("runs start", input, ["args", "config"]);
+	return { args: input.args, config: input.config };
 }
 
-function parseResumeRunInput(value: unknown): { readonly params?: unknown } {
+function parseResumeRunInput(value: unknown): { readonly args?: unknown } {
 	if (value === undefined) return {};
 	const input = parseStructuredInputObject("runs resume", value);
-	assertStructuredInputKeys("runs resume", input, ["params"]);
-	return { params: input.params };
+	assertStructuredInputKeys("runs resume", input, ["args"]);
+	return { args: input.args };
 }
 
 function parseStructuredInputObject(command: string, value: unknown): Record<string, unknown> {

package/assets/packages/cli/src/client.ts

@@ -3,16 +3,15 @@ import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";
 import type {
 	DeletedNornRunInfo,
-	NornPluginDiagnostic,
+	NornWorkflowDiagnostic,
 	NornProjectInspection,
 	NornWorkflowCatalogInfo,
 	NornWorkflowInspection,
 	NornRunCheckpoint,
 	NornRunInfo,
 	NornRunMetrics,
-	NornWorkflowStateReader,
 } from "@vimhead.dev/norn";
-import { loadNornProject } from "./plugin-loader.ts";
+import { loadNornProject } from "./workflow-loader.ts";
 import { NornProjectLoadError } from "./internal/errors.ts";
 import type { NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
 
@@ -32,10 +31,9 @@ export type NornClient = {
 		inspect(workflowId: string): Promise<NornWorkflowInspection>;
 		entries(): Promise<readonly NornRegisteredWorkflow[]>;
 	};
-	readonly state: NornWorkflowStateReader;
 	readonly runs: {
-		start(input: { readonly workflowId: string; readonly params: unknown; readonly configOverride?: unknown }): Promise<NornRunInfo>;
-		resume(input: { readonly run: string; readonly params?: unknown }): Promise<NornRunInfo>;
+		start(input: { readonly workflowId: string; readonly args: unknown; readonly configOverride?: unknown }): Promise<NornRunInfo>;
+		resume(input: { readonly run: string; readonly args?: unknown }): Promise<NornRunInfo>;
 		wait(run: string): Promise<NornRunInfo>;
 		list(): Promise<NornRunInfo[]>;
 		inspect(run: string): Promise<NornRunInfo>;
@@ -61,7 +59,6 @@ export function createNornClient(input: NornClientInput = {}): NornClient {
 			inspect: async (workflowId) => processRunner.readJson<NornWorkflowInspection>(["workflows", "inspect", workflowId]),
 			entries: async () => (await catalog.load()).workflows,
 		},
-		state: catalog.state,
 		runs: {
 			start: async (startInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "start", startInput.workflowId], JSON.stringify(runStartInput(startInput)))).run,
 			resume: async (resumeInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "resume", resumeInput.run], runResumeStdin(resumeInput))).run,
@@ -82,10 +79,6 @@ export function createNornClient(input: NornClientInput = {}): NornClient {
 
 class NornWorkflowCatalog {
 	private loaded: ReturnType<typeof loadNornProject> | undefined;
-	readonly state: NornWorkflowStateReader = {
-		get: async (state) => (await this.load()).state.get(state),
-		getOptional: async (state) => (await this.load()).state.getOptional(state),
-	};
 
 	constructor(private readonly cwd: string) {}
 
@@ -107,7 +100,7 @@ class NornProcessRunner {
 
 	async readJson<T>(args: readonly string[], stdin?: string): Promise<T> {
 		const result = await this.spawn(args, stdin);
-		const parsed = JSON.parse(result.stdout) as T | { error?: { code?: string; message?: string; diagnostics?: NornPluginDiagnostic[] } };
+		const parsed = JSON.parse(result.stdout) as T | { error?: { code?: string; message?: string; diagnostics?: NornWorkflowDiagnostic[] } };
 		if (parsed && typeof parsed === "object" && "error" in parsed) {
 			if (parsed.error?.code === "NORN_PROJECT_INVALID" && Array.isArray(parsed.error.diagnostics)) throw new NornProjectLoadError({ diagnostics: parsed.error.diagnostics });
 			throw new Error(parsed.error?.message ?? "Norn command failed");
@@ -151,10 +144,10 @@ class NornProcessRunner {
 	}
 }
 
-function runStartInput(input: { readonly params: unknown; readonly configOverride?: unknown }): { readonly params: unknown; readonly config?: unknown } {
-	return input.configOverride === undefined ? { params: input.params } : { params: input.params, config: input.configOverride };
+function runStartInput(input: { readonly args: unknown; readonly configOverride?: unknown }): { readonly args: unknown; readonly config?: unknown } {
+	return input.configOverride === undefined ? { args: input.args } : { args: input.args, config: input.configOverride };
 }
 
-function runResumeStdin(input: { readonly params?: unknown }): string | undefined {
-	return input.params === undefined ? undefined : JSON.stringify({ params: input.params });
+function runResumeStdin(input: { readonly args?: unknown }): string | undefined {
+	return input.args === undefined ? undefined : JSON.stringify({ args: input.args });
 }

package/assets/packages/cli/src/documentation-intro.ts

@@ -24,7 +24,7 @@ export function renderNornDocumentationIntro(input: {
 		"",
 		"Live CLI contracts (argument arrays appended to the runtime argv above):",
 		'- ["workflows", "list"] — currently registered entrypoints.',
-		'- ["workflows", "inspect", "<workflow-id>"] — current instructions, params schema, and source.',
+		'- ["workflows", "inspect", "<workflow-id>"] — current instructions, args schema, and source.',
 		'- ["help"] — command usage.',
 	].join("\n");
 }

package/assets/packages/cli/src/generated-build-info.ts

@@ -2,8 +2,8 @@ import type { NornBuildInfo } from "./build-info.ts";
 
 export const NORN_GENERATED_BUILD_INFO = {
   "kind": "npm-registry",
-  "version": "0.1.0-tip.35359392805.1",
-  "commit": "f958006ca0ae3752060727c5b76b2ac1a008b103",
+  "version": "0.1.0-tip.35436871363.1",
+  "commit": "49b14d0ed0c9633fc6ee530a557ec7babbf52b22",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

package/assets/packages/cli/src/internal/agent-response-tool.ts

@@ -71,12 +71,12 @@ export class NornAgentResponseToolFactory {
 				label: Type.String({ description: "The exact workflow agent label provided in the prompt." }),
 				response: Type.Unknown({ description: "The structured response object requested by the workflow." }),
 			}),
-			async execute(_toolCallId, params) {
+			async execute(_toolCallId, args) {
 				try {
-					const captured = responseCollector.capture(params.runId, params.label, params.response);
+					const captured = responseCollector.capture(args.runId, args.label, args.response);
 					return {
 						content: [{ type: "text", text: `Recorded workflow agent response for ${captured.label}.` }],
-						details: { valid: true, runId: params.runId, label: captured.label, response: captured.response } as AgentResponseToolDetails,
+						details: { valid: true, runId: args.runId, label: captured.label, response: captured.response } as AgentResponseToolDetails,
 						terminate: true,
 					};
 				} catch (error) {

package/assets/packages/cli/src/internal/agents.ts

@@ -5,6 +5,7 @@ import {
 	createEventBus,
 	type AgentSession,
 	type CreateAgentSessionOptions,
+	type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import type { NornAgentCreateSessionInput, NornAgentPromptInput, NornAgentRunRawAttempt, NornAgentRunResult, NornAgentSession, NornAgentSessionEvents, NornAgentSinglePromptInput, NornAgentUsage } from "@vimhead.dev/norn";
 import { AGENT_RESPONSE_TOOL_NAME } from "@vimhead.dev/norn-core/agent-protocol";
@@ -12,7 +13,8 @@ import { inspectSchema } from "@vimhead.dev/norn/schema";
 import { randomUUID } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { resolve } from "node:path";
+import { requireAbsoluteWorkingDirectory } from "./working-directory.ts";
 import { type StaticDecode, type TSchema } from "typebox";
 import { resolveNornAgentDirectory } from "./agent-directory.ts";
 import {
@@ -23,19 +25,14 @@ import {
 import { errorMessage } from "./errors.ts";
 import { safeFileName } from "./file-names.ts";
 import type { NornRunLogs } from "./logs.ts";
-import { NornSessionResourceBindings } from "./resource-bindings.ts";
 import type { NornRunLogger } from "./run-log.ts";
 import { agentUsageFromValue, emptyAgentUsage, totalAgentUsage } from "./usage.ts";
 
 const DEFAULT_AGENT_ATTEMPTS = 3;
-const DEFAULT_AGENT_TOOL_ALLOWLIST = ["read", "bash", "edit", "write", AGENT_RESPONSE_TOOL_NAME] as const;
 
 type NornAgentRunnerInput = {
 	readonly id: string;
 	readonly runRoot: string;
-	readonly boundaryRoot: string;
-	readonly boundaryName: string;
-	readonly cwd: string;
 	readonly signal?: AbortSignal;
 	readonly model?: CreateAgentSessionOptions["model"];
 	readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
@@ -49,7 +46,6 @@ type CreatedNornAgentSessionInput = NornAgentRunnerInput & {
 	readonly label: string;
 	readonly cwd: string;
 	readonly session: AgentSession;
-	readonly resourceBindings: NornSessionResourceBindings;
 	readonly events: NornAgentSessionEvents;
 };
 
@@ -61,7 +57,7 @@ export class NornAgentRunner {
 	}
 
 	async createSession(agentInput: NornAgentCreateSessionInput): Promise<NornAgentSession> {
-		const cwd = agentInput.cwd ? this.resolveFromCwd(agentInput.cwd) : this.input.cwd;
+		const cwd = requireAbsoluteWorkingDirectory(agentInput.cwd);
 		const sessionDir = resolve(this.input.runRoot, "sessions");
 		await mkdir(sessionDir, { recursive: true });
 
@@ -82,19 +78,19 @@ export class NornAgentRunner {
 			...loader.getExtensions().errors.map(error => `Failed to load extension ${error.path}: ${error.error}`),
 		];
 		if (errors.length > 0) throw new Error(errors.join("\n"));
-		const resourceBindings = new NornSessionResourceBindings();
+		const customTools = agentInput.customTools ?? [];
+		assertCustomToolNames({
+			tools: customTools,
+			reservedNames: ["read", "bash", "edit", "write", "grep", "find", "ls", "powershell", AGENT_RESPONSE_TOOL_NAME,
+				...loader.getExtensions().extensions.flatMap((extension) => [...extension.tools.keys()])],
+		});
 		let session: AgentSession | undefined;
 		try {
-			await resourceBindings.bind({
-				adapters: agentInput.resourceAdapters ?? [], runId: this.input.id, label: agentInput.label,
-				reservedTools: ["read", "bash", "edit", "write", "grep", "find", "ls", "powershell", AGENT_RESPONSE_TOOL_NAME,
-					...loader.getExtensions().extensions.flatMap((extension) => [...extension.tools.keys()])],
-			});
 			({ session } = await createAgentSessionFromServices({
 				services,
 				sessionManager: SessionManager.create(cwd, sessionDir),
-				tools: [...withAgentResponseTool(agentInput.tools), ...resourceBindings.tools.map((tool) => tool.name)],
-				customTools: [this.responseToolFactory.create(), ...resourceBindings.tools],
+				tools: withAgentResponseTool(agentInput.tools),
+				customTools: [this.responseToolFactory.create(), ...customTools],
 				model: agentInput.model ?? this.input.model,
 				thinkingLevel: agentInput.thinkingLevel ?? this.input.thinkingLevel,
 			}));
@@ -102,13 +98,12 @@ export class NornAgentRunner {
 			await session.bindExtensions({});
 			await this.input.logger.record({ type: "agent.spawned", label: agentInput.label, cwd });
 			return new CreatedNornAgentSession({
-				...this.input, label: agentInput.label, cwd, session, resourceBindings, events: eventBus,
+				...this.input, label: agentInput.label, cwd, session, events: eventBus,
 			});
 		} catch (error) {
 			const errors = [error];
 			try { session?.dispose(); } catch (cleanupError) { errors.push(cleanupError); }
-			try { await resourceBindings.dispose(); } catch (cleanupError) { errors.push(cleanupError); }
-			if (errors.length > 1) throw new AggregateError(errors, "Agent creation and resource cleanup failed");
+			if (errors.length > 1) throw new AggregateError(errors, "Agent creation and cleanup failed");
 			throw error;
 		}
 	}
@@ -121,15 +116,6 @@ export class NornAgentRunner {
 			await agent.dispose();
 		}
 	}
-
-	private resolveFromCwd(path: string): string {
-		const resolvedPath = isAbsolute(path) ? path : resolve(this.input.cwd, path);
-		const pathFromBoundary = relative(this.input.boundaryRoot, resolvedPath);
-		if (pathFromBoundary === ".." || pathFromBoundary.startsWith(`..${sep}`) || isAbsolute(pathFromBoundary)) {
-			throw new Error(`Agent cwd escapes ${this.input.boundaryName} isolation: ${path}`);
-		}
-		return resolvedPath;
-	}
 }
 
 function systemPromptOverride(agentInput: NornAgentCreateSessionInput): (() => string) | undefined {
@@ -229,7 +215,6 @@ class CreatedNornAgentSession implements NornAgentSession {
 		const errors: unknown[] = [];
 		try { await this.input.session.abort(); } catch (error) { errors.push(error); }
 		try { this.input.session.dispose(); } catch (error) { errors.push(error); }
-		try { await this.input.resourceBindings.dispose(); } catch (error) { errors.push(error); }
 		if (errors.length) throw new AggregateError(errors, "Agent disposal failed");
 		await this.input.logger.record({ type: "agent.disposed", label: this.label });
 	}
@@ -360,7 +345,14 @@ function withResponseToolFinalizationInstruction(
 	].join("\n");
 }
 
-function withAgentResponseTool(tools: readonly string[] | undefined): string[] {
-	if (!tools) return [...DEFAULT_AGENT_TOOL_ALLOWLIST];
-	return Array.from(new Set([...tools, AGENT_RESPONSE_TOOL_NAME]));
+function withAgentResponseTool(tools: readonly string[] | undefined): string[] | undefined {
+	return tools === undefined ? undefined : Array.from(new Set([...tools, AGENT_RESPONSE_TOOL_NAME]));
+}
+
+function assertCustomToolNames(input: { readonly tools: readonly ToolDefinition[]; readonly reservedNames: readonly string[] }): void {
+	const names = new Set(input.reservedNames);
+	for (const tool of input.tools) {
+		if (names.has(tool.name)) throw new Error(`Custom tool name collision: ${tool.name}`);
+		names.add(tool.name);
+	}
 }

package/assets/packages/cli/src/internal/commands.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { requireAbsoluteWorkingDirectory } from "./working-directory.ts";
 import type { WriteStream } from "node:fs";
 import type { NornCommandRunInput, NornCommandRunResult, NornLogRef } from "@vimhead.dev/norn";
 import { errorMessage } from "./errors.ts";
@@ -9,9 +9,6 @@ import type { NornRunLogs } from "./logs.ts";
 import type { NornRunLogger } from "./run-log.ts";
 
 type NornCommandRunnerInput = {
-	readonly boundaryRoot: string;
-	readonly boundaryName: string;
-	readonly cwd: string;
 	readonly signal?: AbortSignal;
 	readonly logs: NornRunLogs;
 	readonly logger: NornRunLogger;
@@ -21,7 +18,7 @@ export class NornCommandRunner {
 	constructor(private readonly input: NornCommandRunnerInput) {}
 
 	async run(commandInput: NornCommandRunInput): Promise<NornCommandRunResult> {
-		const cwd = this.resolveFromCwd(commandInput.cwd ?? this.input.cwd);
+		const cwd = requireAbsoluteWorkingDirectory(commandInput.cwd);
 		const startedAtMs = Date.now();
 		const invocationId = randomUUID();
 		const stdoutRef = commandLog({ label: commandInput.label, invocationId, stream: "stdout" });
@@ -67,15 +64,6 @@ export class NornCommandRunner {
 		});
 		return commandResult;
 	}
-
-	private resolveFromCwd(path: string): string {
-		const resolvedPath = isAbsolute(path) ? path : resolve(this.input.cwd, path);
-		const pathFromBoundary = relative(this.input.boundaryRoot, resolvedPath);
-		if (pathFromBoundary === ".." || pathFromBoundary.startsWith(`..${sep}`) || isAbsolute(pathFromBoundary)) {
-			throw new Error(`Command cwd escapes ${this.input.boundaryName} isolation: ${path}`);
-		}
-		return resolvedPath;
-	}
 }
 
 type SpawnCommandInput = {