@vimhead.dev/norn-cli 0.1.0-tip.0

package/dist/client.d.ts

@@ -0,0 +1,48 @@
+import type { DeletedNornRunInfo, NornProjectInspection, NornWorkflowCatalogInfo, NornWorkflowInspection, NornRunCheckpoint, NornRunInfo, NornRunMetrics, NornWorkflowStateReader } from "@vimhead.dev/norn";
+import type { NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
+import type { NornResolvedSeerModeConfig } from "@vimhead.dev/norn/seer";
+export { NornProjectLoadError } from "./internal/errors.ts";
+export type NornClientInput = {
+    readonly spawnCwd?: string;
+    readonly executablePath?: string;
+};
+export type NornClient = {
+    readonly project: {
+        inspect(): Promise<NornProjectInspection>;
+    };
+    readonly workflows: {
+        list(options?: {
+            readonly all?: boolean;
+        }): Promise<NornWorkflowCatalogInfo>;
+        inspect(workflowId: string): Promise<NornWorkflowInspection>;
+        entries(): Promise<readonly NornRegisteredWorkflow[]>;
+    };
+    readonly state: NornWorkflowStateReader;
+    readonly seer: {
+        inspect(): Promise<NornResolvedSeerModeConfig | null>;
+    };
+    readonly runs: {
+        start(input: {
+            readonly workflowId: string;
+            readonly params: unknown;
+            readonly configOverride?: unknown;
+        }): Promise<NornRunInfo>;
+        resume(input: {
+            readonly run: string;
+            readonly params?: unknown;
+        }): Promise<NornRunInfo>;
+        wait(run: string): Promise<NornRunInfo>;
+        list(): Promise<NornRunInfo[]>;
+        inspect(run: string): Promise<NornRunInfo>;
+        checkpoints(run: string): Promise<NornRunCheckpoint[]>;
+        metrics(run: string): Promise<NornRunMetrics>;
+        rollback(run: string, checkpointId: string): Promise<NornRunInfo>;
+        stop(run: string): Promise<NornRunInfo>;
+        kill(run: string): Promise<NornRunInfo>;
+        delete(run: string): Promise<DeletedNornRunInfo>;
+        logs(run: string, options?: {
+            readonly follow?: boolean;
+        }): AsyncIterable<Record<string, unknown>>;
+    };
+};
+export declare function createNornClient(input?: NornClientInput): NornClient;

package/dist/client.js

@@ -0,0 +1,118 @@
+// src/client.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+import { loadNornProject } from "./plugin-loader.js";
+import { NornProjectLoadError } from "./internal/errors.js";
+import { NornProjectLoadError as NornProjectLoadError2 } from "./internal/errors.js";
+function createNornClient(input = {}) {
+  const processRunner = new NornProcessRunner(input);
+  const catalog = new NornWorkflowCatalog(input.spawnCwd ?? process.cwd());
+  const client = {
+    project: {
+      inspect: async () => processRunner.readJson(["project", "inspect"])
+    },
+    workflows: {
+      list: async (options) => processRunner.readJson(["workflows", "list", ...options?.all ? ["--all"] : []]),
+      inspect: async (workflowId) => processRunner.readJson(["workflows", "inspect", workflowId]),
+      entries: async () => (await catalog.load()).workflows
+    },
+    state: catalog.state,
+    seer: {
+      inspect: async () => (await processRunner.readJson(["seer", "inspect"])).seerMode
+    },
+    runs: {
+      start: async (startInput) => (await processRunner.readJson(["runs", "start", startInput.workflowId], JSON.stringify(runStartInput(startInput)))).run,
+      resume: async (resumeInput) => (await processRunner.readJson(["runs", "resume", resumeInput.run], runResumeStdin(resumeInput))).run,
+      wait: async (run) => (await processRunner.readJson(["runs", "wait", run])).run,
+      list: async () => (await processRunner.readJson(["runs", "list"])).runs,
+      inspect: async (run) => (await processRunner.readJson(["runs", "inspect", run])).run,
+      checkpoints: async (run) => (await processRunner.readJson(["runs", "checkpoints", run])).checkpoints,
+      metrics: async (run) => (await processRunner.readJson(["runs", "metrics", run])).metrics,
+      rollback: async (run, checkpointId) => (await processRunner.readJson(["runs", "rollback", run, checkpointId])).run,
+      stop: async (run) => (await processRunner.readJson(["runs", "stop", run])).run,
+      kill: async (run) => (await processRunner.readJson(["runs", "kill", run])).run,
+      delete: async (run) => (await processRunner.readJson(["runs", "delete", run])).deleted,
+      logs: (run, options) => processRunner.readJsonLines(["runs", "logs", run, ...options?.follow ? ["--follow"] : []])
+    }
+  };
+  return client;
+}
+var NornWorkflowCatalog = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  cwd;
+  loaded;
+  state = {
+    get: async (state) => (await this.load()).state.get(state),
+    getOptional: async (state) => (await this.load()).state.getOptional(state)
+  };
+  load() {
+    this.loaded ??= loadNornProject(this.cwd).catch((error) => {
+      this.loaded = void 0;
+      throw error;
+    });
+    return this.loaded;
+  }
+};
+var NornProcessRunner = class {
+  constructor(input) {
+    this.input = input;
+    this.executablePath = input.executablePath ?? fileURLToPath(new URL("../bin/norn.mjs", import.meta.url));
+  }
+  input;
+  executablePath;
+  async readJson(args, stdin) {
+    const result = await this.spawn(args, stdin);
+    const parsed = JSON.parse(result.stdout);
+    if (parsed && typeof parsed === "object" && "error" in parsed) {
+      if (parsed.error?.code === "NORN_PROJECT_INVALID" && Array.isArray(parsed.error.diagnostics)) throw new NornProjectLoadError({ diagnostics: parsed.error.diagnostics });
+      throw new Error(parsed.error?.message ?? "Norn command failed");
+    }
+    if (result.exitCode !== 0) throw new Error(result.stderr || `Norn exited with code ${result.exitCode}`);
+    return parsed;
+  }
+  async *readJsonLines(args) {
+    const child = spawn(process.execPath, [this.executablePath, ...args], { cwd: this.input.spawnCwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const lines = createInterface({ input: child.stdout });
+    for await (const line of lines) {
+      if (line.trim().length === 0) continue;
+      const parsed = JSON.parse(line);
+      if (parsed.error) throw new Error(String(parsed.error.message ?? "Norn stream failed"));
+      yield parsed;
+    }
+    const exitCode = await new Promise((resolvePromise) => child.on("close", resolvePromise));
+    if (exitCode !== 0) throw new Error(stderr || `Norn exited with code ${exitCode}`);
+  }
+  async spawn(args, stdin) {
+    return new Promise((resolvePromise, reject) => {
+      const child = spawn(process.execPath, [this.executablePath, ...args], { cwd: this.input.spawnCwd, stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("error", reject);
+      if (stdin !== void 0) child.stdin?.end(stdin);
+      child.on("close", (exitCode) => resolvePromise({ stdout, stderr, exitCode }));
+    });
+  }
+};
+function runStartInput(input) {
+  return input.configOverride === void 0 ? { params: input.params } : { params: input.params, config: input.configOverride };
+}
+function runResumeStdin(input) {
+  return input.params === void 0 ? void 0 : JSON.stringify({ params: input.params });
+}
+export {
+  NornProjectLoadError2 as NornProjectLoadError,
+  createNornClient
+};

package/dist/documentation-intro.d.ts

@@ -0,0 +1,5 @@
+import type { NornDocumentationLocation } from "./documentation.ts";
+export declare function renderNornDocumentationIntro(input: {
+    readonly documentation: NornDocumentationLocation;
+    readonly invocation: readonly [string, ...string[]];
+}): string;

package/dist/documentation-intro.js

@@ -0,0 +1,29 @@
+// src/documentation-intro.ts
+function renderNornDocumentationIntro(input) {
+  const { documentation, invocation } = input;
+  return [
+    "# Norn",
+    "Norn is a harness-agnostic workflow runtime built primarily for agents. Build agent-driven and code-driven TypeScript workflows with the Norn SDK; use the CLI to discover, run, inspect, and recover them. Norn agents are powered by the bundled, open-source and extensible Pi coding agent, independently of the outer harness. Capabilities can be authored, exercised, repaired, and reused during a task; Norn is optional.",
+    "",
+    `Runtime argv (JSON array; CLI arguments follow these entries): ${JSON.stringify(invocation)}`,
+    `Version: ${JSON.stringify(documentation.version)}; build commit: ${documentation.commit === null ? "unknown" : JSON.stringify(documentation.commit)}`,
+    "",
+    `Documentation index and topic routing: ${JSON.stringify(documentation.paths.index)}`,
+    `Main README: ${JSON.stringify(documentation.paths.readme)}`,
+    `Documentation directory: ${JSON.stringify(documentation.paths.docs)}`,
+    `Runnable examples: ${JSON.stringify(documentation.paths.examples)}`,
+    "Relative documentation links resolve from the containing file, not the task's working directory.",
+    "",
+    "| Rule | GOOD | BAD |",
+    "|---|---|---|",
+    "| IF authoring or repairing a Norn capability, THEN read the index and relevant linked documentation/examples. ELSE leave unrelated documentation unloaded. | Read the Norn agents reference before creating an agent. | Guess the API or load every manual upfront. |",
+    "",
+    "Live CLI contracts (argument arrays appended to the runtime argv above):",
+    '- ["workflows", "list"] \u2014 currently registered entrypoints.',
+    '- ["workflows", "inspect", "<workflow-id>"] \u2014 current instructions, params schema, and source.',
+    '- ["help"] \u2014 command usage.'
+  ].join("\n");
+}
+export {
+  renderNornDocumentationIntro
+};

package/dist/documentation.d.ts

@@ -0,0 +1,33 @@
+import type { NornBuildInfo } from "./build-info.ts";
+import { type NornDocumentationBundle } from "./internal/documentation-bundle.ts";
+export { renderNornDocumentationIntro } from "./documentation-intro.ts";
+export type NornDocumentationSource = {
+    readonly kind: "local";
+    readonly root: string;
+} | {
+    readonly kind: "embedded";
+    readonly bundle: NornDocumentationBundle;
+};
+export type NornDocumentationLocation = {
+    readonly storage: "installation" | "cache";
+    readonly version: string;
+    readonly commit: string | null;
+    readonly assetDigest: string | null;
+    readonly paths: {
+        readonly root: string;
+        readonly readme: string;
+        readonly index: string;
+        readonly docs: string;
+        readonly examples: string;
+    };
+};
+export declare function resolveDocumentationCacheRoot(input: {
+    readonly platform: string;
+    readonly home: string;
+    readonly environment: Readonly<Record<string, string | undefined>>;
+}): string;
+export declare function resolveNornDocumentation(input: {
+    readonly source: NornDocumentationSource;
+    readonly build: NornBuildInfo;
+    readonly cacheRoot: string;
+}): Promise<NornDocumentationLocation>;

package/dist/documentation.js

@@ -0,0 +1,132 @@
+// src/documentation.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DOCUMENTATION_PATHS, hashDocumentationBundle, validateDocumentationBundle } from "./internal/documentation-bundle.js";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/documentation.ts
+import { renderNornDocumentationIntro } from "./documentation-intro.js";
+function resolveDocumentationCacheRoot(input) {
+  const override = input.environment.NORN_DOCS_CACHE_DIR;
+  if (override) return resolve(override);
+  if (input.platform === "win32") return join(input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"), "norn", "docs");
+  if (input.platform === "darwin") return join(input.home, "Library", "Caches", "norn", "docs");
+  const xdgCache = input.environment.XDG_CACHE_HOME;
+  return join(xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"), "norn", "docs");
+}
+async function resolveNornDocumentation(input) {
+  let root;
+  let version;
+  let assetDigest = null;
+  if (input.source.kind === "local") {
+    root = resolve(input.source.root);
+    const packageInfo = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+    if (typeof packageInfo.version !== "string" || packageInfo.version.length === 0) throw new Error("Invalid documentation package version");
+    version = packageInfo.version;
+    if (version !== input.build.version) throw new Error("Local documentation version does not match the runtime; rebuild or reinstall this CLI package");
+    await validateLocalDocumentation(root);
+  } else {
+    validateDocumentationBundle(input.source.bundle);
+    version = input.source.bundle.version;
+    if (version !== input.build.version) throw new Error("Embedded documentation version does not match the binary build");
+    assetDigest = hashDocumentationBundle(input.source.bundle);
+    const cacheKey = createHash("sha256").update(JSON.stringify({ format: 1, assetDigest, version, commit: input.build.commit })).digest("hex");
+    root = await new NornDocumentationCache({ cacheRoot: resolve(input.cacheRoot), cacheKey, bundle: input.source.bundle }).materialize();
+  }
+  return {
+    storage: input.source.kind === "local" ? "installation" : "cache",
+    version,
+    commit: input.build.commit,
+    assetDigest,
+    paths: {
+      root,
+      readme: join(root, DOCUMENTATION_PATHS.readme),
+      index: join(root, DOCUMENTATION_PATHS.index),
+      docs: join(root, DOCUMENTATION_PATHS.docs),
+      examples: join(root, DOCUMENTATION_PATHS.examples)
+    }
+  };
+}
+async function validateLocalDocumentation(root) {
+  for (const [key, path] of Object.entries(DOCUMENTATION_PATHS)) {
+    const stat = await lstat(join(root, path));
+    const isExpectedType = key === "docs" || key === "examples" ? stat.isDirectory() : stat.isFile();
+    if (!isExpectedType) throw new Error(`Invalid local documentation path: ${join(root, path)}`);
+  }
+}
+var NornDocumentationCache = class {
+  constructor(input) {
+    this.input = input;
+    this.root = join(input.cacheRoot, `v1-${input.cacheKey}`);
+    this.files = new Map(input.bundle.files.map((file) => [file.path, file.content]));
+  }
+  input;
+  root;
+  files;
+  async materialize() {
+    await mkdir(this.input.cacheRoot, { recursive: true, mode: 448 });
+    const cacheStat = await lstat(this.input.cacheRoot);
+    if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink()) throw new Error(`Documentation cache root must be a real directory: ${this.input.cacheRoot}`);
+    if (await this.validateExistingCache()) return this.root;
+    const staging = await mkdtemp(join(this.input.cacheRoot, ".extract-"));
+    try {
+      for (const file of this.input.bundle.files) {
+        const parts = file.path.split("/");
+        await mkdir(join(staging, ...parts.slice(0, -1)), { recursive: true, mode: 448 });
+        await writeFile(join(staging, ...parts), file.content, { encoding: "utf8", flag: "wx", mode: 384 });
+      }
+      try {
+        await rename(staging, this.root);
+      } catch (error) {
+        if (!isNodeError(error) || !["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "")) throw error;
+        if (!await this.validateExistingCache()) throw error;
+      }
+      if (!await this.validateExistingCache()) throw new Error(`Documentation cache disappeared after extraction: ${this.root}`);
+      return this.root;
+    } finally {
+      await rm(staging, { recursive: true, force: true });
+    }
+  }
+  async validateExistingCache() {
+    let stat;
+    try {
+      stat = await lstat(this.root);
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return false;
+      throw error;
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw this.invalidCacheError();
+    const seenFiles = /* @__PURE__ */ new Set();
+    await this.validateDirectory({ directory: this.root, prefix: "", seenFiles });
+    if (seenFiles.size !== this.files.size) throw this.invalidCacheError();
+    return true;
+  }
+  async validateDirectory(input) {
+    for (const entry of await readdir(input.directory, { withFileTypes: true })) {
+      const path = input.prefix ? `${input.prefix}/${entry.name}` : entry.name;
+      const absolutePath = join(input.directory, entry.name);
+      if (entry.isDirectory()) {
+        if (![...this.files.keys()].some((file) => file.startsWith(`${path}/`))) throw this.invalidCacheError();
+        await this.validateDirectory({ directory: absolutePath, prefix: path, seenFiles: input.seenFiles });
+      } else if (entry.isFile() && this.files.has(path)) {
+        if (!(await readFile(absolutePath)).equals(Buffer.from(this.files.get(path), "utf8"))) throw this.invalidCacheError();
+        input.seenFiles.add(path);
+      } else {
+        throw this.invalidCacheError();
+      }
+    }
+  }
+  invalidCacheError() {
+    return new Error(`Documentation cache is incomplete or modified: ${this.root}. Remove this cache entry and retry; copy examples elsewhere before editing them.`);
+  }
+};
+export {
+  renderNornDocumentationIntro,
+  resolveDocumentationCacheRoot,
+  resolveNornDocumentation
+};

package/dist/generated-build-info.d.ts

@@ -0,0 +1,10 @@
+export declare const NORN_GENERATED_BUILD_INFO: {
+    readonly kind: "npm-registry";
+    readonly version: "0.1.0-tip.0";
+    readonly commit: "f5872d022f9a38d5c0828bf39fa4ad49ca536caa";
+    readonly packageSpec: "@vimhead.dev/norn-cli@tip";
+    readonly upgrade: {
+        readonly supported: false;
+        readonly reason: "Update @vimhead.dev/norn-cli@tip through your package manager in its existing installation scope (npm install -g only for global npm installations).";
+    };
+};

package/dist/generated-build-info.js

@@ -0,0 +1,14 @@
+// src/generated-build-info.ts
+var NORN_GENERATED_BUILD_INFO = {
+  "kind": "npm-registry",
+  "version": "0.1.0-tip.0",
+  "commit": "f5872d022f9a38d5c0828bf39fa4ad49ca536caa",
+  "packageSpec": "@vimhead.dev/norn-cli@tip",
+  "upgrade": {
+    "supported": false,
+    "reason": "Update @vimhead.dev/norn-cli@tip through your package manager in its existing installation scope (npm install -g only for global npm installations)."
+  }
+};
+export {
+  NORN_GENERATED_BUILD_INFO
+};

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

@@ -0,0 +1,4 @@
+export declare function resolveNornAgentDirectory(input: {
+    home: string;
+    environment: NodeJS.ProcessEnv;
+}): string;

package/dist/internal/agent-directory.js

@@ -0,0 +1,8 @@
+// src/internal/agent-directory.ts
+import { join, resolve } from "node:path";
+function resolveNornAgentDirectory(input) {
+  return resolve(input.environment.NORN_AGENT_DIR || join(input.home, ".norn", "agent"));
+}
+export {
+  resolveNornAgentDirectory
+};

package/dist/internal/agent-response-tool.d.ts

@@ -0,0 +1,21 @@
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { z } from "zod";
+import type { NornDispose } from "@vimhead.dev/norn";
+export type NornCapturedAgentResponse = {
+    readonly called: boolean;
+    readonly response?: unknown;
+};
+export declare class NornAgentResponseCollector {
+    private readonly pending;
+    begin(runId: string, label: string, responseSchema: z.ZodType): NornDispose;
+    capture(runId: string, label: string, response: unknown): {
+        label: string;
+        response: unknown;
+    };
+    get(runId: string): NornCapturedAgentResponse;
+}
+export declare class NornAgentResponseToolFactory {
+    private readonly responseCollector;
+    constructor(responseCollector: NornAgentResponseCollector);
+    create(): ToolDefinition;
+}

package/dist/internal/agent-response-tool.js

@@ -0,0 +1,79 @@
+// src/internal/agent-response-tool.ts
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+// ../core/src/agent-protocol.ts
+var AGENT_RESPONSE_TOOL_NAME = "pi_workflows_agent_response";
+
+// src/internal/agent-response-tool.ts
+import { zodErrorMessage } from "./errors.js";
+var NornAgentResponseCollector = class {
+  pending = /* @__PURE__ */ new Map();
+  begin(runId, label, responseSchema) {
+    this.pending.set(runId, { label, responseSchema, called: false });
+    return () => this.pending.delete(runId);
+  }
+  capture(runId, label, response) {
+    const pending = this.pending.get(runId);
+    if (!pending) throw new Error(`No active workflow agent response slot: ${runId}`);
+    if (pending.label !== label) {
+      throw new Error(`Workflow agent response label mismatch: expected ${pending.label}, received ${label}`);
+    }
+    if (pending.called) throw new Error(`Workflow agent response already recorded for ${runId}`);
+    const parsed = pending.responseSchema.safeParse(response);
+    if (!parsed.success) throw new Error(zodErrorMessage(parsed.error));
+    pending.called = true;
+    pending.response = parsed.data;
+    return { label: pending.label, response: parsed.data };
+  }
+  get(runId) {
+    const pending = this.pending.get(runId);
+    return pending ? { called: pending.called, response: pending.response } : { called: false };
+  }
+};
+var NornAgentResponseToolFactory = class {
+  constructor(responseCollector) {
+    this.responseCollector = responseCollector;
+  }
+  responseCollector;
+  create() {
+    const responseCollector = this.responseCollector;
+    return defineTool({
+      name: AGENT_RESPONSE_TOOL_NAME,
+      label: "Workflow Agent Response",
+      description: "Record the final structured response for a Norn nested agent run.",
+      promptSnippet: "Record a final structured response for Norn agent automation",
+      promptGuidelines: [
+        `Use ${AGENT_RESPONSE_TOOL_NAME} as your final action when a workflow prompt gives you a workflow response runId.`,
+        `After calling ${AGENT_RESPONSE_TOOL_NAME}, do not emit another assistant response in the same turn.`
+      ],
+      parameters: Type.Object({
+        runId: Type.String({ description: "The exact workflow response runId provided in the prompt." }),
+        label: Type.String({ description: "The exact workflow agent label provided in the prompt." }),
+        response: Type.Unknown({ description: "The structured response object requested by the workflow." })
+      }),
+      async execute(_toolCallId, params) {
+        try {
+          const captured = responseCollector.capture(params.runId, params.label, params.response);
+          return {
+            content: [{ type: "text", text: `Recorded workflow agent response for ${captured.label}.` }],
+            details: { valid: true, runId: params.runId, label: captured.label, response: captured.response },
+            terminate: true
+          };
+        } catch (error) {
+          return invalidAgentResponseToolResult(error instanceof Error ? error.message : String(error));
+        }
+      }
+    });
+  }
+};
+function invalidAgentResponseToolResult(error) {
+  return {
+    content: [{ type: "text", text: `Invalid workflow agent response: ${error}. Call the tool again with a corrected response.` }],
+    details: { valid: false, error }
+  };
+}
+export {
+  NornAgentResponseCollector,
+  NornAgentResponseToolFactory
+};

package/dist/internal/agents.d.ts

@@ -0,0 +1,29 @@
+import { type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import { z } from "zod";
+import type { NornAgentCreateSessionInput, NornAgentSession, NornAgentSinglePromptInput } from "@vimhead.dev/norn";
+import { NornAgentResponseCollector } from "./agent-response-tool.ts";
+import type { NornRunLogs } from "./logs.ts";
+import type { NornRunLogger } from "./run-log.ts";
+type NornAgentRunnerInput = {
+    readonly id: string;
+    readonly runRoot: string;
+    readonly boundaryRoot: string;
+    readonly boundaryName: string;
+    readonly cwd: string;
+    readonly signal?: AbortSignal;
+    readonly model?: CreateAgentSessionOptions["model"];
+    readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+    readonly agentDir?: string;
+    readonly logs: NornRunLogs;
+    readonly logger: NornRunLogger;
+    readonly responseCollector: NornAgentResponseCollector;
+};
+export declare class NornAgentRunner {
+    private readonly input;
+    private readonly responseToolFactory;
+    constructor(input: NornAgentRunnerInput);
+    createSession(agentInput: NornAgentCreateSessionInput): Promise<NornAgentSession>;
+    prompt<ResponseSchema extends z.ZodType>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>>;
+    private resolveFromCwd;
+}
+export {};