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

package/dist/internal/engine.d.ts

@@ -33,7 +33,7 @@ export declare class NornEngine {
     private nextWorkflowStep;
     private createRunSession;
     private openRunSession;
-    private buildRun;
+    private buildExecutionContext;
     private startActiveRun;
     private finishActiveRun;
     private failActiveRun;

package/dist/internal/engine.js

@@ -1,20 +1,18 @@
 // 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 { NornRunResources } from "../resources.js";
 import { assertRunVersion, getRunInfo, mergeInterruptedWorkflowArgs, NornRunStateStore, resolveRunRoot } from "./run-state.js";
 import { NornRunStore, runCurrentRoot } from "./run-store.js";
-import { NornRunContext } from "./run.js";
+import { NornExecutionContext } from "./execution-context.js";
 import { NornWorkflowRegistry } from "./workflow-registry.js";
 var RUNS_DIR_NAME = ".norn";
 var MANIFEST_FILE_NAME = "manifest.json";
@@ -103,14 +101,14 @@ var NornEngine = class {
         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 {
@@ -128,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.args, session.state.currentState().configOverride);
+          const description = await this.registry.describeGate({ workflow: currentStep.workflow, execution: session.execution, 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.execution.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.execution.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.execution.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));
@@ -162,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.execution.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) });
@@ -172,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.args, session.state.currentState().configOverride);
-      await assertWorkspaceBoundary(session, run.workspace);
+      const result = await this.registry.execute({ workflow: step.workflow, execution: session.execution, 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 });
@@ -209,7 +206,8 @@ var NornEngine = class {
     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);
@@ -226,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 execution = await this.buildExecutionContext({ id, currentRoot, paths, signal: activeRun.controller.signal, logger });
       const state = await NornRunStateStore.create(runRoot, {
+        projectRoot: paths.project,
         id,
         name,
         entrypointWorkflowId: workflow.id,
@@ -242,7 +241,7 @@ var NornEngine = class {
         },
         startedAt
       });
-      const session = { runRoot, run, state, lease, runStore, logger, activeRun };
+      const session = { runRoot, cwd, execution, 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;
@@ -261,37 +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 execution = await this.buildExecutionContext({ id: currentState.id, currentRoot, paths, signal: activeRun.controller.signal, logger });
+      return { runRoot, cwd: process.cwd(), execution, paths, state, lease, runStore, logger, activeRun };
     } catch (error) {
       this.failActiveRun(runRoot, activeRun);
       throw error;
     }
   }
-  async buildRun(input) {
-    const artifactsRoot = join(input.currentRoot, "artifacts");
+  async buildExecutionContext(input) {
     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));
