@vimhead.dev/norn-cli 0.1.0-tip.35390859630.1 → 0.1.0-tip.35568631545.1

package/assets/examples/worktree-development-loop/README.md

@@ -9,8 +9,8 @@ is a single-step starting point.
 It registers an entrypoint workflow named **Workspace development loop**. The
 workflow:
 
-1. clones the configured repository into `run.workspace/repo`;
-2. passes the repository path and retained artifact references through workflow arguments;
+1. clones the configured repository into `paths.workspace/repo`;
+2. passes the repository path and retained file paths through workflow arguments;
 3. passes explicit cwd values to agents and commands;
 4. plans once, then loops through implementation and automated review;
 5. routes automated review through a gated review router;
@@ -62,13 +62,14 @@ norn runs inspect "$RUN"
 After planning, implementation, and automated review succeed, expect
 `run.status: interrupted` at `worktreeDevelopmentLoop.reviewRouter`, **not** a
 completed run. Inspection exposes the iteration, proposed decision, summary, and
-automated-review artifact in `run.interruption.args`. A command or agent failure
+`automatedReviewPath` in `run.interruption.args`. A command or agent failure
 can end the run before this gate; inspect the failure instead of attempting approval.
 
 ## Review and resume
 
-For the interrupted iteration `N`, inspect these files under
-`.norn/runs/$RUN/current/artifacts/`:
+The example's file and repository paths are relative to `run.paths.workspace`,
+reported by run inspection. For the interrupted iteration `N`, inspect these files
+in that directory:
 
 - `planning/plan.md` — the saved plan.
 - `implementation/iteration-N-status.txt` — recorded Git status.
@@ -78,8 +79,9 @@ For the interrupted iteration `N`, inspect these files under
 Inspect the actual clone as well:
 
 ```bash
-git -C ".norn/runs/$RUN/current/workspace/repo" status --short
-git -C ".norn/runs/$RUN/current/workspace/repo" diff HEAD -- .
+WORKSPACE=<run.paths.workspace-from-inspection>
+git -C "$WORKSPACE/repo" status --short
+git -C "$WORKSPACE/repo" diff HEAD -- .
 ```
 
 Check new files, any commits made since the selected base revision, and evidence
@@ -112,12 +114,12 @@ resume input and protected fields.
 
 After acceptance, expect `run.status: completed`, `run.health: healthy`, and
 `run.outcome.workflowId: worktreeDevelopmentLoop.reviewRouter`. Outcome metadata
-includes plan/review artifact refs and data with `status: done`,
-`repositoryPath: "repo"`, and the iteration count. The review ref points to
-`review/iteration-N-decision.json`, retaining the chosen decision and automated
-review ref.
+includes `data.planPath`, `data.reviewPath`, `data.status: done`,
+`data.repositoryPath: "repo"`, and the iteration count. The review file is
+`review/iteration-N-decision.json`, retaining the chosen decision and
+`automatedReviewPath`.
 
