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

package/assets/packages/cli/src/internal/workflow-registry.ts

@@ -1,4 +1,4 @@
-import { isWorkflowComplete, isWorkflowDeclaration, isWorkflowFail, isWorkflowNext, type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRunFor, type NornRunNext, type NornWorkflowContext, type NornWorkflowGateInfo, type NornWorkflowSource, type NornWorkflowScopeInfo, type NornProjectConfigurationInfo } from "@vimhead.dev/norn";
+import { isWorkflowComplete, isWorkflowDeclaration, isWorkflowFail, isWorkflowNext, type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRun, type NornRunNext, type NornWorkflowPaths, type NornWorkflowContext, type NornWorkflowGateInfo, type NornWorkflowSource, type NornWorkflowScopeInfo, type NornProjectConfigurationInfo } from "@vimhead.dev/norn";
 import { assertWorkflowMetadata, inspectSchema, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
 import type { TSchema } from "typebox";
 import { Value } from "typebox/value";
@@ -42,6 +42,15 @@ export type NornWorkflowStepResult =
 	| { readonly type: "complete"; readonly workflow: NornAnyWorkflowDeclaration; readonly metadata?: NornRunComplete["metadata"] }
 	| { readonly type: "fail"; readonly workflow: NornAnyWorkflowDeclaration; readonly metadata: NornRunFail["metadata"] };
 
+type NornExecutionContextInput = {
+	readonly run: NornRun;
+	readonly paths: NornWorkflowPaths;
+	readonly args: unknown;
+	readonly configOverride: unknown;
+};
+
+type NornWorkflowExecutionInput = NornExecutionContextInput & { readonly workflow: NornAnyWorkflowDeclaration };
+
 export class NornWorkflowRegistry {
 	private readonly entries = new Map<string, NornRegisteredWorkflow>();
 	private readonly scopes = new Map<string, NornRegisteredScope>();
@@ -99,31 +108,34 @@ export class NornWorkflowRegistry {
 	launchableEntries(): NornRegisteredWorkflow[] { return this.sortedEntries().filter(({ workflow }) => workflow.isEntrypoint); }
 	workflowById(workflowId: string): NornAnyWorkflowDeclaration | undefined { return this.entries.get(workflowId)?.workflow; }
 
-	async describeGate<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<string> {
+	async describeGate(input: NornWorkflowExecutionInput): Promise<string> {
+		const { workflow } = input;
 		const entry = this.requireEntry(workflow.id);
 		if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
-		const context = this.createExecutionContext({ entry, run, args, configOverride });
+		const context = this.createExecutionContext({ ...input, entry });
 		const description = await entry.workflow.gate?.describe?.(context) ?? workflow.id;
 		if (typeof description !== "string" || description.trim().length === 0) throw new Error(`Workflow gate description must not be empty: ${workflow.id}`);
 		return description.trim();
 	}
 
-	async execute<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<NornWorkflowStepResult> {
+	async execute(input: NornWorkflowExecutionInput): Promise<NornWorkflowStepResult> {
+		const { workflow } = input;
 		const entry = this.requireEntry(workflow.id);
-		const result = await entry.workflow.execute(this.createExecutionContext({ entry, run, args, configOverride }));
+		const result = await entry.workflow.execute(this.createExecutionContext({ ...input, entry }));
 		if (isWorkflowNext(result)) return result;
 		if (isWorkflowComplete(result)) return { type: "complete", workflow, metadata: result.metadata };
 		if (isWorkflowFail(result)) return { type: "fail", workflow, metadata: result.metadata };
 		throw new Error(`Workflow returned invalid control result: ${workflow.id}`);
 	}
 
-	private createExecutionContext(input: { readonly entry: NornRegisteredWorkflow; readonly run: NornRunFor<NornAnyWorkflowDeclaration>; readonly args: unknown; readonly configOverride: unknown }): NornWorkflowContext {
-		const { entry, run, configOverride } = input;
+	private createExecutionContext(input: NornExecutionContextInput & { readonly entry: NornRegisteredWorkflow }): NornWorkflowContext {
+		const { entry, run, paths, configOverride } = input;
 		const scope = entry.scopeId ? this.scopes.get(entry.scopeId) : undefined;
 		return {
 			args: Value.Decode(entry.workflow.args, input.args),
 			config: parseExecutionConfig(entry.configuration, configOverride),
 			...(scope ? { scope: { id: scope.definition.id, config: parseExecutionConfig(scope.configuration, configOverride) } } : {}),
+			paths,
 			run,
 		};
 	}
@@ -175,7 +187,7 @@ function assertGateWorkflow(workflow: NornAnyWorkflowDeclaration): void {
 function workflowInfo(entry: NornRegisteredWorkflow): NornRegisteredWorkflowInfo {
 	return {
 		id: entry.workflow.id, instructions: entry.workflow.instructions, isEntrypoint: entry.workflow.isEntrypoint,
-		isolation: entry.workflow.isolation, source: entry.source,
+		source: entry.source,
 		configKey: entry.workflow.id,
 		scope: entry.scopeId ? { id: entry.scopeId } : undefined,
 	};

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

@@ -0,0 +1,6 @@
+import { isAbsolute, resolve } from "node:path";
+
+export function requireAbsoluteWorkingDirectory(cwd: string): string {
+	if (typeof cwd !== "string" || !isAbsolute(cwd)) throw new Error("Working directory (cwd) must be an absolute path");
+	return resolve(cwd);
+}

package/assets/packages/cli/src/workflow-loader.ts

@@ -1,7 +1,6 @@
 import * as nornModule from "@vimhead.dev/norn";
 import { isWorkflowDeclaration, type NornAnyWorkflowDeclaration, type NornDispose, type NornWorkflowDiagnostic, type NornProjectInfo, type NornProjectInspection, type NornProjectConfigurationInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowSource } from "@vimhead.dev/norn";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
-import * as nornFilesModule from "@vimhead.dev/norn/files";
 import * as nornSchemaModule from "@vimhead.dev/norn/schema";
 import { inspectSchema, isPlainObject } from "@vimhead.dev/norn/schema";
 import { createJiti, type ModuleCache } from "jiti/static";
@@ -178,7 +177,7 @@ function createDiagnostic(input: { readonly source: NornWorkflowSource; readonly
 	return { configPath: input.source.configPath, modulePath: input.source.path, scopeId: input.scopeId, workflowId: input.workflowId, stage: input.stage, message: errorMessage(input.error), issues: input.error instanceof AssertError ? input.error.cause.errors : [] };
 }
 function nornWorkflowVirtualModules(): Record<string, unknown> {
-	return { "@vimhead.dev/norn": nornModule, "@vimhead.dev/norn/files": nornFilesModule, "@vimhead.dev/norn/schema": nornSchemaModule, typebox: typeboxModule, "typebox/value": typeboxValueModule, "typebox/compile": typeboxCompileModule, "typebox/schema": typeboxSchemaModule };
+	return { "@vimhead.dev/norn": nornModule, "@vimhead.dev/norn/schema": nornSchemaModule, typebox: typeboxModule, "typebox/value": typeboxValueModule, "typebox/compile": typeboxCompileModule, "typebox/schema": typeboxSchemaModule };
 }
 function mergeProjectConfig(files: readonly NornConfigFile[]): Record<string, unknown> {
 	const [project, ...reusable] = files;

package/assets/packages/sdk/src/api.ts

@@ -1,4 +1,4 @@
-import type { CreateAgentSessionOptions, EventBus, PromptOptions } from "@earendil-works/pi-coding-agent";
+import type { CreateAgentSessionOptions, EventBus, PromptOptions, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type, type StaticDecode, type StaticEncode, type TCodec, type TSchema } from "typebox";
 import type { TLocalizedValidationError } from "typebox/error";
 import { createWorkflowTransition } from "@vimhead.dev/norn-core/workflow-transition";
@@ -15,16 +15,17 @@ export type NornWorkflowAnyGate = {
 	readonly fields?: readonly string[];
 };
 
-export type NornWorkflowIsolationMode = "runWorkspace" | "project";
+export type NornWorkflowPaths = {
+	/** Absolute project root. Excluded from run checkpoints and rollback. */
+	readonly project: string;
 
-export type NornWorkflowIsolation<Mode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
-	readonly mode: Mode;
+	/** Absolute, initially empty workspace. Saved in run checkpoints and restored on rollback. */
+	readonly workspace: string;
 };
 
 export type NornWorkflowDeclaration<
 	Id extends string = string,
 	ArgsSchema extends TSchema = TSchema,
-	IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode,
 	ConfigSchema extends TSchema | undefined = TSchema | undefined,
 	Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined,
 > = {
@@ -35,12 +36,11 @@ export type NornWorkflowDeclaration<
 	readonly instructions?: string;
 	readonly args: ArgsSchema;
 	readonly gate?: NornWorkflowGate<ArgsSchema> & {
-		describe?(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<string>;
+		describe?(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<string>;
 	};
-	readonly isolation: NornWorkflowIsolation<IsolationMode>;
 	readonly config?: ConfigSchema;
 	readonly scope: Scope;
-	execute(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
+	execute(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
 };
 
 export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((args: never) => NornRunNext);
@@ -69,18 +69,17 @@ type NornWorkflowInstructions =
 	| { readonly isEntrypoint: true; readonly instructions: string }
 	| { readonly isEntrypoint: false; readonly instructions?: string };
 
-type RunForIsolation<Mode extends NornWorkflowIsolationMode> = Mode extends "project" ? NornProjectRun : NornRun;
 type WorkflowConfig<Schema extends TSchema | undefined> = Schema extends TSchema ? StaticDecode<Schema> : undefined;
 
 export type NornWorkflowContext<
 	ArgsSchema extends TSchema = TSchema,
-	Mode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode,
 	ConfigSchema extends TSchema | undefined = TSchema | undefined,
 	Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined,
 > = {
 	readonly args: StaticDecode<ArgsSchema>;
 	readonly config: WorkflowConfig<ConfigSchema>;
-	readonly run: RunForIsolation<Mode>;
+	readonly paths: NornWorkflowPaths;
+	readonly run: NornRun;
 } & (Scope extends NornWorkflowScopeInfo ? {
 	readonly scope: { readonly id: Scope["id"]; readonly config: WorkflowConfig<Scope["config"]> };
 } : {});
@@ -88,18 +87,16 @@ export type NornWorkflowContext<
 export type NornWorkflowDefinition<
 	Id extends string = string,
 	ArgsSchema extends TSchema = TSchema,
-	IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode,
 	ConfigSchema extends TSchema | undefined = undefined,
 	Scope extends NornWorkflowScopeInfo | undefined = undefined,
 > = {
 	readonly id: Id;
 	readonly args: ArgsSchema;
 	readonly config?: ConfigSchema;
-	readonly isolation?: NornWorkflowIsolation<IsolationMode>;
 	readonly gate?: NornWorkflowGate<ArgsSchema> & {
-		describe?(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<string>;
+		describe?(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<string>;
 	};
-	execute(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
+	execute(context: NornWorkflowContext<ArgsSchema, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
 } & NornWorkflowInstructions;
 
 export type NornWorkflowScopeInfo = {
@@ -110,31 +107,29 @@ export type NornWorkflowScopeInfo = {
 export type NornWorkflowScope<Id extends string, ConfigSchema extends TSchema | undefined> = {
 	readonly id: Id;
 	readonly config: ConfigSchema;
-	workflow<const LocalId extends string, ArgsSchema extends TSchema, const Mode extends NornWorkflowIsolationMode = "runWorkspace", LocalConfig extends TSchema | undefined = undefined>(
-		definition: NornWorkflowDefinition<LocalId, ArgsSchema, Mode, LocalConfig, { readonly id: Id; readonly config: ConfigSchema }>,
-	): NornWorkflowDeclaration<`${Id}.${LocalId}`, ArgsSchema, Mode, LocalConfig, { readonly id: Id; readonly config: ConfigSchema }>;
+	workflow<const LocalId extends string, ArgsSchema extends TSchema, LocalConfig extends TSchema | undefined = undefined>(
+		definition: NornWorkflowDefinition<LocalId, ArgsSchema, LocalConfig, { readonly id: Id; readonly config: ConfigSchema }>,
+	): NornWorkflowDeclaration<`${Id}.${LocalId}`, ArgsSchema, LocalConfig, { readonly id: Id; readonly config: ConfigSchema }>;
 };
 
 export function workflow<
 	const Id extends string,
 	ArgsSchema extends TSchema,
-	const Mode extends NornWorkflowIsolationMode = "runWorkspace",
 	ConfigSchema extends TSchema | undefined = undefined,
->(definition: NornWorkflowDefinition<Id, ArgsSchema, Mode, ConfigSchema>): NornWorkflowDeclaration<Id, ArgsSchema, Mode, ConfigSchema, undefined> {
+>(definition: NornWorkflowDefinition<Id, ArgsSchema, ConfigSchema>): NornWorkflowDeclaration<Id, ArgsSchema, ConfigSchema, undefined> {
 	return createWorkflow({ definition, scope: undefined });
 }
 
-function createWorkflow<Id extends string, ArgsSchema extends TSchema, Mode extends NornWorkflowIsolationMode, ConfigSchema extends TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined>(
-	input: { readonly definition: NornWorkflowDefinition<Id, ArgsSchema, Mode, ConfigSchema, Scope>; readonly scope: Scope },
-): NornWorkflowDeclaration<Id, ArgsSchema, Mode, ConfigSchema, Scope> {
+function createWorkflow<Id extends string, ArgsSchema extends TSchema, ConfigSchema extends TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined>(
+	input: { readonly definition: NornWorkflowDefinition<Id, ArgsSchema, ConfigSchema, Scope>; readonly scope: Scope },
+): NornWorkflowDeclaration<Id, ArgsSchema, ConfigSchema, Scope> {
 	const { definition, scope } = input;
 	assertDeclarationId(definition.id);
 	const callable = (args: StaticEncode<ArgsSchema>): NornRunNext => createWorkflowTransition({ workflowId: definition.id, args });
 	const result = Object.assign(callable, definition, {
 		kind: WORKFLOW_DECLARATION_KIND,
 		scope,
-		isolation: definition.isolation ?? { mode: "runWorkspace" },
-	}) as NornWorkflowDeclaration<Id, ArgsSchema, Mode, ConfigSchema, Scope>;
+	}) as NornWorkflowDeclaration<Id, ArgsSchema, ConfigSchema, Scope>;
 	if (!isWorkflowDeclaration(result)) throw new Error(`Invalid workflow definition: ${definition.id}`);
 	assertWorkflowMetadata(result);
 	return result;
@@ -163,7 +158,6 @@ export type NornRunNext = {
 
 export type NornRunOutcomeMetadata = {
 	readonly summary?: string;
-	readonly artifacts?: Record<string, NornArtifactRef>;
 	readonly logs?: Record<string, NornLogRef>;
 	readonly data?: Record<string, unknown>;
 };
@@ -180,10 +174,6 @@ export type NornRunFail = {
 
 export type WorkflowResult = NornRunNext | NornRunComplete | NornRunFail;
 
-export type NornRunFor<TWorkflow extends NornAnyWorkflowDeclaration> = TWorkflow extends { readonly isolation: { readonly mode: "project" } }
-	? NornProjectRun
-	: NornRun;
-
 export type NornRunStartOptions = {
 	readonly id?: string;
 	readonly name?: string;
@@ -270,6 +260,7 @@ export type NornRunInfo = {
 	readonly id: string;
 	readonly name: string;
 	readonly path: string;
+	readonly paths: NornWorkflowPaths;
 	readonly entrypointWorkflowId: string;
 	readonly currentWorkflowId?: string;
 	readonly status: NornRunStatus;
@@ -298,17 +289,11 @@ export type NornRunCheckpoint = {
 export type NornCommandRunInput = {
 	readonly label: string;
 	readonly command: string | readonly [string, ...string[]];
-	readonly cwd?: string;
+	readonly cwd: string;
 	readonly env?: Record<string, string>;
 	readonly timeoutMs?: number;
 };
 
-export const artifactRefSchema = Type.Object({
-	path: Type.String(),
-});
-
-export type NornArtifactRef = StaticDecode<typeof artifactRefSchema>;
-
 const emptyWorkflowRefArgsSchema = Type.Object({});
 const workflowReferenceInputSchema = Type.Union([
 	Type.String({ minLength: 1 }),
@@ -350,9 +335,9 @@ export type NornAgentBeforeSessionStartContext = {
 };
 
 export type NornAgentCreateSessionInput = {
-	readonly resourceAdapters?: readonly import("./agent-resource-adapter.ts").NornAgentResourceAdapter[];
+	readonly customTools?: readonly ToolDefinition[];
 	readonly label: string;
-	readonly cwd?: string;
+	readonly cwd: string;
 	readonly tools?: string[];
 	readonly beforeSessionStart?: (context: NornAgentBeforeSessionStartContext) => MaybePromise<void>;
 	readonly model?: CreateAgentSessionOptions["model"];
@@ -477,26 +462,11 @@ export type NornAgentSession = {
 	dispose(): Promise<void>;
 };
 
-export type NornRun = NornRunBase;
-
-export type NornProjectRun = NornRunBase & {
-	projectRoot: string;
-	projectPath(relativePath: string): string;
-};
-
-type NornRunBase = {
+export type NornRun = {
 	id: string;
-	workspace: string;
-	cwd: string;
-	path(relativePath: string): string;
 	next(workflowId: string, args: unknown): NornRunNext;
 	complete(metadata?: NornRunOutcomeMetadata): NornRunComplete;
 	fail(metadata: NornRunOutcomeMetadata & { readonly summary: string }): NornRunFail;
-	resources: import("./resources.ts").NornResources;
-	artifacts: {
-		write(path: string, content: string): Promise<NornArtifactRef>;
-		read(ref: NornArtifactRef): Promise<string>;
-	};
 	logs: {
 		read(log: NornLogRef): Promise<string>;
 	};
@@ -525,7 +495,6 @@ export type NornRegisteredWorkflowInfo = {
 	readonly id: string;
 	readonly instructions?: string;
 	readonly isEntrypoint: boolean;
-	readonly isolation: NornWorkflowIsolation;
 	readonly scope?: { readonly id: string };
 	readonly source?: NornWorkflowSource;
 	readonly configKey: string;
@@ -589,7 +558,7 @@ function assertDeclarationId(id: string): void {
 
 export function isWorkflowDeclaration(value: unknown): value is NornAnyWorkflowDeclaration {
 	if (typeof value !== "function") return false;
-	const candidate = value as { kind?: unknown; id?: unknown; instructions?: unknown; isEntrypoint?: unknown; args?: unknown; execute?: unknown; isolation?: { mode?: unknown } };
+	const candidate = value as { kind?: unknown; id?: unknown; instructions?: unknown; isEntrypoint?: unknown; args?: unknown; execute?: unknown };
 	return (
 		candidate.kind === WORKFLOW_DECLARATION_KIND &&
 		typeof candidate.id === "string" &&
@@ -597,8 +566,7 @@ export function isWorkflowDeclaration(value: unknown): value is NornAnyWorkflowD
 		(candidate.instructions === undefined || typeof candidate.instructions === "string") &&
 		typeof candidate.isEntrypoint === "boolean" &&
 		Boolean(candidate.args) &&
-		typeof candidate.execute === "function" &&
-		(candidate.isolation?.mode === "runWorkspace" || candidate.isolation?.mode === "project")
+		typeof candidate.execute === "function"
 	);
 }
 

package/assets/packages/sdk/src/index.ts

@@ -1,5 +1,2 @@
 export type { CreateAgentSessionOptions, EventBus, PromptOptions, ToolDefinition } from "@earendil-works/pi-coding-agent";
 export * from "./api.ts";
-export { NornFileCoordinator } from "./files.ts";
-export * from "./resources.ts";
-export * from "./agent-resource-adapter.ts";

package/assets/tests/workflow-ref.test.ts

@@ -1,4 +1,4 @@
-import { artifactRefSchema, workflow, isWorkflowDeclaration, workflowRefSchema, type NornWorkflowRefSchemaOptions } from "@vimhead.dev/norn";
+import { workflow, isWorkflowDeclaration, workflowRefSchema, type NornWorkflowRefSchemaOptions } from "@vimhead.dev/norn";
 import { inspectSchema } from "@vimhead.dev/norn/schema";
 import assert from "node:assert/strict";
 import { Type } from "typebox";
@@ -15,7 +15,6 @@ test("callable declarations retain metadata and construct transitions without ex
 	assert.equal(isWorkflowDeclaration(target), true);
 	assert.equal(isWorkflowDeclaration(() => undefined), false);
 	assert.equal(Value.Check(target.args, { report: "done" }), true);
-	assert.deepEqual(target.isolation, { mode: "runWorkspace" });
 	assert.deepEqual(target({ report: "done" }), { type: "next", workflowId: target.id, args: { report: "done" } });
 });
 
@@ -57,7 +56,7 @@ test("optional reference properties remain optional in validation and inspection
 test("inspection advertises encoded contributions and invocation does not decode them", () => {
 	let decodes = 0;
 	const contributions = Type.Object({
-		records: artifactRefSchema,
+		records: Type.String(),
 		count: Type.Decode(Type.String(), value => { decodes++; return Number(value); }),
 		label: Type.Optional(Type.String({ default: "collected" })),
 	});
@@ -72,10 +71,10 @@ test("inspection advertises encoded contributions and invocation does not decode
 	expect(inspected).toHaveProperty("properties.next.x-norn-workflow-ref.contributedArgsSchema.properties.count.type", "string");
 	const forwardArgs = { taskId: "task-42", nested: { labels: ["one", "two"], enabled: false, absent: null } };
 	const next = Value.Decode(schema, { next: { workflow: "refs.finish", forwardArgs } }).next;
-	const contribution = { records: { path: "records.json" }, count: "2" };
+	const contribution = { records: "records.json", count: "2" };
 	assert.deepEqual(next(contribution).args, { ...forwardArgs, ...contribution });
 	assert.equal(decodes, 0);
-	assert.throws(() => Reflect.apply(next, undefined, [{ records: { path: "records.json" }, count: 2 }]));
+	assert.throws(() => Reflect.apply(next, undefined, [{ records: "records.json", count: 2 }]));
 });
 
 test("references without contributions advertise an empty object schema", () => {
@@ -100,10 +99,10 @@ test("optional, nullable and array references retain annotations and callable co
 
 test("nested references retain encoded payloads in contributed parameters", () => {
 	const finalContributions = Type.Object({ summary: Type.String() });
-	const contributions = Type.Object({ records: artifactRefSchema, next: workflowRefSchema({ args: finalContributions }) });
+	const contributions = Type.Object({ records: Type.String(), next: workflowRefSchema({ args: finalContributions }) });
 	const reference = workflowRefSchema({ args: contributions });
 	expect(inspectSchema(reference)).toHaveProperty("x-norn-workflow-ref.contributedArgsSchema.properties.next.x-norn-workflow-ref.contributedArgsSchema", inspectSchema(finalContributions));
-	const args = { records: { path: "records.json" }, next: { workflow: "refs.finish", forwardArgs: { batch: 1 } } };
+	const args = { records: "records.json", next: { workflow: "refs.finish", forwardArgs: { batch: 1 } } };
 	const transition = Value.Decode(reference, "intermediate")(args);
 	assert.deepEqual(transition.args, args);
 	assert.deepEqual(Value.Decode(contributions, transition.args).next({ summary: "done" }).args, { batch: 1, summary: "done" });

package/dist/cli.js

@@ -18,6 +18,7 @@ import { Value } from "typebox/value";
 import { NORN_BUILD_INFO } from "./build-info.js";
 import { renderNornDocumentationIntro, resolveDocumentationCacheRoot, resolveNornDocumentation } from "./documentation.js";
 import { NornEngine } from "./internal/engine.js";
+import { resolveNornAgentDirectory } from "./internal/agent-directory.js";
 import { errorMessage, NornProjectLoadError, NornRunStoppedError } from "./internal/errors.js";
 import { clearRunResumeRequest, readRunLaunchRequest, readRunResumeRequest, writeRunLaunchRequest, writeRunResumeRequest } from "./internal/launch-request.js";
 import { readRunMetrics } from "./internal/metrics.js";
@@ -25,6 +26,7 @@ import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.js";
 import { generateRunName } from "./internal/run-names.js";
 import { assertRunVersion, getRunInfo, listRuns, mergeInterruptedWorkflowArgs, resolveRunRoot } from "./internal/run-state.js";
 import { NornRunStore } from "./internal/run-store.js";
+import { prepareRunWorkerDirectory } from "./internal/worker-directory.js";
 import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./workflow-loader.js";
 var RUNS_ROOT = join(".norn", "runs");
 var RUN_WAIT_INTERVAL_MS = 1e3;
@@ -715,7 +717,7 @@ async function startRun(workflowId, commandArgs) {
   const createdAt = (/* @__PURE__ */ 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, args) {
   assertNoStructuredInputArgs("runs resume", args);
@@ -822,8 +824,10 @@ async function executeRun(runId) {
   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);
@@ -918,6 +922,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/dist/generated-build-info.d.ts

@@ -1,7 +1,7 @@
 export declare const NORN_GENERATED_BUILD_INFO: {
     readonly kind: "npm-registry";
-    readonly version: "0.1.0-tip.35390859630.1";
-    readonly commit: "7a7976170d62c342c29c6479444394d542c3f22b";
+    readonly version: "0.1.0-tip.35436871363.1";
+    readonly commit: "49b14d0ed0c9633fc6ee530a557ec7babbf52b22";
     readonly packageSpec: "@vimhead.dev/norn-cli@tip";
     readonly upgrade: {
         readonly supported: false;

package/dist/generated-build-info.js

@@ -1,8 +1,8 @@
 // src/generated-build-info.ts
 var 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/dist/internal/agents.d.ts

@@ -7,9 +7,6 @@ import type { NornRunLogger } from "./run-log.ts";
 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"];
@@ -24,6 +21,5 @@ export declare class NornAgentRunner {
     constructor(input: NornAgentRunnerInput);
     createSession(agentInput: NornAgentCreateSessionInput): Promise<NornAgentSession>;
     prompt<ResponseSchema extends TSchema>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
-    private resolveFromCwd;
 }
 export {};

package/dist/internal/agents.js

@@ -14,17 +14,16 @@ 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.js";
 import { resolveNornAgentDirectory } from "./agent-directory.js";
 import {
   NornAgentResponseToolFactory
 } from "./agent-response-tool.js";
 import { errorMessage } from "./errors.js";
 import { safeFileName } from "./file-names.js";
-import { NornSessionResourceBindings } from "./resource-bindings.js";
 import { agentUsageFromValue, emptyAgentUsage, totalAgentUsage } from "./usage.js";
 var DEFAULT_AGENT_ATTEMPTS = 3;
-var DEFAULT_AGENT_TOOL_ALLOWLIST = ["read", "bash", "edit", "write", AGENT_RESPONSE_TOOL_NAME];
 var NornAgentRunner = class {
   constructor(input) {
     this.input = input;
@@ -33,7 +32,7 @@ var NornAgentRunner = class {
   input;
   responseToolFactory;
   async createSession(agentInput) {
-    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 });
     const eventBus = createEventBus();
@@ -53,31 +52,29 @@ var NornAgentRunner = class {
       ...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;
     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
       }));
@@ -89,7 +86,6 @@ var NornAgentRunner = class {
         label: agentInput.label,
         cwd,
         session,
-        resourceBindings,
         events: eventBus
       });
     } catch (error) {
@@ -99,12 +95,7 @@ var NornAgentRunner = class {
       } catch (cleanupError) {
         errors2.push(cleanupError);
       }
-      try {
-        await resourceBindings.dispose();
-      } catch (cleanupError) {
-        errors2.push(cleanupError);
-      }
-      if (errors2.length > 1) throw new AggregateError(errors2, "Agent creation and resource cleanup failed");
+      if (errors2.length > 1) throw new AggregateError(errors2, "Agent creation and cleanup failed");
       throw error;
     }
   }
@@ -116,14 +107,6 @@ var NornAgentRunner = class {
       await agent.dispose();
     }
   }
-  resolveFromCwd(path) {
-    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) {
   const systemPrompt = agentInput.systemPrompt;
@@ -223,11 +206,6 @@ var CreatedNornAgentSession = class {
     } 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 });
   }
@@ -328,8 +306,14 @@ function withResponseToolFinalizationInstruction(responseSchema, label, response
   ].join("\n");
 }
 function withAgentResponseTool(tools) {
-  if (!tools) return [...DEFAULT_AGENT_TOOL_ALLOWLIST];
-  return Array.from(/* @__PURE__ */ new Set([...tools, AGENT_RESPONSE_TOOL_NAME]));
+  return tools === void 0 ? void 0 : Array.from(/* @__PURE__ */ new Set([...tools, AGENT_RESPONSE_TOOL_NAME]));
+}
+function assertCustomToolNames(input) {
+  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);
+  }
 }
 export {
   NornAgentRunner

package/dist/internal/commands.d.ts

@@ -2,9 +2,6 @@ import type { NornCommandRunInput, NornCommandRunResult } from "@vimhead.dev/nor
 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;
@@ -13,6 +10,5 @@ export declare class NornCommandRunner {
     private readonly input;
     constructor(input: NornCommandRunnerInput);
     run(commandInput: NornCommandRunInput): Promise<NornCommandRunResult>;
-    private resolveFromCwd;
 }
 export {};