@vimhead.dev/norn-cli 0.1.0-tip.35390859630.1 → 0.1.0-tip.35436871363.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.35436871363.1",
+  "commit": "49b14d0ed0c9633fc6ee530a557ec7babbf52b22",
   "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 = {

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

@@ -7,20 +7,19 @@ import {
 	type NornRunNext,
 	type NornRunResult,
 	type NornRunStartOptions,
+	type NornWorkflowPaths,
 } from "@vimhead.dev/norn";
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { createRunFileCoordinator } from "./file-coordinator.ts";
 import { randomUUID } from "node:crypto";
 import { mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { Value } from "typebox/value";
 import { NornAgentResponseCollector } from "./agent-response-tool.ts";
-import { NornArtifacts } from "./artifacts.ts";
 import { errorMessage, NornRunStoppedError } from "./errors.ts";
 import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS, type NornRunResumeRequest } from "./launch-request.ts";
 import { NornRunLogs } from "./logs.ts";
 import { NornRunLease } from "./run-lease.ts";
 import { NornRunLogger } from "./run-log.ts";
-import { NornRunResources } from "../resources.ts";
 import { assertRunVersion, getRunInfo, mergeInterruptedWorkflowArgs, NornRunStateStore, resolveRunRoot, type NornRunState } from "./run-state.ts";
 import { NornRunStore, runCurrentRoot } from "./run-store.ts";
 import { NornRunContext } from "./run.ts";