-The resulting repository is `.norn/runs/$RUN/current/workspace/repo`. There is no
+The resulting repository is `repo` inside the inspected `run.paths.workspace`. There is no
 automatic step to merge, push, or copy its changes back to the original repository;
 retain or transfer the wanted changes before deleting the run. This workspace is
 [not a filesystem sandbox](../../docs/persistence.md#filesystem-boundaries).

package/assets/examples/worktree-development-loop/scope.ts

@@ -1,4 +1,4 @@
 import { workflowScope } from "@vimhead.dev/norn";
 import { developmentLoopConfigSchema } from "./workflows/development-loop/schema.ts";
 
-export const developmentLoopScope = workflowScope({ id: "worktreeDevelopmentLoop", config: developmentLoopConfigSchema });
+export const developmentLoopScope = workflowScope({ name: "worktreeDevelopmentLoop", config: developmentLoopConfigSchema });

package/assets/examples/worktree-development-loop/workflows/development-loop/execute.ts

@@ -5,12 +5,12 @@ import { developmentLoopArgsSchema } from "./schema.ts";
 import { materializeWorkspaceRepository } from "./repository.ts";
 
 export const developmentLoopWorkflow = developmentLoopScope.workflow({
-	id: "developmentLoop",
+	name: "developmentLoop",
 	isEntrypoint: true,
 	instructions: "Plan once, then loop implementation and review in a workspace repository copy. Call this when a repository task should run through planning, implementation, and review.",
 	args: developmentLoopArgsSchema,
-	async execute({ args, scope, run }): Promise<WorkflowResult> {
-		const repositoryPath = await materializeWorkspaceRepository(run, scope.config.repositoryRoot, args.baseRef);
+	async execute({ args, scope, paths, commands }): Promise<WorkflowResult> {
+		const repositoryPath = await materializeWorkspaceRepository({ commands, paths, repositoryRoot: scope.config.repositoryRoot, baseRef: args.baseRef });
 
 		return planningWorkflow({ task: args.task, repositoryPath, maxIterations: args.maxIterations });
 	}

package/assets/examples/worktree-development-loop/workflows/development-loop/repository.ts

@@ -1,12 +1,14 @@
-import type { NornRun } from "@vimhead.dev/norn";
+import { join } from "node:path";
+import type { NornCommands, NornWorkflowPaths } from "@vimhead.dev/norn";
 import { ensureCommandSucceeded } from "../../shared/commands.ts";
 
 const WORKSPACE_REPOSITORY_PATH = "repo";
 
-export async function materializeWorkspaceRepository(run: NornRun, repositoryRoot: string, baseRef: string): Promise<string> {
-	const repositoryPath = run.path(WORKSPACE_REPOSITORY_PATH);
-	const result = await run.commands.run({
+export async function materializeWorkspaceRepository({ commands, paths, repositoryRoot, baseRef }: { commands: NornCommands; paths: NornWorkflowPaths; repositoryRoot: string; baseRef: string }): Promise<string> {
+	const repositoryPath = join(paths.workspace, WORKSPACE_REPOSITORY_PATH);
+	const result = await commands.run({
 		label: "materialize-workspace-repository",
+		cwd: paths.workspace,
 		command: [
 			`rm -rf ${shellQuote(repositoryPath)}`,
 			`git clone --no-checkout ${shellQuote(repositoryRoot)} ${shellQuote(repositoryPath)}`,

package/assets/examples/worktree-development-loop/workflows/implementation/execute.ts

@@ -1,3 +1,5 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { reviewWorkflow } from "../review/execute.ts";
 import type { WorkflowResult } from "@vimhead.dev/norn";
 import { developmentLoopScope } from "../../scope.ts";
@@ -6,31 +8,30 @@ import { ensureCommandSucceeded } from "../../shared/commands.ts";
 import { implementationAgentResponseSchema } from "./schema.ts";
 
 export const implementationWorkflow = developmentLoopScope.workflow({
-	id: "implementation",
+	name: "implementation",
 	isEntrypoint: false,
 	instructions: "Apply one implementation pass in the current repository.",
 	args: implementationArgsSchema,
-	async execute({ args, run }): Promise<WorkflowResult> {
-		const repositoryPath = args.repositoryPath;
-		const planArtifact = args.planArtifact;
-		const plan = await run.artifacts.read(planArtifact);
-		const previousReviewArtifact = args.previousReviewArtifact;
-		const previousReview = previousReviewArtifact ? await run.artifacts.read(previousReviewArtifact) : undefined;
-		const implementation = await run.agents.prompt({
+	async execute({ args, paths, agents, commands, logs }): Promise<WorkflowResult> {
+		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
+		const plan = await readFile(join(paths.workspace, args.planPath), "utf8");
+		const previousReview = args.previousReviewPath ? await readFile(join(paths.workspace, args.previousReviewPath), "utf8") : undefined;
+		const implementation = await agents.prompt({
 			label: `implementation-${args.iteration}`,
 			cwd: repositoryPath,
 			tools: ["read", "grep", "find", "ls", "edit", "write", "bash"],
 			prompt: buildImplementationPrompt(args.task, plan, args.iteration, previousReview),
 			response: implementationAgentResponseSchema,
 		});
-		const status = await run.commands.run({
+		const status = await commands.run({
 			label: `implementation-${args.iteration}-status`,
 			cwd: repositoryPath,
 			command: "git status --short",
 		});
 		await ensureCommandSucceeded(status);
-		const statusOutput = await run.logs.read(status.stdoutLog);
-		await run.artifacts.write(`implementation/iteration-${args.iteration}-status.txt`, statusOutput);
+		const statusOutput = await logs.read(status.stdoutLog);
+		await mkdir(join(paths.workspace, "implementation"), { recursive: true });
+		await writeFile(join(paths.workspace, `implementation/iteration-${args.iteration}-status.txt`), statusOutput);
 		return reviewWorkflow({ ...args, implementationSummary: implementation.summary });
 	}
 });

package/assets/examples/worktree-development-loop/workflows/implementation/schema.ts

@@ -1,12 +1,11 @@
-import { artifactRefSchema } from "@vimhead.dev/norn";
 import { planningArgsSchema } from "../planning/schema.ts";
 import { Type, type StaticDecode } from "typebox";
 
 export const implementationArgsSchema = Type.Object({
 	...planningArgsSchema.properties,
 	iteration: Type.Integer({ minimum: 1 }),
-	planArtifact: artifactRefSchema,
-	previousReviewArtifact: Type.Optional(artifactRefSchema),
+	planPath: Type.String(),
+	previousReviewPath: Type.Optional(Type.String()),
 });
 
 export const implementationAgentResponseSchema = Type.Object({

package/assets/examples/worktree-development-loop/workflows/planning/execute.ts

@@ -1,3 +1,5 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { implementationWorkflow } from "../implementation/execute.ts";
 import type { WorkflowResult } from "@vimhead.dev/norn";
 import { developmentLoopScope } from "../../scope.ts";
@@ -5,21 +7,23 @@ import { planningArgsSchema } from "./schema.ts";
 import { planningAgentResponseSchema } from "./schema.ts";
 
 export const planningWorkflow = developmentLoopScope.workflow({
-	id: "planning",
+	name: "planning",
 	isEntrypoint: false,
 	instructions: "Create an implementation plan for a repository task.",
 	args: planningArgsSchema,
-	async execute({ args, run }): Promise<WorkflowResult> {
-		const repositoryPath = args.repositoryPath;
-		const planning = await run.agents.prompt({
+	async execute({ args, paths, agents }): Promise<WorkflowResult> {
+		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
+		const planning = await agents.prompt({
 			label: "planning",
 			cwd: repositoryPath,
 			tools: ["read", "grep", "find", "ls"],
 			prompt: buildPlanningPrompt(args.task),
 			response: planningAgentResponseSchema,
 		});
-		const planArtifact = await run.artifacts.write("planning/plan.md", planning.plan);
-		return implementationWorkflow({ ...args, planArtifact, iteration: 1 });
+		const planPath = "planning/plan.md";
+		await mkdir(join(paths.workspace, "planning"), { recursive: true });
+		await writeFile(join(paths.workspace, planPath), planning.plan);
+		return implementationWorkflow({ ...args, planPath, iteration: 1 });
 	}
 });
 

package/assets/examples/worktree-development-loop/workflows/review/execute.ts

@@ -1,3 +1,5 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { reviewRouterWorkflow } from "../review-router/execute.ts";
 import type { WorkflowResult } from "@vimhead.dev/norn";
 import { developmentLoopScope } from "../../scope.ts";
@@ -6,37 +8,38 @@ import { ensureCommandSucceeded } from "../../shared/commands.ts";
 import { reviewAgentResponseSchema } from "./schema.ts";
 
 export const reviewWorkflow = developmentLoopScope.workflow({
-	id: "review",
+	name: "review",
 	isEntrypoint: false,
 	instructions: "Review the current repository boundary changes.",
 	args: reviewArgsSchema,
-	async execute({ args, run }): Promise<WorkflowResult> {
-		const repositoryPath = args.repositoryPath;
-		const planArtifact = args.planArtifact;
+	async execute({ args, paths, agents, commands, logs }): Promise<WorkflowResult> {
+		const repositoryPath = resolve(paths.workspace, args.repositoryPath);
 		const implementationSummary = args.implementationSummary;
-		const plan = await run.artifacts.read(planArtifact);
-		const diff = await run.commands.run({
+		const plan = await readFile(join(paths.workspace, args.planPath), "utf8");
+		const diff = await commands.run({
 			label: `review-${args.iteration}-diff`,
 			cwd: repositoryPath,
 			command: "git status --short && git diff --stat HEAD -- . && git diff HEAD -- .",
 		});
 		await ensureCommandSucceeded(diff);
-		const diffOutput = await run.logs.read(diff.stdoutLog);
-		await run.artifacts.write(`review/iteration-${args.iteration}-diff.txt`, diffOutput);
-		const review = await run.agents.prompt({
+		const diffOutput = await logs.read(diff.stdoutLog);
+		await mkdir(join(paths.workspace, "review"), { recursive: true });
+		await writeFile(join(paths.workspace, `review/iteration-${args.iteration}-diff.txt`), diffOutput);
+		const review = await agents.prompt({
 			label: `review-${args.iteration}`,
 			cwd: repositoryPath,
 			tools: ["read", "grep", "find", "ls", "bash"],
 			prompt: buildReviewPrompt(args.task, plan, implementationSummary, diffOutput),
 			response: reviewAgentResponseSchema,
 		});
-		const automatedReviewArtifact = await run.artifacts.write(`review/iteration-${args.iteration}-automated.json`, JSON.stringify(review, null, 2));
+		const automatedReviewPath = `review/iteration-${args.iteration}-automated.json`;
+		await writeFile(join(paths.workspace, automatedReviewPath), JSON.stringify(review, null, 2));
 		return reviewRouterWorkflow({
 			...args,
 			iteration: args.iteration,
 			decision: review.decision,
 			summary: review.summary,
-			automatedReviewArtifact,
+			automatedReviewPath,
 		});
 	}
 });

package/assets/examples/worktree-development-loop/workflows/review/schema.ts

@@ -1,5 +1,4 @@
 import { implementationArgsSchema } from "../implementation/schema.ts";
-import { artifactRefSchema } from "@vimhead.dev/norn";
 import { Type, type StaticDecode } from "typebox";
 
 export const reviewDecisionSchema = Type.Enum(["accept", "revise", "blocked"]);
@@ -17,7 +16,7 @@ export const reviewAgentResponseSchema = Type.Object({
 export const storedReviewSchema = Type.Object({
 	decision: reviewDecisionSchema,
 	summary: Type.String(),
-	reviewArtifact: artifactRefSchema,
+	reviewPath: Type.String(),
 });
 
 export type ReviewArgs = StaticDecode<typeof reviewArgsSchema>;

package/assets/examples/worktree-development-loop/workflows/review-router/execute.ts

@@ -1,3 +1,5 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import { implementationWorkflow } from "../implementation/execute.ts";
 import type { WorkflowResult } from "@vimhead.dev/norn";
 import { developmentLoopScope } from "../../scope.ts";
@@ -5,52 +7,51 @@ import { reviewRouterArgsSchema } from "./schema.ts";
 import type { StoredReview } from "../review/schema.ts";
 
 export const reviewRouterWorkflow = developmentLoopScope.workflow({
-	id: "reviewRouter",
+	name: "reviewRouter",
 	isEntrypoint: false,
 	instructions: "Route implementation and review iterations based on the latest review decision.",
 	gate: {
 		enabled: true,
-		describe: ({ args }) => `Review iteration ${args.iteration}. Confirm or edit the automated decision before continuing. Plan: ${args.planArtifact.path}.`,
+		describe: ({ args }) => `Review iteration ${args.iteration}. Confirm or edit the automated decision before continuing. Plan: ${args.planPath}.`,
 		fields: ["decision", "summary"] as const,
 	},
 	args: reviewRouterArgsSchema,
-	async execute({ args, run }): Promise<WorkflowResult> {
+	async execute({ args, paths, run }): Promise<WorkflowResult> {
 		const repositoryPath = args.repositoryPath;
-		const planArtifact = args.planArtifact;
+		const planPath = args.planPath;
 		const currentIteration = args.iteration;
 		const maxIterations = args.maxIterations;
 		const task = args.task;
-		const reviewArtifact = await run.artifacts.write(
-			`review/iteration-${args.iteration}-decision.json`,
-			JSON.stringify({ decision: args.decision, summary: args.summary, automatedReviewArtifact: args.automatedReviewArtifact }, null, 2),
+		const reviewPath = `review/iteration-${args.iteration}-decision.json`;
+		await mkdir(join(paths.workspace, "review"), { recursive: true });
+		await writeFile(
+			join(paths.workspace, reviewPath),
+			JSON.stringify({ decision: args.decision, summary: args.summary, automatedReviewPath: args.automatedReviewPath }, null, 2),
 		);
-		const lastReview: StoredReview = { decision: args.decision, summary: args.summary, reviewArtifact };
+		const lastReview: StoredReview = { decision: args.decision, summary: args.summary, reviewPath };
 
 		if (args.decision === "accept") {
 			return run.complete({
 				summary: `Implementation accepted after ${currentIteration} iteration(s).`,
-				artifacts: { plan: planArtifact, review: reviewArtifact },
-				data: { status: "done", repositoryPath, iterations: currentIteration, lastReview },
+				data: { status: "done", repositoryPath, planPath, reviewPath, iterations: currentIteration, lastReview },
 			});
 		}
 
 		if (args.decision === "blocked") {
 			return run.fail({
 				summary: args.summary,
-				artifacts: { plan: planArtifact, review: reviewArtifact },
-				data: { status: "blocked", repositoryPath, iterations: currentIteration, lastReview },
+				data: { status: "blocked", repositoryPath, planPath, reviewPath, iterations: currentIteration, lastReview },
 			});
 		}
 
 		if (currentIteration >= maxIterations) {
 			return run.fail({
 				summary: `Maximum iteration count reached after ${currentIteration} iteration(s).`,
-				artifacts: { plan: planArtifact, review: reviewArtifact },
-				data: { status: "needs-attention", repositoryPath, iterations: currentIteration, lastReview },
+				data: { status: "needs-attention", repositoryPath, planPath, reviewPath, iterations: currentIteration, lastReview },
 			});
 		}
 
 		const nextIteration = currentIteration + 1;
-		return implementationWorkflow({ task, repositoryPath, maxIterations, planArtifact, iteration: nextIteration, previousReviewArtifact: reviewArtifact });
+		return implementationWorkflow({ task, repositoryPath, maxIterations, planPath, iteration: nextIteration, previousReviewPath: reviewPath });
 	}
 });

package/assets/examples/worktree-development-loop/workflows/review-router/schema.ts

@@ -1,5 +1,4 @@
 import { implementationArgsSchema } from "../implementation/schema.ts";
-import { artifactRefSchema } from "@vimhead.dev/norn";
 import { Type, type StaticDecode } from "typebox";
 import { reviewDecisionSchema } from "../review/schema.ts";
 
@@ -7,7 +6,7 @@ export const reviewRouterArgsSchema = Type.Object({
 	...implementationArgsSchema.properties,
 	decision: reviewDecisionSchema,
 	summary: Type.String(),
-	automatedReviewArtifact: artifactRefSchema,
+	automatedReviewPath: Type.String(),
 });
 
 export type ReviewRouterArgs = StaticDecode<typeof reviewRouterArgsSchema>;

package/assets/package.json

@@ -1 +1 @@
-{"version":"0.1.0-tip.35390859630.1"}
+{"version":"0.1.0-tip.35568631545.1"}

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

@@ -12,6 +12,7 @@ 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";
@@ -19,6 +20,7 @@ import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.ts";
 import { generateRunName } from "./internal/run-names.ts";
 import { assertRunVersion, getRunInfo, listRuns, mergeInterruptedWorkflowArgs, resolveRunRoot } from "./internal/run-state.ts";
 import { NornRunStore } from "./internal/run-store.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");
@@ -784,7 +786,7 @@ async function startRun(workflowId: string, commandArgs: readonly string[]): Pro
 	const createdAt = new Date().toISOString();
 	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> {
@@ -899,8 +901,10 @@ 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 });
+		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);
@@ -1000,6 +1004,7 @@ function detachedExecuteRunArgs(runId: string): readonly string[] {
 }
 
 function startedRunInfo(input: {
+	readonly projectRoot: string;
 	readonly id: string;
 	readonly name: string;
 	readonly workflow: NornAnyWorkflowDeclaration;
@@ -1011,6 +1016,7 @@ function startedRunInfo(input: {
 		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",

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.35390859630.1",
-  "commit": "7a7976170d62c342c29c6479444394d542c3f22b",
+  "version": "0.1.0-tip.35568631545.1",
+  "commit": "f16f4b16ede3d325d56cdbd1f21193b3a3d45d38",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

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 = {