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

package/dist/internal/working-directory.js

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

package/dist/workflow-loader.js

@@ -8,7 +8,6 @@ function isNodeError(error) {
 }
 
 // src/workflow-loader.ts
-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 } from "jiti/static";
@@ -192,7 +191,7 @@ function createDiagnostic(input) {
   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() {
-  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) {
   const [project, ...reusable] = files;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn-cli",
-  "version": "0.1.0-tip.35390859630.1",
+  "version": "0.1.0-tip.35568631545.1",
   "description": "Harness-agnostic runtime for agent-driven and code-driven workflows, built primarily for agents.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "@earendil-works/pi-coding-agent": "0.85.1",
     "jiti": "^2.7.0",
     "typebox": "^1.3.34",
-    "@vimhead.dev/norn": "0.1.0-tip.35390859630.1"
+    "@vimhead.dev/norn": "0.1.0-tip.35568631545.1"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.ts"

package/assets/docs/resources.md

@@ -1,46 +0,0 @@
-# Run resources and exclusive locking
-
-## Initialization is separate from attachment
-
-`run.resources` provides shared resource handles. The [shared-state example](../examples/shared-state/README.md) demonstrates mutable storage as a custom resource.
-
-`run.resources.ensure(definition)` returns a shared handle for that resource across workflow contexts in the current executor. A definition contains `name`, `kind`, JSON `configuration`, and `initialize({directory, files, mode})`. Names are single alphanumeric/underscore/hyphen identifiers starting with an alphanumeric character. Identity/configuration conflicts fail; `configuration` owns format/version compatibility.
-
-`mode: "create"` also covers retry of an interrupted initialization; `mode: "open"` means an earlier initialization succeeded. Initializers own their data schema and must reject missing/incompatible data when reopening. Failed initialization remains visible and retryable, not a successful empty resource. Definitions have no filesystem effects until ensured.
-
-| Decision | GOOD | BAD |
-|---|---|---|
-| IF implementing an initializer, THEN make create retries preserve existing data and open validate existing storage. ELSE do not register the definition. | Validate a file left by an interrupted create before reusing it. | Truncate the file each time `ensure` calls the initializer. |
-| IF a resource format changes incompatibly, THEN change its declared configuration and provide an explicit migration. ELSE reopen the same format. | A mismatching `format` fails. | Reinterpret old bytes under an unchanged format declaration. |
-
-[Persistence](persistence.md) covers resource lifetimes, storage locations, and recovery. Cross-run storage, queues, ledgers, and scheduler/agent activation are not supplied by this API.
-
-## Explicit agent attachment
-
-The [shared-state example](../examples/shared-state/README.md) supplies its own resource and permission-selected adapter. The [queue example](../examples/coordinating-multiple-agents/README.md) supplies a different resource and tool contract. Neither adapter is a built-in SDK state facility.
-
-Custom adapters implement `NornAgentResourceAdapter`: a unique name and `bind({runId, label})` returning a `NornAgentResourceBinding` with tools and async `dispose()`. An adapter can expose one or several resource handles; initializing storage does not construct or attach tools. Session creation and one-shot prompting accept adapters through `resourceAdapters`, not through the resource manager or state handle directly. Attached tools are activated with the normal response tool. Duplicate adapter names and collisions with built-ins, the response tool, other adapters or already-loaded extension tools fail. Successful bindings are cleaned up in reverse order on session disposal or later creation failure. An initializer/binder that throws before returning its handle owns cleanup of its partial allocations.
-
-| Decision | GOOD | BAD |
-|---|---|---|
-| IF a Norn agent needs resource access, THEN attach an adapter exposing the required operations. ELSE omit the attachment. | A reviewer receives read-only access to a candidate. | Automatically expose every resource to every session. |
-| IF disposing a binding, THEN release session-local handles only. ELSE retain the resource for later sessions. | Close a subscription. | Delete workflow state when its agent exits. |
-
-The attachment never exposes internal scheduler/checkpoint control state. It is a cooperative tool boundary, not a sandbox against unrestricted filesystem tools or trusted extensions. [Agent loading](agents.md#prompts-tools-and-resource-loading) owns those limitations.
-
-## Shared storage coordination
-
-`run.resources.files` supplies `readText`, `writeText`, and `withExclusiveLock(path, async lockedPath => ...)`. Standalone callers can construct `NornFileCoordinator({lockRoot, waitTimeoutMs})` from `@vimhead.dev/norn`. Coordinating callers must use the same lock namespace. Target parents must exist before a raw `withExclusiveLock` call; `writeText` creates them. Existing symbolic links resolve to their canonical target; dangling links fail.
-
-The lock spans the complete callback, including read/validate/modify/persist. `writeText` replaces complete file contents atomically. A live owner is never expired by a TTL; confirmed dead local owners can be reclaimed. Invalid or foreign-host ownership fails closed, and contention has a bounded wait. PID reuse can delay reclamation rather than permit two owners. Locks support local filesystems on one host, not distributed storage.
-
-Reads of live command-output logs may return partial streams. File locks do not make multi-file snapshots or external side effects transactional.
-
-| Decision | GOOD | BAD |
-|---|---|---|
-| IF updating shared file data, THEN hold one lock around the entire operation and use its canonical `lockedPath`. ELSE ordinary atomic replacement suffices only for independent values. | Read, modify and atomically replace inside one callback. | Lock only the final write after reading stale contents. |
-| IF two callers access the same resource, THEN use the same coordinator namespace. ELSE do not claim mutual exclusion. | Reuse the run manager's `files`. | Give each session a different lock root for the same data. |
-| IF a callback holds a lock, THEN finish its short storage operation before prompting a model or taking another lock on the same file. ELSE release it first. | Persist a value and return. | Wait for a model turn while holding a file lock. |
-| IF restoring a checkpoint, THEN restore resource data but not lock ownership. ELSE follow the owning external resource's recovery contract. | Built-in locks live under the run's `locks/`, outside `current/`. | Restore an old owner's lock directory as live ownership. |
-
-Sources: [resource contracts](../packages/sdk/src/resources.ts), [resource manager](../packages/cli/src/resources.ts), [adapter contracts](../packages/sdk/src/agent-resource-adapter.ts), [file coordinator](../packages/sdk/src/files.ts).

package/assets/examples/coordinating-multiple-agents/queue-adapter.ts

@@ -1,51 +0,0 @@
-import type { NornAgentResourceAdapter } from "@vimhead.dev/norn";
-import { randomUUID } from "node:crypto";
-import { Type, type Static } from "typebox";
-import { summarySchema, type WorkQueue } from "./work-queue.ts";
-
-const acknowledgeParameters = Type.Object({
-	id: Type.String({ minLength: 1, maxLength: 128 }),
-	token: Type.String({ minLength: 36, maxLength: 36 }),
-	result: summarySchema,
-});
-
-export function QueueAdapter(input: { readonly queue: WorkQueue }): NornAgentResourceAdapter {
-	return {
-		name: "example.note-summaries",
-		async bind() {
-			const owner = randomUUID();
-			return {
-				tools: [
-					{
-						name: "queue_status", label: "Note queue status", description: "Read counts of available, leased and acknowledged notes, without exposing other agents' notes or tokens.",
-						parameters: Type.Object({}),
-						async execute() {
-							const { items: _items, ...status } = await input.queue.inspect();
-							return describeResult(status);
-						},
-					},
-					{
-						name: "queue_claim", label: "Claim a note", description: "Claim one note for this session, or return its existing live claim. Null means nothing available now, not all work complete. Save its token; expiresAt is Unix time in milliseconds. Note text is bounded to 1000 characters.",
-						parameters: Type.Object({}),
-						async execute(_id, _args, signal) {
-							return describeResult({ claim: await input.queue.claim({ owner, signal }) });
-						},
-					},
-					{
-						name: "queue_acknowledge", label: "Save a note summary", description: "Save {summary, quote} and acknowledge this session's live claim in one operation. Stale tokens fail; identical successful retries succeed. This records processing, not semantic approval.",
-						parameters: acknowledgeParameters,
-						async execute(_id: string, args: Static<typeof acknowledgeParameters>, signal: AbortSignal | undefined) {
-							await input.queue.acknowledge({ ...args, owner, signal });
-							return describeResult({ acknowledged: args.id });
-						},
-					},
-				],
-				async dispose() {},
-			};
-		},
-	};
-}
-
-function describeResult(value: unknown) {
-	return { content: [{ type: "text" as const, text: JSON.stringify(value) }], details: value };
-}

package/assets/examples/shared-state/state-adapter.ts

@@ -1,76 +0,0 @@
-import { createHash } from "node:crypto";
-import { Type, type TSchema } from "typebox";
-import type { NornAgentResourceAdapter, ToolDefinition } from "@vimhead.dev/norn";
-import type { SharedStateAccess, SharedStateField } from "./shared-state.ts";
-import { inspectSchema } from "@vimhead.dev/norn/schema";
-
-function defineTool<Schema extends TSchema>(tool: ToolDefinition<Schema>): ToolDefinition<Schema> { return tool; }
-
-export type NornStateFieldAccess = {
-	readonly field: SharedStateField;
-	readonly access: "read" | "write" | "read-write";
-};
-
-const pageParameters = {
-	offset: Type.Integer({ minimum: 0, description: "Zero-based UTF-16 offset into the serialized JSON. Start at 0." }),
-	limit: Type.Integer({ minimum: 1, maximum: 10000 }),
-};
-
-export function StateAdapter(input: { readonly state: SharedStateAccess; readonly fields: readonly NornStateFieldAccess[] }): NornAgentResourceAdapter {
-	const fields = new Map(input.fields.map((grant) => [grant.field.id, grant]));
-	if (fields.size !== input.fields.length || fields.size === 0) throw new Error("State attachment requires unique, explicitly selected fields");
-	const selectField = (key: string, access: "read" | "write") => {
-		const grant = fields.get(key);
-		if (!grant || (grant.access !== access && grant.access !== "read-write")) throw new Error(`State ${access} is not attached: ${key}`);
-		return grant.field;
-	};
-	return {
-		name: "example.shared-state",
-		async bind() {
-			return {
-				tools: [
-					defineTool({
-						name: "norn_state_list",
-						label: "Attached workflow state",
-						description: "List only attached workflow-state field IDs, permissions and value schemas. JSON is paginated; use nextOffset until null.",
-						parameters: Type.Object(pageParameters),
-						async execute(_id, args) {
-							return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: inspectSchema(field.schema) })), ...args });
-						},
-					}),
-					defineTool({
-						name: "norn_state_get",
-						label: "Read workflow state",
-						description: "Read a selected workflow-state field. Unset fields return isSet:false. JSON is paginated; concurrent writes can change later pages, so compare revision before combining pages.",
-						parameters: Type.Object({ key: Type.String(), ...pageParameters }),
-						async execute(_id, args) {
-							const value = await input.state.getOptional(selectField(args.key, "read"));
-							return serializePage({ value: value === undefined ? { isSet: false } : { isSet: true, value }, ...args });
-						},
-					}),
-					defineTool({
-						name: "norn_state_set",
-						label: "Write workflow state",
-						description: "Set an explicitly writable workflow-state field. Validate the value against its schema from norn_state_list. A get followed by set is not a transaction.",
-						parameters: Type.Object({ key: Type.String(), value: Type.Unknown() }),
-						async execute(_id, args, signal) {
-							signal?.throwIfAborted();
-							const field = selectField(args.key, "write");
-							await input.state.set(field, args.value);
-							return { content: [{ type: "text", text: "Workflow state saved." }], details: {} };
-						},
-					}),
-				],
-				async dispose() {},
-			};
-		},
-	};
-}
-
-function serializePage(input: { readonly value: unknown; readonly offset: number; readonly limit: number }) {
-	const serialized = JSON.stringify(input.value);
-	if (!Number.isInteger(input.offset) || input.offset < 0 || !Number.isInteger(input.limit) || input.limit < 1 || input.limit > 10000) throw new Error("Invalid state output page");
-	const end = Math.min(serialized.length, input.offset + input.limit);
-	const details = { text: serialized.slice(input.offset, end), nextOffset: end < serialized.length ? end : null, revision: createHash("sha256").update(serialized).digest("hex") };
-	return { content: [{ type: "text" as const, text: JSON.stringify(details) }], details };
-}

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