-    return new NornRunContext({
+    const files = createRunFileCoordinator(dirname(input.currentRoot));
+    return new NornExecutionContext({
       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)
     });
   }
   startActiveRun(runRoot) {
@@ -326,10 +315,7 @@ var NornEngine = class {
   }
 };
 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 {

package/dist/internal/execution-context.d.ts

@@ -0,0 +1,26 @@
+import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { NornAgents, NornCommands, NornLogs, NornRun } from "@vimhead.dev/norn";
+import type { NornAgentResponseCollector } from "./agent-response-tool.ts";
+import type { NornRunLogs } from "./logs.ts";
+import type { NornRunLogger } from "./run-log.ts";
+type NornExecutionContextInput = {
+    readonly id: string;
+    readonly runRoot: string;
+    readonly signal?: AbortSignal;
+    readonly model?: CreateAgentSessionOptions["model"];
+    readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+    readonly agentDir?: string;
+    readonly responseCollector: NornAgentResponseCollector;
+    readonly logger: NornRunLogger;
+    readonly logs: NornRunLogs;
+};
+export declare class NornExecutionContext {
+    private readonly input;
+    readonly run: NornRun;
+    readonly logs: NornLogs;
+    readonly commands: NornCommands;
+    readonly agents: NornAgents;
+    constructor(input: NornExecutionContextInput);
+    private createAgentRunner;
+}
+export {};

package/dist/internal/execution-context.js

@@ -0,0 +1,55 @@
+// ../core/src/workflow-transition.ts
+function createWorkflowTransition(input) {
+  if (typeof input.workflowId !== "string" || input.workflowId.trim().length === 0) throw new Error("Workflow transition requires a nonempty workflow ID");
+  return { type: "next", workflowId: input.workflowId, args: input.args };
+}
+
+// src/internal/execution-context.ts
+import { NornAgentRunner } from "./agents.js";
+import { NornCommandRunner } from "./commands.js";
+var NornExecutionContext = class {
+  constructor(input) {
+    this.input = input;
+    this.run = {
+      id: input.id,
+      next: (workflowId, args) => createWorkflowTransition({ workflowId, args }),
+      complete: (metadata) => ({ type: "complete", metadata }),
+      fail: (metadata) => ({ type: "fail", metadata })
+    };
+    this.logs = {
+      read: (log) => this.input.logs.read(log)
+    };
+    this.commands = {
+      run: (commandInput) => new NornCommandRunner({
+        signal: this.input.signal,
+        logs: this.input.logs,
+        logger: this.input.logger
+      }).run(commandInput)
+    };
+    this.agents = {
+      createSession: (agentInput) => this.createAgentRunner().createSession(agentInput),
+      prompt: (agentInput) => this.createAgentRunner().prompt(agentInput)
+    };
+  }
+  input;
+  run;
+  logs;
+  commands;
+  agents;
+  createAgentRunner() {
+    return new NornAgentRunner({
+      id: this.input.id,
+      runRoot: this.input.runRoot,
+      signal: this.input.signal,
+      model: this.input.model,
+      thinkingLevel: this.input.thinkingLevel,
+      agentDir: this.input.agentDir,
+      logs: this.input.logs,
+      logger: this.input.logger,
+      responseCollector: this.input.responseCollector
+    });
+  }
+};
+export {
+  NornExecutionContext
+};

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;

package/dist/internal/file-coordinator.js

@@ -0,0 +1,162 @@
+// ../core/src/atomic-files.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// ../core/src/atomic-files.ts
+async function writeTextAtomically(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  let existingMode;
+  try {
+    existingMode = (await stat(path)).mode & 511;
+  } catch (error) {
+    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+  }
+  const tmpPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    if (existingMode !== void 0) await chmod(tmpPath, existingMode);
+    await rename(tmpPath, path);
+  } catch (error) {
+    await rm(tmpPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/internal/file-coordinator.ts
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { lstat, mkdir as mkdir2, mkdtemp, readFile, readdir, realpath, rename as rename2, rm as rm2, rmdir, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { hostname } from "node:os";
+import { basename, dirname as dirname2, join, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var ownerSchema = Type.Object({
+  token: Type.String({ format: "uuid" }),
+  pid: Type.Integer({ exclusiveMinimum: 0 }),
+  host: Type.String(),
+  target: Type.String()
+}, { additionalProperties: false });
+var NornFileCoordinator = class {
+  constructor(input) {
+    this.input = input;
+    if (!Number.isSafeInteger(input.waitTimeoutMs) || input.waitTimeoutMs <= 0) throw new Error("Lock wait timeout must be a positive integer");
+    this.lockRoot = resolve(input.lockRoot);
+  }
+  input;
+  lockRoot;
+  async withExclusiveLock(path, operation) {
+    const target = await this.resolveTarget(path);
+    await mkdir2(this.lockRoot, { recursive: true, mode: 448 });
+    const key = createHash("sha256").update(target).digest("hex");
+    const lockPath = join(this.lockRoot, `${key}.lock`);
+    const stagingPath = await mkdtemp(join(this.lockRoot, `${key}.pending-`));
+    const token = randomUUID2();
+    const marker = `${token}.json`;
+    return this.withCleanup({
+      operation: async () => {
+        await writeFile2(join(stagingPath, marker), JSON.stringify({ token, pid: process.pid, host: hostname(), target }), { mode: 384 });
+        await this.acquire({ stagingPath, lockPath, target });
+        return this.withCleanup({
+          operation: () => operation(target),
+          cleanup: async () => {
+            await unlink(join(lockPath, marker));
+            await this.removeEmptyLock(lockPath);
+          }
+        });
+      },
+      cleanup: () => rm2(stagingPath, { recursive: true, force: true })
+    });
+  }
+  async readText(path) {
+    return this.withExclusiveLock(path, (lockedPath) => readFile(lockedPath, "utf8"));
+  }
+  async writeText(path, content) {
+    await mkdir2(dirname2(path), { recursive: true });
+    await this.withExclusiveLock(path, (lockedPath) => writeTextAtomically(lockedPath, content));
+  }
+  async withCleanup(input) {
+    let result;
+    try {
+      result = await input.operation();
+    } catch (error) {
+      try {
+        await input.cleanup();
+      } catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], "File operation and lock cleanup failed");
+      }
+      throw error;
+    }
+    await input.cleanup();
+    return result;
+  }
+  async resolveTarget(path) {
+    try {
+      return await realpath(path);
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+      const entry = await lstat(path).catch((error2) => {
+        if (isNodeError(error2) && error2.code === "ENOENT") return void 0;
+        throw error2;
+      });
+      if (entry?.isSymbolicLink()) throw new Error(`Cannot lock a dangling symbolic link: ${path}`);
+      return join(await realpath(dirname2(path)), basename(path));
+    }
+  }
+  async acquire(input) {
+    const deadline = Date.now() + this.input.waitTimeoutMs;
+    while (true) {
+      try {
+        await rename2(input.stagingPath, input.lockPath);
+        return;
+      } catch (error) {
+        if (!isNodeError(error) || !["ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+      }
+      await this.reclaimDeadOwner(input);
+      if (Date.now() >= deadline) throw new Error(`Timed out waiting for file lock: ${input.target}`);
+      await delay(10);
+    }
+  }
+  async reclaimDeadOwner(input) {
+    try {
+      const entries = await readdir(input.lockPath);
+      if (entries.length === 0) return;
+      if (entries.length !== 1) throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
+      const marker = entries[0];
+      const owner = Value.Parse(ownerSchema, JSON.parse(await readFile(join(input.lockPath, marker), "utf8")));
+      if (marker !== `${owner.token}.json` || owner.target !== input.target || owner.host !== hostname()) {
+        throw new Error(`Incompatible file lock ownership: ${input.lockPath}`);
+      }
+      try {
+        process.kill(owner.pid, 0);
+        return;
+      } catch (error) {
+        if (isNodeError(error) && error.code === "EPERM") return;
+        if (!isNodeError(error) || error.code !== "ESRCH") throw error;
+      }
+      await unlink(join(input.lockPath, marker));
+      await this.removeEmptyLock(input.lockPath);
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+    }
+  }
+  async removeEmptyLock(path) {
+    try {
+      await rmdir(path);
+    } catch (error) {
+      if (!isNodeError(error) || !["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+    }
+  }
+};
+function createRunFileCoordinator(runRoot) {
+  return new NornFileCoordinator({ lockRoot: join(runRoot, "locks"), waitTimeoutMs: 3e4 });
+}
+export {
+  NornFileCoordinator,
+  createRunFileCoordinator
+};

package/dist/internal/logs.d.ts

@@ -1,5 +1,5 @@
 import { type WriteStream } from "node:fs";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { NornFileCoordinator } from "./file-coordinator.ts";
 import type { NornLogRef } from "@vimhead.dev/norn";
 export type NornLogWriteStream = {
     readonly log: NornLogRef;

package/dist/internal/run-log.d.ts

@@ -1,4 +1,4 @@
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { NornFileCoordinator } from "./file-coordinator.ts";
 export type NornRunManifestEvent = {
     readonly at: string;
     readonly type: string;

package/dist/internal/run-state.d.ts

@@ -40,6 +40,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;
@@ -54,6 +55,7 @@ export type NornRunState = {
     readonly updatedAt: string;
 };
 type CreateNornRunStateInput = {
+    readonly projectRoot: string;
     readonly id: string;
     readonly name: string;
     readonly entrypointWorkflowId: string;

package/dist/internal/run-state.js

@@ -39,7 +39,7 @@ async function writeTextAtomically(path, content) {
 }
 
 // src/internal/run-state.ts
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { createRunFileCoordinator } from "./file-coordinator.js";
 import { runCurrentRoot } from "./run-store.js";
 import { jsonValueSchema } from "@vimhead.dev/norn/schema";
 import { Value } from "typebox/value";
@@ -70,7 +70,8 @@ var NornRunStateStore = 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,
@@ -204,6 +205,7 @@ async function getRunInfo(runRoot) {
       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,
@@ -260,6 +262,7 @@ async function getLaunchedRunInfo(runRoot) {
     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/dist/internal/worker-directory.d.ts

@@ -0,0 +1 @@
+export declare function prepareRunWorkerDirectory(runRoot: string): Promise<string>;

package/dist/internal/worker-directory.js

@@ -0,0 +1,26 @@
+// src/internal/worker-directory.ts
+import { chmod, lstat, mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/internal/worker-directory.ts
+async function prepareRunWorkerDirectory(runRoot) {
+  const directory = join(runRoot, "worker");
+  try {
+    await mkdir(directory, { mode: 365 });
+  } 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, 365);
+  return directory;
+}
+export {
+  prepareRunWorkerDirectory
+};

package/dist/internal/workflow-registry.d.ts

@@ -1,4 +1,4 @@
-import { type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRunFor, type NornRunNext, type NornWorkflowSource, type NornProjectConfigurationInfo } from "@vimhead.dev/norn";
+import { type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRunNext, type NornWorkflowPaths, type NornWorkflowContext, type NornWorkflowSource, type NornProjectConfigurationInfo } from "@vimhead.dev/norn";
 import type { TSchema } from "typebox";
 export type NornRegisteredConfiguration = {
     readonly key: string;
@@ -27,6 +27,15 @@ export type NornWorkflowStepResult = NornRunNext | {
     readonly workflow: NornAnyWorkflowDeclaration;
     readonly metadata: NornRunFail["metadata"];
 };
+type NornExecutionContextInput = {
+    readonly execution: Pick<NornWorkflowContext, "run" | "agents" | "commands" | "logs">;
+    readonly paths: NornWorkflowPaths;
+    readonly args: unknown;
+    readonly configOverride: unknown;
+};
+type NornWorkflowExecutionInput = NornExecutionContextInput & {
+    readonly workflow: NornAnyWorkflowDeclaration;
+};
 export declare class NornWorkflowRegistry {
     private readonly entries;
     private readonly scopes;
@@ -42,10 +51,11 @@ export declare class NornWorkflowRegistry {
     configurationInfos(): NornProjectConfigurationInfo[];
     launchableEntries(): NornRegisteredWorkflow[];
     workflowById(workflowId: string): NornAnyWorkflowDeclaration | undefined;
-    describeGate<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<string>;
-    execute<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<NornWorkflowStepResult>;
+    describeGate(input: NornWorkflowExecutionInput): Promise<string>;
+    execute(input: NornWorkflowExecutionInput): Promise<NornWorkflowStepResult>;
     private createExecutionContext;
     private requireEntry;
     private sortedEntries;
 }
 export declare function assertWorkflowDefinition(workflow: NornAnyWorkflowDeclaration): void;
+export {};

package/dist/internal/workflow-registry.js

@@ -81,30 +81,36 @@ var NornWorkflowRegistry = class {
   workflowById(workflowId) {
     return this.entries.get(workflowId)?.workflow;
   }
-  async describeGate(workflow, run, args, configOverride) {
+  async describeGate(input) {
+    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(workflow, run, args, configOverride) {
+  async execute(input) {
+    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}`);
   }
   createExecutionContext(input) {
-    const { entry, run, configOverride } = input;
+    const { entry, execution, paths, configOverride } = input;
     const scope = entry.scopeId ? this.scopes.get(entry.scopeId) : void 0;
     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) } } : {},
-      run
+      paths,
+      run: execution.run,
+      agents: execution.agents,
+      commands: execution.commands,
+      logs: execution.logs
     };
   }
   requireEntry(id) {
@@ -152,7 +158,6 @@ function workflowInfo(entry) {
     id: entry.workflow.id,
     instructions: entry.workflow.instructions,
     isEntrypoint: entry.workflow.isEntrypoint,
-    isolation: entry.workflow.isolation,
     source: entry.source,
     configKey: entry.workflow.id,
     scope: entry.scopeId ? { id: entry.scopeId } : void 0

package/dist/internal/working-directory.d.ts

@@ -0,0 +1 @@
+export declare function requireAbsoluteWorkingDirectory(cwd: string): string;