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

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 {};

package/dist/internal/commands.js

@@ -1,7 +1,7 @@
 // src/internal/commands.ts
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { requireAbsoluteWorkingDirectory } from "./working-directory.js";
 import { errorMessage } from "./errors.js";
 import { safeFileName } from "./file-names.js";
 var NornCommandRunner = class {
@@ -10,7 +10,7 @@ var NornCommandRunner = class {
   }
   input;
   async run(commandInput) {
-    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" });
@@ -56,14 +56,6 @@ var NornCommandRunner = class {
     });
     return commandResult;
   }
-  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(`Command cwd escapes ${this.input.boundaryName} isolation: ${path}`);
-    }
-    return resolvedPath;
-  }
 };
 async function spawnCommand(input) {
   const command = typeof input.command === "string" ? "bash" : input.command[0];

package/dist/internal/engine.d.ts

@@ -1,4 +1,4 @@
-import { type NornAnyWorkflowDeclaration, type NornAnyWorkflowPluginManifest, type NornDispose, type NornRunCheckpoint, type NornRunInfo, type NornRunResult, type NornRunStartOptions, type NornWorkflowPlugin } from "@vimhead.dev/norn";
+import { type NornAnyWorkflowDeclaration, type NornDispose, type NornRunCheckpoint, type NornRunInfo, type NornRunResult, type NornRunStartOptions } from "@vimhead.dev/norn";
 import { NornAgentResponseCollector } from "./agent-response-tool.ts";
 import { type NornRunResumeRequest } from "./launch-request.ts";
 import { type NornRegisteredWorkflow } from "./workflow-registry.ts";
@@ -13,19 +13,16 @@ export type NornEngineInput = {
 export declare class NornEngine {
     private readonly input;
     private readonly registry;
-    private readonly registrarState;
-    private readonly disposersByPlugin;
     private readonly responseCollector;
     private readonly activeRuns;
     constructor(input: NornEngineInput);
-    registerPlugin<TManifest extends NornAnyWorkflowPluginManifest>(plugin: NornWorkflowPlugin<TManifest>): NornDispose;
+    registerWorkflows(workflows: readonly NornAnyWorkflowDeclaration[]): NornDispose;
     listWorkflows(): import("@vimhead.dev/norn").NornRegisteredWorkflowInfo[];
     visibleWorkflowEntries(): NornRegisteredWorkflow[];
-    private resolvePluginImplementation;
-    runWorkflow<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, params: unknown, options: NornRunStartOptions | undefined): Promise<NornRunResult>;
+    runWorkflow<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, args: unknown, options: NornRunStartOptions | undefined): Promise<NornRunResult>;
     listRunCheckpoints(path: string): Promise<NornRunCheckpoint[]>;
     rollbackRun(path: string, checkpointId: string): Promise<NornRunInfo>;
-    resumeWorkflow(path: string, params?: unknown): Promise<NornRunResult>;
+    resumeWorkflow(path: string, args?: unknown): Promise<NornRunResult>;
     resumeRequestedWorkflow(input: {
         readonly runRoot: string;
         readonly request: NornRunResumeRequest;
@@ -40,5 +37,4 @@ export declare class NornEngine {
     private startActiveRun;
     private finishActiveRun;
     private failActiveRun;
-    private disposePlugin;
 }

package/dist/internal/engine.js

@@ -1,22 +1,19 @@
 // src/internal/engine.ts
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { createRunFileCoordinator } from "./file-coordinator.js";
 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.js";
-import { NornArtifacts } from "./artifacts.js";
 import { errorMessage, NornRunStoppedError } from "./errors.js";
 import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS } from "./launch-request.js";
 import { NornRunLogs } from "./logs.js";
 import { NornRunLease } from "./run-lease.js";
 import { NornRunLogger } from "./run-log.js";
-import { initializeRunResources } from "./run-resources.js";
-import { getRunInfo, mergeInterruptedWorkflowParams, NornRunStateStore, resolveRunRoot } from "./run-state.js";
+import { assertRunVersion, getRunInfo, mergeInterruptedWorkflowArgs, NornRunStateStore, resolveRunRoot } from "./run-state.js";
 import { NornRunStore, runCurrentRoot } from "./run-store.js";
 import { NornRunContext } from "./run.js";
-import { NornMemoryWorkflowState } from "./state-store.js";
-import { decodePluginConfiguration, NornWorkflowRegistry } from "./workflow-registry.js";
+import { NornWorkflowRegistry } from "./workflow-registry.js";
 var RUNS_DIR_NAME = ".norn";
 var MANIFEST_FILE_NAME = "manifest.json";
 var NornEngine = class {
@@ -26,22 +23,18 @@ var NornEngine = class {
   }
   input;
   registry = new NornWorkflowRegistry();
-  registrarState = new NornMemoryWorkflowState();
-  disposersByPlugin = /* @__PURE__ */ new Map();
   responseCollector;
   activeRuns = /* @__PURE__ */ new Map();
-  registerPlugin(plugin) {
-    this.disposePlugin(plugin.manifest.id);
-    const implementation = this.resolvePluginImplementation(plugin.implementation);
-    const configuration = decodePluginConfiguration({ pluginId: plugin.manifest.id, schema: plugin.manifest.config, value: this.input.config?.[plugin.manifest.id] });
-    const disposers = Object.entries(plugin.manifest.workflows).map(([key, workflow]) => {
-      const workflowImplementation = implementation.workflows[key];
-      if (!workflowImplementation) throw new Error(`Missing implementation for workflow ${plugin.manifest.id}.${key}`);
-      return this.registry.register(workflow, workflowImplementation, { plugin: { id: plugin.manifest.id }, configuration });
-    });
-    this.disposersByPlugin.set(plugin.manifest.id, disposers);
+  registerWorkflows(workflows) {
+    const disposers = [];
+    try {
+      for (const workflow of workflows) disposers.push(this.registry.register({ workflow, config: this.input.config ?? {}, source: void 0 }));
+    } catch (error) {
+      for (const dispose of disposers.reverse()) dispose();
+      throw error;
+    }
     return () => {
-      if (this.disposersByPlugin.get(plugin.manifest.id) === disposers) this.disposePlugin(plugin.manifest.id);
+      for (const dispose of disposers) dispose();
     };
   }
   listWorkflows() {
@@ -50,11 +43,8 @@ var NornEngine = class {
   visibleWorkflowEntries() {
     return this.registry.launchableEntries();
   }
-  resolvePluginImplementation(implementationInput) {
-    return typeof implementationInput === "function" ? implementationInput({ cwd: this.input.cwd, state: this.registrarState }) : implementationInput;
-  }
-  async runWorkflow(workflow, params, options) {
-    const session = await this.createRunSession(workflow, params, options);
+  async runWorkflow(workflow, args, options) {
+    const session = await this.createRunSession(workflow, args, options);
     const current = session.state.currentState().current;
     if (!current) throw new Error("New run is missing its initial workflow step");
     return this.runScheduler(session, toWorkflowStep(workflow, current));
@@ -65,6 +55,7 @@ var NornEngine = class {
   }
   async rollbackRun(path, checkpointId) {
     const runRoot = await resolveRunRoot(this.input.cwd, path);
+    assertRunVersion((await getRunInfo(runRoot)).version);
     const lease = await NornRunLease.acquire(runRoot);
     try {
       const pendingRequest = await readOptionalRunResumeRequest(runRoot);
@@ -80,19 +71,19 @@ var NornEngine = class {
       await lease.release();
     }
   }
-  async resumeWorkflow(path, params) {
-    return this.resumeWorkflowExecution({ path, params, expectedRequest: void 0 });
+  async resumeWorkflow(path, args) {
+    return this.resumeWorkflowExecution({ path, args, expectedRequest: void 0 });
   }
   async resumeRequestedWorkflow(input) {
-    return this.resumeWorkflowExecution({ path: input.runRoot, params: input.request.params, expectedRequest: input.request });
+    return this.resumeWorkflowExecution({ path: input.runRoot, args: input.request.args, expectedRequest: input.request });
   }
   async resumeWorkflowExecution(input) {
-    const { params, expectedRequest } = input;
+    const { args, expectedRequest } = input;
     const runRoot = await resolveRunRoot(this.input.cwd, input.path);
     const initialStateStore = await NornRunStateStore.load(runRoot);
     const initialState = initialStateStore.currentState();
-    if (initialState.status === "interrupted" && params === void 0) throw new Error(`Interrupted workflow resume requires params: ${runRoot}`);
-    if (initialState.status === "pendingResume" && params !== void 0) throw new Error(`Pending-resume workflows do not accept params: ${runRoot}`);
+    if (initialState.status === "interrupted" && args === void 0) throw new Error(`Interrupted workflow resume requires args: ${runRoot}`);
+    if (initialState.status === "pendingResume" && args !== void 0) throw new Error(`Pending-resume workflows do not accept args: ${runRoot}`);
     if (initialState.status !== "interrupted" && initialState.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
     const lease = await NornRunLease.acquire(runRoot);
     let isLeaseOwnedByScheduler = false;
@@ -107,17 +98,17 @@ var NornEngine = class {
       const workflow = this.registry.workflowById(current.workflowId);
       if (!workflow) throw new Error(`Unknown workflow for resumed run: ${current.workflowId}`);
       if (state.status === "interrupted") {
-        const rawParams = mergeInterruptedWorkflowParams(current.params, params, current.interruption?.fields);
-        Value.Decode(workflow.params, rawParams);
-        await session.state.replaceCurrentParams(rawParams);
-        await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
+        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.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 {
@@ -135,28 +126,27 @@ var NornEngine = class {
     try {
       for (let step = 1; step <= 1e3; step++) {
         throwIfRunAborted(session.activeRun);
-        const stepRuntime = session.run.forWorkflow(currentStep.workflow);
         if (shouldPauseForGate(currentStep)) {
-          const description = await this.registry.describeGate(currentStep.workflow, stepRuntime, currentStep.params, 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.params, interruption);
+          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.params, 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));
@@ -169,7 +159,7 @@ var NornEngine = class {
       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) });
@@ -179,13 +169,13 @@ var NornEngine = class {
       this.finishActiveRun(session.runRoot, session.activeRun);
     }
   }
-  async executeWorkflowStep(session, step, run) {
+  async executeWorkflowStep(session, step) {
     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.params, 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 });
@@ -206,17 +196,18 @@ var NornEngine = class {
     if (!workflow) throw new Error(`Unknown next workflow: ${next.workflowId}`);
     return {
       workflow,
-      params: next.params,
+      args: next.args,
       interruption: this.input.gateMode === "pause" && workflow.gate ? { status: "pending" } : void 0
     };
   }
-  async createRunSession(workflow, params, options) {
+  async createRunSession(workflow, args, options) {
     const id = options?.id ?? randomUUID();
     const name = options?.name ?? id;
     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 = { project: resolve(this.input.cwd), workspace };
+    const cwd = process.cwd();
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     await mkdir(runRoot, { recursive: true });
     const lease = await NornRunLease.acquire(runRoot);
@@ -233,8 +224,9 @@ var NornEngine = class {
         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,
@@ -242,14 +234,14 @@ var NornEngine = class {
         configOverride: options?.configOverride,
         current: {
           workflowId: workflow.id,
-          params,
+          args,
           cwd,
           env: {},
           interruption: this.input.gateMode === "pause" && workflow.gate ? { status: "pending" } : void 0
         },
         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;
@@ -268,38 +260,27 @@ var NornEngine = class {
       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) : void 0;
-      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 = { 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;
     }
   }
   async buildRun(input) {
-    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, state } = await initializeRunResources(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,
-      state,
       logger: input.logger,
-      artifacts: new NornArtifacts(artifactsRoot, resources.files),
-      logs: new NornRunLogs(logsRoot, resources.files)
+      logs: new NornRunLogs(logsRoot, files)
     });
   }
   startActiveRun(runRoot) {
@@ -332,29 +313,21 @@ var NornEngine = class {
     activeRun.dispose();
     activeRun.finish();
   }
-  disposePlugin(pluginId) {
-    const disposers = this.disposersByPlugin.get(pluginId) ?? [];
-    for (const dispose of [...disposers].reverse()) dispose();
-    this.disposersByPlugin.delete(pluginId);
-  }
 };
 function defaultRunRoot(cwd, id) {
-  return join(cwd, RUNS_DIR_NAME, "runs", id);
-}
-function workflowDefaultCwd(projectRoot, workspace, workflow) {
-  return workflow?.isolation.mode === "project" ? projectRoot : workspace;
+  return join(resolve(cwd), RUNS_DIR_NAME, "runs", id);
 }
 function toWorkflowStep(workflow, step) {
   return {
     workflow,
-    params: step.params,
+    args: step.args,
     interruption: step.interruption
   };
 }
 function toRunStateStep(step) {
   return {
     workflowId: step.workflow.id,
-    params: step.params,
+    args: step.args,
     cwd: "",
     env: {},
     interruption: step.interruption
@@ -372,7 +345,7 @@ function throwIfRunAborted(activeRun) {
 function isRunStopped(session, error) {
   return error instanceof NornRunStoppedError || session.activeRun.controller.signal.reason instanceof NornRunStoppedError;
 }
-function interruptedLaunchResult(run, workflow, params, interruption) {
+function interruptedLaunchResult(run, workflow, args, interruption) {
   if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
   if (!interruption.description) throw new Error(`Interrupted workflow is missing description: ${workflow.id}`);
   return {
@@ -382,7 +355,7 @@ function interruptedLaunchResult(run, workflow, params, interruption) {
     workspace: run.workspace,
     cwd: run.cwd,
     workflowId: workflow.id,
-    interruption: { workflowId: workflow.id, params, description: interruption.description, fields: interruption.fields }
+    interruption: { workflowId: workflow.id, args, description: interruption.description, fields: interruption.fields }
   };
 }
 async function recordRunEvent(session, event) {

package/dist/internal/errors.d.ts

@@ -1,11 +1,11 @@
-import type { NornPluginDiagnostic } from "@vimhead.dev/norn";
+import type { NornWorkflowDiagnostic } from "@vimhead.dev/norn";
 import { AssertError } from "typebox/value";
 export declare class NornProjectLoadError extends Error {
     readonly code = "NORN_PROJECT_INVALID";
     readonly isComplete = false;
-    readonly diagnostics: readonly NornPluginDiagnostic[];
+    readonly diagnostics: readonly NornWorkflowDiagnostic[];
     constructor(input: {
-        readonly diagnostics: readonly NornPluginDiagnostic[];
+        readonly diagnostics: readonly NornWorkflowDiagnostic[];
     });
 }
 export declare class NornRunStoppedError extends Error {

package/dist/internal/errors.js

@@ -6,7 +6,7 @@ var NornProjectLoadError = class extends Error {
   diagnostics;
   constructor(input) {
     const details = input.diagnostics.map(
-      (diagnostic) => `${diagnostic.stage}: ${diagnostic.pluginPath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`
+      (diagnostic) => `${diagnostic.stage}: ${diagnostic.modulePath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`
     );
     super(`Norn project is incomplete (${input.diagnostics.length} diagnostics); execution is blocked.
 ${details.join("\n")}`);

package/dist/internal/file-coordinator.d.ts

@@ -0,0 +1,17 @@
+export declare class NornFileCoordinator {
+    private readonly input;
+    private readonly lockRoot;
+    constructor(input: {
+        readonly lockRoot: string;
+        readonly waitTimeoutMs: number;
+    });
+    withExclusiveLock<T>(path: string, operation: (lockedPath: string) => Promise<T>): Promise<T>;
+    readText(path: string): Promise<string>;
+    writeText(path: string, content: string): Promise<void>;
+    private withCleanup;
+    private resolveTarget;
+    private acquire;
+    private reclaimDeadOwner;
+    private removeEmptyLock;
+}
+export declare function createRunFileCoordinator(runRoot: string): NornFileCoordinator;