@@ -40,7 +39,9 @@ export type NornEngineInput = {
 
 type RunSession = {
 	readonly runRoot: string;
+	readonly cwd: string;
 	readonly run: NornRunContext;
+	readonly paths: NornWorkflowPaths;
 	readonly state: NornRunStateStore;
 	readonly lease: NornRunLease;
 	readonly runStore: NornRunStore;
@@ -157,14 +158,14 @@ export class NornEngine {
 				const rawArgs = mergeInterruptedWorkflowArgs(current.args, args, current.interruption?.fields);
 				Value.Decode(workflow.args, rawArgs);
 				await session.state.replaceCurrentArgs(rawArgs);
-				await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
+				await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.cwd });
 				const resumedCurrent = session.state.currentState().current;
 				if (!resumedCurrent) throw new Error(`Run is not resumable: ${runRoot}`);
 				isLeaseOwnedByScheduler = true;
 				return this.runScheduler(session, toWorkflowStep(workflow, resumedCurrent));
 			}
 			if (state.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
-			await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
+			await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.cwd });
 			isLeaseOwnedByScheduler = true;
 			return this.runScheduler(session, toWorkflowStep(workflow, current));
 		} finally {
@@ -183,28 +184,27 @@ export class NornEngine {
 		try {
 			for (let step = 1; step <= 1_000; step++) {
 				throwIfRunAborted(session.activeRun);
-				const stepRuntime = session.run.forWorkflow(currentStep.workflow);
 				if (shouldPauseForGate(currentStep)) {
-					const description = await this.registry.describeGate(currentStep.workflow, stepRuntime, currentStep.args, session.state.currentState().configOverride);
+					const description = await this.registry.describeGate({ workflow: currentStep.workflow, run: session.run, paths: session.paths, args: currentStep.args, configOverride: session.state.currentState().configOverride });
 					const interruption = { description, fields: currentStep.workflow.gate?.fields };
 					await session.state.interruptCurrent(currentStep.args, interruption);
 					await recordRunEvent(session, { type: "run.interrupted", workflowId: currentStep.workflow.id });
 					await commitRunBoundary(session, `run interrupted: ${currentStep.workflow.id}`);
-					return interruptedLaunchResult({ id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd }, currentStep.workflow, currentStep.args, interruption);
+					return interruptedLaunchResult({ id: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd }, currentStep.workflow, currentStep.args, interruption);
 				}
 				await session.state.startStep(toRunStateStep(currentStep));
-				const stepResult = await this.executeWorkflowStep(session, currentStep, stepRuntime);
+				const stepResult = await this.executeWorkflowStep(session, currentStep);
 				throwIfRunAborted(session.activeRun);
 				if (stepResult.type === "complete") {
 					await session.state.completeRun(stepResult.workflow.id, stepResult.metadata);
 					await recordRunEvent(session, { type: "run.completed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
 					await commitRunBoundary(session, `run completed: ${stepResult.workflow.id}`);
-					return { status: "completed", id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+					return { status: "completed", id: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
 				}
 				if (stepResult.type === "fail") {
 					await session.state.failRun(stepResult.workflow.id, stepResult.metadata);
 					await recordRunEvent(session, { type: "run.failed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
-					return { status: "failed", id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+					return { status: "failed", id: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
 				}
 				const nextStep = this.nextWorkflowStep(stepResult);
 				await session.state.completeWithNext(currentStep.workflow.id, toRunStateStep(nextStep));
@@ -217,7 +217,7 @@ export class NornEngine {
 			if (isRunStopped(session, error)) {
 				await session.state.stopCurrent();
 				await recordRunEvent(session, { type: "run.stopped", workflowId: currentStep.workflow.id });
-				return { status: "stopped", id: session.run.id, name: session.state.currentState().name, workspace: session.run.workspace, cwd: session.run.cwd, workflowId: currentStep.workflow.id };
+				return { status: "stopped", id: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: currentStep.workflow.id };
 			}
 			await session.state.failCurrent(errorMessage(error));
 			await recordRunEvent(session, { type: "run.failed", workflowId: currentStep.workflow.id, error: errorMessage(error) });
@@ -228,13 +228,13 @@ export class NornEngine {
 		}
 	}
 
-	private async executeWorkflowStep(session: RunSession, step: WorkflowStep, run: NornRunContext): Promise<NornWorkflowStepResult> {
+	private async executeWorkflowStep(session: RunSession, step: WorkflowStep): Promise<NornWorkflowStepResult> {
 		const startedAtMs = Date.now();
 		try {
-			await assertWorkspaceBoundary(session, run.workspace);
+			await assertWorkspaceBoundary(session, session.paths.workspace);
 			await recordRunEvent(session, { type: "workflow.started", workflowId: step.workflow.id });
-			const result = await this.registry.execute(step.workflow, run, step.args, session.state.currentState().configOverride);
-			await assertWorkspaceBoundary(session, run.workspace);
+			const result = await this.registry.execute({ workflow: step.workflow, run: session.run, paths: session.paths, args: step.args, configOverride: session.state.currentState().configOverride });
+			await assertWorkspaceBoundary(session, session.paths.workspace);
 			const durationMs = Date.now() - startedAtMs;
 			if (result.type === "complete") await recordRunEvent(session, { type: "workflow.completed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
 			else if (result.type === "fail") await recordRunEvent(session, { type: "workflow.failed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
@@ -271,7 +271,8 @@ export class NornEngine {
 		const runRoot = defaultRunRoot(this.input.cwd, id);
 		const currentRoot = runCurrentRoot(runRoot);
 		const workspace = join(currentRoot, "workspace");
-		const cwd = workflowDefaultCwd(this.input.cwd, workspace, workflow);
+		const paths: NornWorkflowPaths = { project: resolve(this.input.cwd), workspace: workspace };
+		const cwd = process.cwd();
 		const startedAt = new Date().toISOString();
 		await mkdir(runRoot, { recursive: true });
 		const lease = await NornRunLease.acquire(runRoot);
@@ -288,8 +289,9 @@ export class NornEngine {
 				initialCwd: cwd,
 				startedAt,
 			} });
-			const run = await this.buildRun({ id, currentRoot, workspace, cwd, isolationMode: workflow.isolation.mode, signal: activeRun.controller.signal, logger });
+			const run = await this.buildRun({ id, currentRoot, paths, signal: activeRun.controller.signal, logger });
 			const state = await NornRunStateStore.create(runRoot, {
+				projectRoot: paths.project,
 				id,
 				name,
 				entrypointWorkflowId: workflow.id,
@@ -301,7 +303,7 @@ export class NornEngine {
 				},
 				startedAt,
 			});
-			const session = { runRoot, run, state, lease, runStore, logger, activeRun };
+			const session = { runRoot, cwd, run, paths, state, lease, runStore, logger, activeRun };
 			await logger.record({ type: "run.started", workflowId: workflow.id, cwd, workspace });
 			await commitRunBoundary(session, `run started: ${workflow.id}`);
 			return session;
@@ -321,11 +323,9 @@ export class NornEngine {
 			const runStore = await NornRunStore.open(runRoot);
 			const currentRoot = runCurrentRoot(runRoot);
 			const logger = await NornRunLogger.load(join(currentRoot, MANIFEST_FILE_NAME), createRunFileCoordinator(runRoot));
-			const workflow = currentState.current ? this.registry.workflowById(currentState.current.workflowId) : undefined;
-			const isolationMode = workflow?.isolation.mode ?? "runWorkspace";
-			const cwd = workflowDefaultCwd(this.input.cwd, currentState.workspace, workflow);
-			const run = await this.buildRun({ id: currentState.id, currentRoot, workspace: currentState.workspace, cwd, isolationMode, signal: activeRun.controller.signal, logger });
-			return { runRoot, run, state, lease, runStore, logger, activeRun };
+			const paths: NornWorkflowPaths = { project: currentState.projectRoot ?? resolve(runRoot, "../../.."), workspace: currentState.workspace };
+			const run = await this.buildRun({ id: currentState.id, currentRoot, paths, signal: activeRun.controller.signal, logger });
+			return { runRoot, cwd: process.cwd(), run, paths, state, lease, runStore, logger, activeRun };
 		} catch (error) {
 			this.failActiveRun(runRoot, activeRun);
 			throw error;
@@ -335,32 +335,22 @@ export class NornEngine {
 	private async buildRun(input: {
 		readonly id: string;
 		readonly currentRoot: string;
-		readonly workspace: string;
-		readonly cwd: string;
-		readonly isolationMode: "runWorkspace" | "project";
+		readonly paths: NornWorkflowPaths;
 		readonly signal: AbortSignal;
 		readonly logger: NornRunLogger;
 	}): Promise<NornRunContext> {
-		const artifactsRoot = join(input.currentRoot, "artifacts");
 		const logsRoot = join(input.currentRoot, "logs");
-		await mkdir(input.workspace, { recursive: true });
-		await mkdir(artifactsRoot, { recursive: true });
+		await mkdir(input.paths.workspace, { recursive: true });
 		await mkdir(logsRoot, { recursive: true });
-		const resources = await NornRunResources.initialize(dirname(input.currentRoot));
+		const files = createRunFileCoordinator(dirname(input.currentRoot));
 		return new NornRunContext({
 			id: input.id,
 			runRoot: input.currentRoot,
-			workspace: input.workspace,
-			projectRoot: this.input.cwd,
-			cwd: input.cwd,
-			isolationMode: input.isolationMode,
 			signal: input.signal,
 			agentDir: this.input.agentDir,
 			responseCollector: this.responseCollector,
-			resources,
 			logger: input.logger,
-			artifacts: new NornArtifacts(artifactsRoot, resources.files),
-			logs: new NornRunLogs(logsRoot, resources.files),
+			logs: new NornRunLogs(logsRoot, files),
 		});
 	}
 
@@ -400,11 +390,7 @@ export class NornEngine {
 }
 
 function defaultRunRoot(cwd: string, id: string): string {
-	return join(cwd, RUNS_DIR_NAME, "runs", id);
-}
-
-function workflowDefaultCwd(projectRoot: string, workspace: string, workflow: NornAnyWorkflowDeclaration | undefined): string {
-	return workflow?.isolation.mode === "project" ? projectRoot : workspace;
+	return join(resolve(cwd), RUNS_DIR_NAME, "runs", id);
 }
 
 function toWorkflowStep(workflow: NornAnyWorkflowDeclaration, step: NonNullable<NornRunState["current"]>): WorkflowStep {

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

@@ -1,6 +1,6 @@
 import { createWriteStream, type WriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { NornFileCoordinator } from "./file-coordinator.ts";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import type { NornLogRef } from "@vimhead.dev/norn";
 

package/assets/packages/cli/src/internal/run-log.ts

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { NornFileCoordinator } from "./file-coordinator.ts";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
 

package/assets/packages/cli/src/internal/run-state.ts

@@ -5,7 +5,7 @@ import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { readRunLaunchRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS } from "./launch-request.ts";
 import { getRunLeaseHealth } from "./run-lease.ts";
 import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
-import { createRunFileCoordinator, type NornFileCoordinator } from "@vimhead.dev/norn/files";
+import { createRunFileCoordinator, type NornFileCoordinator } from "./file-coordinator.ts";
 import { runCurrentRoot } from "./run-store.ts";
 import { jsonValueSchema } from "@vimhead.dev/norn/schema";
 import { Value } from "typebox/value";
@@ -59,6 +59,7 @@ type NornRunWorkflowOutcome = {
 
 export type NornRunState = {
 	readonly version: 1 | typeof RUN_STATE_VERSION;
+	readonly projectRoot?: string;
 	readonly id: string;
 	readonly name: string;
 	readonly entrypointWorkflowId: string;
@@ -74,6 +75,7 @@ export type NornRunState = {
 };
 
 type CreateNornRunStateInput = {
+	readonly projectRoot: string;
 	readonly id: string;
 	readonly name: string;
 	readonly entrypointWorkflowId: string;
@@ -101,7 +103,8 @@ export class NornRunStateStore {
 			id: input.id,
 			name: input.name,
 			entrypointWorkflowId: input.entrypointWorkflowId,
-			workspace: input.workspace,
+			projectRoot: resolve(input.projectRoot),
+			workspace: resolve(input.workspace),
 			configOverride: input.configOverride,
 			status: "running",
 			current: input.current,
@@ -252,6 +255,7 @@ export async function getRunInfo(runRoot: string): Promise<NornRunInfo> {
 			id: state.id,
 			name: state.name,
 			path: runRoot,
+			paths: { project: state.projectRoot ?? resolve(runRoot, "../../.."), workspace: state.workspace },
 			entrypointWorkflowId: state.entrypointWorkflowId,
 			currentWorkflowId: state.current?.workflowId,
 			status: resumeRequest ? "running" : state.status,
@@ -317,6 +321,7 @@ async function getLaunchedRunInfo(runRoot: string): Promise<NornRunInfo> {
 		id: launchRequest.id,
 		name: launchRequest.name,
 		path: runRoot,
+		paths: { project: resolve(runRoot, "../../.."), workspace: join(runCurrentRoot(resolve(runRoot)), "workspace") },
 		entrypointWorkflowId: launchRequest.workflowId,
 		currentWorkflowId: launchRequest.workflowId,
 		status: "running",

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

@@ -1,60 +1,38 @@
-import { isAbsolute, relative, resolve, sep } from "node:path";
 import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
-import type { NornAnyWorkflowDeclaration, NornProjectRun, NornRunOutcomeMetadata, NornWorkflowIsolationMode, NornRun } from "@vimhead.dev/norn";
+import type { NornRunOutcomeMetadata, NornRun } from "@vimhead.dev/norn";
 import { createWorkflowTransition } from "@vimhead.dev/norn-core/workflow-transition";
 import type { NornAgentResponseCollector } from "./agent-response-tool.ts";
-import type { NornArtifacts } from "./artifacts.ts";
 import { NornAgentRunner } from "./agents.ts";
 import { NornCommandRunner } from "./commands.ts";
 import type { NornRunLogs } from "./logs.ts";
 import type { NornRunLogger } from "./run-log.ts";
-import type { NornRunResources } from "../resources.ts";
 
 type DefaultNornRunInput = {
 	readonly id: string;
 	readonly runRoot: string;
-	readonly projectRoot: string;
-	readonly workspace: string;
-	readonly cwd: string;
-	readonly isolationMode: NornWorkflowIsolationMode;
 	readonly signal?: AbortSignal;
 	readonly model?: CreateAgentSessionOptions["model"];
 	readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
 	readonly agentDir?: string;
 	readonly responseCollector: NornAgentResponseCollector;
-	readonly resources: NornRunResources;
 	readonly logger: NornRunLogger;
-	readonly artifacts: NornArtifacts;
 	readonly logs: NornRunLogs;
 };
 
-export class NornRunContext implements NornProjectRun {
-	readonly resources: NornRunResources;
-	readonly artifacts: NornRun["artifacts"];
+export class NornRunContext implements NornRun {
 	readonly logs: NornRun["logs"];
 	readonly commands: NornRun["commands"];
 	readonly agents: NornRun["agents"];
 	readonly id: string;
-	readonly workspace: string;
-	readonly projectRoot: string;
-	readonly cwd: string;
 
 	constructor(private readonly input: DefaultNornRunInput) {
 		this.id = input.id;
-		this.workspace = input.workspace;
-		this.projectRoot = input.projectRoot;
-		this.cwd = input.cwd;
-		this.resources = input.resources;
-		this.artifacts = input.artifacts;
 		this.logs = {
 			read: (log) => this.input.logs.read(log),
 		};
 		this.commands = {
 			run: (commandInput) =>
 				new NornCommandRunner({
-					boundaryRoot: this.boundaryRoot,
-					boundaryName: this.input.isolationMode,
-					cwd: this.cwd,
 					signal: this.input.signal,
 					logs: this.input.logs,
 					logger: this.input.logger,
@@ -66,26 +44,10 @@ export class NornRunContext implements NornProjectRun {
 		};
 	}
 
-	forWorkflow(workflow: NornAnyWorkflowDeclaration): NornRunContext {
-		const isolationMode = workflow.isolation.mode;
-		return new NornRunContext({
-			...this.input,
-			isolationMode,
-			cwd: isolationMode === "project" ? this.projectRoot : this.workspace,
-		});
-	}
-
-	private get boundaryRoot(): string {
-		return this.input.isolationMode === "project" ? this.projectRoot : this.workspace;
-	}
-
 	private createAgentRunner(): NornAgentRunner {
 		return new NornAgentRunner({
 			id: this.id,
 			runRoot: this.input.runRoot,
-			boundaryRoot: this.boundaryRoot,
-			boundaryName: this.input.isolationMode,
-			cwd: this.cwd,
 			signal: this.input.signal,
 			model: this.input.model,
 			thinkingLevel: this.input.thinkingLevel,
@@ -96,14 +58,6 @@ export class NornRunContext implements NornProjectRun {
 		});
 	}
 
-	path(relativePath: string): string {
-		return this.resolveFromRoot(this.cwd, this.boundaryRoot, relativePath);
-	}
-
-	projectPath(relativePath: string): string {
-		return this.resolveFromRoot(this.projectRoot, this.projectRoot, relativePath);
-	}
-
 	next(workflowId: string, args: unknown): ReturnType<NornRun["next"]> {
 		return createWorkflowTransition({ workflowId, args });
 	}
@@ -115,13 +69,4 @@ export class NornRunContext implements NornProjectRun {
 	fail(metadata: NornRunOutcomeMetadata & { readonly summary: string }): ReturnType<NornRun["fail"]> {
 		return { type: "fail", metadata };
 	}
-
-	private resolveFromRoot(root: string, boundaryRoot: string, path: string): string {
-		const resolvedPath = isAbsolute(path) ? path : resolve(root, path);
-		const pathFromBoundary = relative(boundaryRoot, resolvedPath);
-		if (pathFromBoundary === ".." || pathFromBoundary.startsWith(`..${sep}`) || isAbsolute(pathFromBoundary)) {
-			throw new Error(`Workflow path escapes ${this.input.isolationMode} isolation: ${path}`);
-		}
-		return resolvedPath;
-	}
 }

package/assets/packages/cli/src/internal/worker-directory.ts

@@ -0,0 +1,17 @@
+import { chmod, lstat, mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { isNodeError } from "@vimhead.dev/norn-core/errors";
+
+export async function prepareRunWorkerDirectory(runRoot: string): Promise<string> {
+	const directory = join(runRoot, "worker");
+	try {
+		await mkdir(directory, { mode: 0o555 });
+	} catch (error) {
+		if (!isNodeError(error) || error.code !== "EEXIST") throw error;
+	}
+	const metadata = await lstat(directory);
+	if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw new Error(`Run worker cwd must be a directory, not a symlink: ${directory}`);
+	if ((await readdir(directory)).length !== 0) throw new Error(`Run worker cwd must be empty: ${directory}`);
+	await chmod(directory, 0o555);
+	return directory;
+}