@@ -1,26 +0,0 @@
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
-import type { NornArtifactRef } from "@vimhead.dev/norn";
-
-export class NornArtifacts {
-	constructor(private readonly artifactsRoot: string, private readonly files: NornFileCoordinator) {}
-
-	async write(path: string, content: string): Promise<NornArtifactRef> {
-		await this.files.writeText(this.resolveArtifactPath(path), content);
-		return { path };
-	}
-
-	async read(ref: NornArtifactRef): Promise<string> {
-		return this.files.readText(this.resolveArtifactPath(ref.path));
-	}
-
-	private resolveArtifactPath(path: string): string {
-		if (isAbsolute(path)) throw new Error(`Artifact path must be relative: ${path}`);
-		const resolvedPath = resolve(this.artifactsRoot, path);
-		const relativePath = relative(this.artifactsRoot, resolvedPath);
-		if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
-			throw new Error(`Artifact path escapes artifacts directory: ${path}`);
-		}
-		return resolvedPath;
-	}
-}

package/assets/packages/cli/src/internal/resource-bindings.ts

@@ -1,35 +0,0 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { NornAgentResourceBinding, NornAgentResourceAdapter } from "@vimhead.dev/norn";
-
-export class NornSessionResourceBindings {
-	readonly tools: ToolDefinition[] = [];
-	private readonly bindings: NornAgentResourceBinding[] = [];
-
-	async bind(input: { readonly adapters: readonly NornAgentResourceAdapter[]; readonly runId: string; readonly label: string; readonly reservedTools: readonly string[] }): Promise<void> {
-		const adapterNames = new Set<string>();
-		const tools = new Set(input.reservedTools);
-		for (const adapter of input.adapters) {
-			if (adapterNames.has(adapter.name)) throw new Error(`Duplicate resource adapter: ${adapter.name}`);
-			adapterNames.add(adapter.name);
-			const binding = await adapter.bind({ runId: input.runId, label: input.label });
-			this.bindings.push(binding);
-			for (const tool of binding.tools) {
-				if (tools.has(tool.name)) throw new Error(`Resource tool name collision: ${tool.name}`);
-				tools.add(tool.name);
-				this.tools.push(tool);
-			}
-		}
-	}
-
-	async dispose(): Promise<void> {
-		const errors: unknown[] = [];
-		for (const binding of this.bindings.splice(0).reverse()) {
-			try {
-				await binding.dispose();
-			} catch (error) {
-				errors.push(error);
-			}
-		}
-		if (errors.length) throw new AggregateError(errors, "Resource binding cleanup failed");
-	}
-}

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

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

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

@@ -1,69 +0,0 @@
-import type { NornResourceDefinition, NornResources } from "@vimhead.dev/norn";
-import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
-import { isNodeError } from "@vimhead.dev/norn-core/errors";
-import { createRunFileCoordinator, type NornFileCoordinator } from "@vimhead.dev/norn/files";
-import { jsonValueSchema } from "@vimhead.dev/norn/schema";
-import { mkdir, readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { isDeepStrictEqual } from "node:util";
-import { Type, type StaticDecode } from "typebox";
-import { Value } from "typebox/value";
-
-const definitionSchema = Type.Object({ name: Type.String(), kind: Type.String({ minLength: 1 }), configuration: jsonValueSchema }, { additionalProperties: false });
-const recordSchema = Type.Object({ ...definitionSchema.properties, isInitialized: Type.Boolean() }, { additionalProperties: false });
-
-export class NornRunResources implements NornResources {
-	readonly files: NornFileCoordinator;
-	private readonly entries = new Map<string, { readonly definition: StaticDecode<typeof definitionSchema>; readonly value: Promise<unknown> }>();
-
-	private constructor(private readonly runRoot: string) {
-		this.files = createRunFileCoordinator(runRoot);
-	}
-
-	static async initialize(runRoot: string): Promise<NornRunResources> {
-		const resources = new NornRunResources(resolve(runRoot));
-		await mkdir(join(resources.runRoot, "current", "resources"), { recursive: true });
-		return resources;
-	}
-
-	async ensure<T>(definition: NornResourceDefinition<T>): Promise<T> {
-		if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(definition.name)) throw new Error(`Invalid resource name: ${definition.name}`);
-		const identity = structuredClone(Value.Parse(definitionSchema, { name: definition.name, kind: definition.kind, configuration: definition.configuration }));
-		const existing = this.entries.get(definition.name);
-		if (existing) {
-			if (!isDeepStrictEqual(existing.definition, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-			return existing.value as Promise<T>;
-		}
-		const value = this.initializeResource(definition, identity);
-		const entry = { definition: identity, value };
-		this.entries.set(definition.name, entry);
-		try {
-			return await value;
-		} catch (error) {
-			if (this.entries.get(definition.name) === entry) this.entries.delete(definition.name);
-			throw error;
-		}
-	}
-
-	private async initializeResource<T>(definition: NornResourceDefinition<T>, identity: StaticDecode<typeof definitionSchema>): Promise<T> {
-		const directory = join(this.runRoot, "current", "resources", definition.name);
-		await mkdir(directory, { recursive: true });
-		return this.files.withExclusiveLock(join(directory, "definition.json"), async (path) => {
-			let stored: StaticDecode<typeof recordSchema> | undefined;
-			try {
-				stored = Value.Parse(recordSchema, JSON.parse(await readFile(path, "utf8")));
-			} catch (error) {
-				if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-			}
-			if (stored) {
-				const { isInitialized: _isInitialized, ...storedIdentity } = stored;
-				if (!isDeepStrictEqual(storedIdentity, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-			} else {
-				await writeJsonAtomically(path, { ...identity, isInitialized: false });
-			}
-			const value = await definition.initialize({ directory, files: this.files, mode: stored?.isInitialized ? "open" : "create" });
-			if (!stored?.isInitialized) await writeJsonAtomically(path, { ...identity, isInitialized: true });
-			return value;
-		});
-	}
-}

package/assets/packages/sdk/src/agent-resource-adapter.ts

@@ -1,11 +0,0 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-
-export type NornAgentResourceBinding = {
-	readonly tools: readonly ToolDefinition[];
-	dispose(): Promise<void>;
-};
-
-export type NornAgentResourceAdapter = {
-	readonly name: string;
-	bind(context: { readonly runId: string; readonly label: string }): Promise<NornAgentResourceBinding>;
-};

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

@@ -1,20 +0,0 @@
-import type { NornFileCoordinator } from "./files.ts";
-import type { NornJsonValue } from "./schema.ts";
-
-export type NornResourceContext = {
-	readonly mode: "create" | "open";
-	readonly directory: string;
-	readonly files: NornFileCoordinator;
-};
-
-export type NornResourceDefinition<T> = {
-	readonly name: string;
-	readonly kind: string;
-	readonly configuration: NornJsonValue;
-	initialize(context: NornResourceContext): Promise<T>;
-};
-
-export type NornResources = {
-	readonly files: NornFileCoordinator;
-	ensure<T>(definition: NornResourceDefinition<T>): Promise<T>;
-};

package/dist/internal/artifacts.d.ts

@@ -1,10 +0,0 @@
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
-import type { NornArtifactRef } from "@vimhead.dev/norn";
-export declare class NornArtifacts {
-    private readonly artifactsRoot;
-    private readonly files;
-    constructor(artifactsRoot: string, files: NornFileCoordinator);
-    write(path: string, content: string): Promise<NornArtifactRef>;
-    read(ref: NornArtifactRef): Promise<string>;
-    private resolveArtifactPath;
-}

package/dist/internal/artifacts.js

@@ -1,29 +0,0 @@
-// src/internal/artifacts.ts
-import { isAbsolute, relative, resolve, sep } from "node:path";
-var NornArtifacts = class {
-  constructor(artifactsRoot, files) {
-    this.artifactsRoot = artifactsRoot;
-    this.files = files;
-  }
-  artifactsRoot;
-  files;
-  async write(path, content) {
-    await this.files.writeText(this.resolveArtifactPath(path), content);
-    return { path };
-  }
-  async read(ref) {
-    return this.files.readText(this.resolveArtifactPath(ref.path));
-  }
-  resolveArtifactPath(path) {
-    if (isAbsolute(path)) throw new Error(`Artifact path must be relative: ${path}`);
-    const resolvedPath = resolve(this.artifactsRoot, path);
-    const relativePath = relative(this.artifactsRoot, resolvedPath);
-    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
-      throw new Error(`Artifact path escapes artifacts directory: ${path}`);
-    }
-    return resolvedPath;
-  }
-};
-export {
-  NornArtifacts
-};

package/dist/internal/resource-bindings.d.ts

@@ -1,13 +0,0 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { NornAgentResourceAdapter } from "@vimhead.dev/norn";
-export declare class NornSessionResourceBindings {
-    readonly tools: ToolDefinition[];
-    private readonly bindings;
-    bind(input: {
-        readonly adapters: readonly NornAgentResourceAdapter[];
-        readonly runId: string;
-        readonly label: string;
-        readonly reservedTools: readonly string[];
-    }): Promise<void>;
-    dispose(): Promise<void>;
-}

package/dist/internal/resource-bindings.js

@@ -1,34 +0,0 @@
-// src/internal/resource-bindings.ts
-var NornSessionResourceBindings = class {
-  tools = [];
-  bindings = [];
-  async bind(input) {
-    const adapterNames = /* @__PURE__ */ new Set();
-    const tools = new Set(input.reservedTools);
-    for (const adapter of input.adapters) {
-      if (adapterNames.has(adapter.name)) throw new Error(`Duplicate resource adapter: ${adapter.name}`);
-      adapterNames.add(adapter.name);
-      const binding = await adapter.bind({ runId: input.runId, label: input.label });
-      this.bindings.push(binding);
-      for (const tool of binding.tools) {
-        if (tools.has(tool.name)) throw new Error(`Resource tool name collision: ${tool.name}`);
-        tools.add(tool.name);
-        this.tools.push(tool);
-      }
-    }
-  }
-  async dispose() {
-    const errors = [];
-    for (const binding of this.bindings.splice(0).reverse()) {
-      try {
-        await binding.dispose();
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    if (errors.length) throw new AggregateError(errors, "Resource binding cleanup failed");
-  }
-};
-export {
-  NornSessionResourceBindings
-};

package/dist/internal/run.d.ts

@@ -1,49 +0,0 @@
-import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
-import type { NornAnyWorkflowDeclaration, NornProjectRun, NornRunOutcomeMetadata, NornWorkflowIsolationMode, NornRun } from "@vimhead.dev/norn";
-import type { NornAgentResponseCollector } from "./agent-response-tool.ts";
-import type { NornArtifacts } from "./artifacts.ts";
-import type { NornRunLogs } from "./logs.ts";
-import type { NornRunLogger } from "./run-log.ts";
-import type { NornRunResources } from "../resources.ts";
-type DefaultNornRunInput = {
-    readonly id: string;
-    readonly runRoot: string;
-    readonly projectRoot: string;
-    readonly workspace: string;
-    readonly cwd: string;
-    readonly isolationMode: NornWorkflowIsolationMode;
-    readonly signal?: AbortSignal;
-    readonly model?: CreateAgentSessionOptions["model"];
-    readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
-    readonly agentDir?: string;
-    readonly responseCollector: NornAgentResponseCollector;
-    readonly resources: NornRunResources;
-    readonly logger: NornRunLogger;
-    readonly artifacts: NornArtifacts;
-    readonly logs: NornRunLogs;
-};
-export declare class NornRunContext implements NornProjectRun {
-    private readonly input;
-    readonly resources: NornRunResources;
-    readonly artifacts: NornRun["artifacts"];
-    readonly logs: NornRun["logs"];
-    readonly commands: NornRun["commands"];
-    readonly agents: NornRun["agents"];
-    readonly id: string;
-    readonly workspace: string;
-    readonly projectRoot: string;
-    readonly cwd: string;
-    constructor(input: DefaultNornRunInput);
-    forWorkflow(workflow: NornAnyWorkflowDeclaration): NornRunContext;
-    private get boundaryRoot();
-    private createAgentRunner;
-    path(relativePath: string): string;
-    projectPath(relativePath: string): string;
-    next(workflowId: string, args: unknown): ReturnType<NornRun["next"]>;
-    complete(metadata?: NornRunOutcomeMetadata): ReturnType<NornRun["complete"]>;
-    fail(metadata: NornRunOutcomeMetadata & {
-        readonly summary: string;
-    }): ReturnType<NornRun["fail"]>;
-    private resolveFromRoot;
-}
-export {};