@pi-harness/pi-harness 0.1.1

package/packages/core/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@pi-harness/core",
+  "version": "0.1.1",
+  "description": "Cordis boot and Pi runtime plugins for Pi Harness",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./plugins/*": {
+      "types": "./dist/plugins/*.d.ts",
+      "import": "./dist/plugins/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "profiles"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "typecheck": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.1",
+    "@deepseek-ai/cordis-plugin-group": "1.0.1",
+    "@deepseek-ai/cordis-plugin-hmr": "1.0.16",
+    "@deepseek-ai/cordis-plugin-include": "1.0.6",
+    "@deepseek-ai/cordis-plugin-loader": "1.0.2",
+    "@deepseek-ai/cordis-plugin-logger-console": "1.0.1",
+    "@deepseek-ai/cordis-plugin-timer": "1.1.3",
+    "@deepseek-ai/schemastery": "3.18.1",
+    "@earendil-works/pi-agent-core": "0.84.4",
+    "@earendil-works/pi-ai": "0.84.4",
+    "@earendil-works/pi-coding-agent": "0.84.4"
+  }
+}

package/packages/core/profiles/default/cordis.yml

@@ -0,0 +1,35 @@
+- id: agent
+  name: cordis:group
+  group: true
+  config:
+    - id: models
+      name: "@pi-harness/core/plugins/models"
+      config:
+        provider: deepseek
+        model: deepseek-v4-flash
+        refreshOnCreate: false
+    - id: resources
+      name: "@pi-harness/core/plugins/resources"
+      config: {}
+    - id: model
+      name: "@pi-harness/core/plugins/model"
+      config: {}
+    - id: session
+      name: "@pi-harness/core/plugins/session"
+      config:
+        storage: jsonl
+    - id: tools
+      name: "@pi-harness/core/plugins/tools"
+      config:
+        names:
+          - read
+          - bash
+          - edit
+          - write
+    - id: runtime
+      name: "@pi-harness/core/plugins/runtime"
+      config:
+        thinkingLevel: medium
+    - id: stdio
+      name: "@pi-harness/core/plugins/stdio"
+      config: {}

package/packages/core/profiles/development/cordis.yml

@@ -0,0 +1,47 @@
+- id: logger
+  name: "@deepseek-ai/cordis-plugin-logger-console"
+  config: {}
+- id: timer
+  name: "@deepseek-ai/cordis-plugin-timer"
+  config: {}
+- id: hmr
+  name: "@deepseek-ai/cordis-plugin-hmr"
+  config:
+    base: !!js piHarnessLaunch.cwd
+    root:
+      - .
+- id: agent
+  name: cordis:group
+  group: true
+  config:
+    - id: models
+      name: "@pi-harness/core/plugins/models"
+      config:
+        provider: deepseek
+        model: deepseek-v4-flash
+        refreshOnCreate: false
+    - id: resources
+      name: "@pi-harness/core/plugins/resources"
+      config: {}
+    - id: model
+      name: "@pi-harness/core/plugins/model"
+      config: {}
+    - id: session
+      name: "@pi-harness/core/plugins/session"
+      config:
+        storage: jsonl
+    - id: tools
+      name: "@pi-harness/core/plugins/tools"
+      config:
+        names:
+          - read
+          - bash
+          - edit
+          - write
+    - id: runtime
+      name: "@pi-harness/core/plugins/runtime"
+      config:
+        thinkingLevel: medium
+    - id: stdio
+      name: "@pi-harness/core/plugins/stdio"
+      config: {}

package/packages/core/src/boot.ts

@@ -0,0 +1,103 @@
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Context, type FiberState } from "@deepseek-ai/cordis";
+import Group from "@deepseek-ai/cordis-plugin-group";
+import Include from "@deepseek-ai/cordis-plugin-include";
+import Loader, { type EntryOptions } from "@deepseek-ai/cordis-plugin-loader";
+
+class ReadonlyInclude extends Include {
+  override write(): void {}
+}
+
+export interface BootHarnessOptions {
+  configPath: string;
+  prepare?: (context: Context) => Promise<void> | void;
+  onFullReload?: () => void;
+  signal?: AbortSignal;
+}
+
+export interface BootedHarness {
+  readonly context: Context;
+  dispose(): Promise<void>;
+}
+
+const FIBER_PENDING = 0 as FiberState.PENDING;
+const FIBER_ACTIVE = 2 as FiberState.ACTIVE;
+const FIBER_FAILED = 3 as FiberState.FAILED;
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+
+async function assertEntriesActivated(context: Context): Promise<void> {
+  const loader = context.get("loader");
+  if (loader === undefined) throw new Error("Cordis Loader was disposed during startup");
+  const failures: string[] = [];
+  for (const entry of loader.entries()) {
+    if (entry.disabled) continue;
+    const fiber = entry.fiber;
+    if (fiber === undefined) {
+      failures.push(`${entry.options.name}: module did not load`);
+      continue;
+    }
+    if (fiber.state === FIBER_ACTIVE) continue;
+    if (fiber.state === FIBER_FAILED) {
+      try {
+        await fiber.await();
+      } catch (error) {
+        failures.push(`${entry.options.name}: ${formatError(error)}`);
+      }
+      continue;
+    }
+    if (fiber.state === FIBER_PENDING) {
+      const missing = Object.keys(fiber.inject).filter((service) => fiber.ctx.get(service) === undefined);
+      failures.push(`${entry.options.name}: pending (waiting for services: ${missing.join(", ") || "unknown"})`);
+      continue;
+    }
+    failures.push(`${entry.options.name}: fiber state ${String(fiber.state)}`);
+  }
+  if (failures.length > 0) throw new Error(`Cordis plugin tree did not activate:\n${failures.join("\n")}`);
+}
+
+async function mountProfile(context: Context, configPath: string): Promise<void> {
+  context.loader.builtins.include = ReadonlyInclude;
+  context.loader.builtins.group = Group;
+  const root: EntryOptions = {
+    id: "profile",
+    name: "cordis:include",
+    config: { path: pathToFileURL(configPath).href },
+  };
+  await context.loader.create(root);
+}
+
+export async function bootHarness(options: BootHarnessOptions): Promise<BootedHarness> {
+  const configPath = resolve(options.configPath);
+  const context = new Context();
+  const abort = () => {
+    void context.fiber.dispose().catch(() => {});
+  };
+  if (options.signal?.aborted) throw new Error("Pi Harness startup was aborted", { cause: options.signal.reason });
+  options.signal?.addEventListener("abort", abort, { once: true });
+  let stage = "host preparation";
+  try {
+    context.baseUrl = `${pathToFileURL(dirname(configPath)).href}/`;
+    await context.plugin(Loader);
+    if (options.onFullReload !== undefined) context.loader.exit = options.onFullReload;
+    await options.prepare?.(context);
+    stage = "plugin tree activation";
+    await mountProfile(context, configPath);
+    await context.get("loader")?.await();
+    if (context.get("loader") !== undefined) await assertEntriesActivated(context);
+  } catch (cause) {
+    await context.fiber.dispose();
+    throw new Error(`Pi Harness ${stage} failed: ${formatError(cause)}`, { cause });
+  } finally {
+    options.signal?.removeEventListener("abort", abort);
+  }
+  return {
+    context,
+    async dispose() {
+      await context.fiber.dispose();
+    },
+  };
+}

package/packages/core/src/context.ts

@@ -0,0 +1,3 @@
+import type { Context } from "@deepseek-ai/cordis";
+
+export type HarnessContext = Context;

package/packages/core/src/index.ts

@@ -0,0 +1,6 @@
+export * from "./boot.js";
+export type * from "./context.js";
+export * from "./profile.js";
+export * from "./runtime.js";
+export * from "./services.js";
+export * from "./stdio.js";

package/packages/core/src/plugins/model.ts

@@ -0,0 +1,12 @@
+import type { Context } from "@deepseek-ai/cordis";
+
+export default {
+  name: "pi-model",
+  inject: ["piModelRuntime", "piResources"],
+  apply(context: Context) {
+    const { runtime, provider, model: modelId } = context.piModelRuntime;
+    const model = runtime.getModel(provider, modelId);
+    if (model === undefined) throw new Error(`Pi model is not registered: ${provider}/${modelId}`);
+    context.provide("piModels", { runtime, model });
+  },
+};

package/packages/core/src/plugins/models.ts

@@ -0,0 +1,32 @@
+import { join } from "node:path";
+import type { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+
+export interface ModelsPluginConfig {
+  provider: string;
+  model: string;
+  refreshOnCreate?: boolean;
+}
+
+export const Config: z<ModelsPluginConfig> = z.object({
+  provider: z.string().required(),
+  model: z.string().required(),
+  refreshOnCreate: z.boolean().default(false),
+});
+
+export default {
+  name: "pi-models",
+  inject: ["piHarnessLaunch"],
+  Config,
+  async apply(context: Context, config: ModelsPluginConfig) {
+    const agentDir = context.piHarnessLaunch.agentDir;
+    const runtime = await ModelRuntime.create({
+      authPath: join(agentDir, "auth.json"),
+      modelsPath: join(agentDir, "models.json"),
+      modelsStorePath: join(agentDir, "models-store.json"),
+      refreshOnCreate: config.refreshOnCreate ?? false,
+    });
+    context.provide("piModelRuntime", { runtime, provider: config.provider, model: config.model });
+  },
+};

package/packages/core/src/plugins/resources.ts

@@ -0,0 +1,57 @@
+import type { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { createAgentSessionServices } from "@earendil-works/pi-coding-agent";
+
+export interface ResourcesPluginConfig {
+  noExtensions?: boolean;
+  noSkills?: boolean;
+  noPromptTemplates?: boolean;
+  noThemes?: boolean;
+  noContextFiles?: boolean;
+}
+
+export const Config: z<ResourcesPluginConfig> = z.object({
+  noExtensions: z.boolean().default(false),
+  noSkills: z.boolean().default(false),
+  noPromptTemplates: z.boolean().default(false),
+  noThemes: z.boolean().default(false),
+  noContextFiles: z.boolean().default(false),
+});
+
+export default {
+  name: "pi-resources",
+  inject: ["piHarnessLaunch", "piModelRuntime"],
+  Config,
+  async apply(context: Context, config: ResourcesPluginConfig) {
+    const services = await createAgentSessionServices({
+      cwd: context.piHarnessLaunch.cwd,
+      agentDir: context.piHarnessLaunch.agentDir,
+      modelRuntime: context.piModelRuntime.runtime,
+      resourceLoaderOptions: {
+        noExtensions: config.noExtensions ?? false,
+        noSkills: config.noSkills ?? false,
+        noPromptTemplates: config.noPromptTemplates ?? false,
+        noThemes: config.noThemes ?? false,
+        noContextFiles: config.noContextFiles ?? false,
+      },
+    });
+    const errors = services.diagnostics.filter((diagnostic) => diagnostic.type === "error");
+    if (errors.length > 0) throw new Error(`Pi resource loading failed:\n${errors.map((diagnostic) => diagnostic.message).join("\n")}`);
+    const resourceLoaderOptions = {
+      noExtensions: config.noExtensions ?? false,
+      noSkills: config.noSkills ?? false,
+      noPromptTemplates: config.noPromptTemplates ?? false,
+      noThemes: config.noThemes ?? false,
+      noContextFiles: config.noContextFiles ?? false,
+    };
+    context.provide("piResources", {
+      ...services,
+      createForCwd: (cwd: string) => createAgentSessionServices({
+        cwd,
+        agentDir: context.piHarnessLaunch.agentDir,
+        modelRuntime: context.piModelRuntime.runtime,
+        resourceLoaderOptions,
+      }),
+    });
+  },
+};

package/packages/core/src/plugins/runtime.ts

@@ -0,0 +1,73 @@
+import type { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { createAgentSessionFromServices, createAgentSessionRuntime, type AgentSession, type CreateAgentSessionRuntimeFactory } from "@earendil-works/pi-coding-agent";
+import { PiRuntime } from "../runtime.js";
+
+export interface RuntimePluginConfig {
+  thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+}
+
+export const Config: z<RuntimePluginConfig> = z.object({
+  thinkingLevel: z.union(["off", "minimal", "low", "medium", "high", "xhigh", "max"]).default("medium"),
+});
+
+export default {
+  name: "pi-runtime",
+  inject: ["piModels", "piResources", "piSession", "piTools"],
+  Config,
+  async apply(context: Context, config: RuntimePluginConfig) {
+    const tools = context.piTools.acquire();
+    context.effect(() => () => tools.release());
+    const requestedTools = [...tools.names, ...tools.customTools.map((tool) => tool.name)];
+    const createRuntime: CreateAgentSessionRuntimeFactory = async ({ cwd, sessionManager, sessionStartEvent }) => {
+      const services = cwd === context.piResources.cwd ? context.piResources : await context.piResources.createForCwd(cwd);
+      const result = await createAgentSessionFromServices({
+        services,
+        sessionManager,
+        ...(sessionStartEvent === undefined ? {} : { sessionStartEvent }),
+        model: context.piModels.model,
+        thinkingLevel: config.thinkingLevel ?? "medium",
+        tools: requestedTools,
+        customTools: tools.customTools,
+      });
+      return { ...result, services, diagnostics: services.diagnostics };
+    };
+    const sessionRuntime = await createAgentSessionRuntime(createRuntime, {
+      cwd: context.piResources.cwd,
+      agentDir: context.piResources.agentDir,
+      sessionManager: context.piSession.manager,
+    });
+    const runtime = new PiRuntime(sessionRuntime);
+    const bindSession = async (session: AgentSession): Promise<void> => {
+      const activeTools = new Set(session.getAllTools().map((tool) => tool.name));
+      const missingTools = requestedTools.filter((name) => !activeTools.has(name));
+      if (missingTools.length > 0) throw new Error(`Pi tools are not registered: ${missingTools.join(", ")}`);
+      await session.bindExtensions({
+        mode: "print",
+        abortHandler: () => {
+          void runtime.abort();
+        },
+        onError: (error) => {
+          context.emit("pi/extension-error", error);
+        },
+      });
+    };
+    context.provide("piRuntime", runtime);
+    let unsubscribe: (() => void) | undefined;
+    const rebindSession = async (session: AgentSession): Promise<void> => {
+      unsubscribe?.();
+      await bindSession(session);
+      unsubscribe = session.subscribe((event) => {
+        context.emit("pi/session-event", event);
+      });
+    };
+    sessionRuntime.setRebindSession(rebindSession);
+    await rebindSession(sessionRuntime.session);
+    context.effect(() => {
+      return async () => {
+        unsubscribe?.();
+        await runtime.dispose();
+      };
+    });
+  },
+};

package/packages/core/src/plugins/session.ts

@@ -0,0 +1,27 @@
+import { join, resolve } from "node:path";
+import type { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+
+export interface SessionPluginConfig {
+  storage?: "memory" | "jsonl";
+  directory?: string;
+}
+
+export const Config: z<SessionPluginConfig> = z.object({
+  storage: z.union(["memory", "jsonl"]).default("jsonl"),
+  directory: z.string(),
+});
+
+export default {
+  name: "pi-session",
+  inject: ["piHarnessLaunch"],
+  Config,
+  apply(context: Context, config: SessionPluginConfig) {
+    const storage = config.storage ?? "jsonl";
+    const manager = storage === "memory"
+      ? SessionManager.inMemory(context.piHarnessLaunch.cwd)
+      : SessionManager.create(context.piHarnessLaunch.cwd, config.directory === undefined ? join(context.piHarnessLaunch.agentDir, "sessions") : resolve(context.piHarnessLaunch.cwd, config.directory));
+    context.provide("piSession", { manager });
+  },
+};

package/packages/core/src/plugins/stdio.ts

@@ -0,0 +1,20 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { StdioApplication } from "../stdio.js";
+
+export default {
+  name: "pi-stdio",
+  inject: ["piRuntime", "piResources", "piHarnessStdio", "piHarnessLaunch"],
+  apply(context: Context) {
+    const application = new StdioApplication(context.piRuntime, context.piHarnessLaunch, context.piHarnessStdio);
+    for (const diagnostic of context.piResources.diagnostics) {
+      if (diagnostic.type !== "error") context.piHarnessStdio.writeError(`Resource ${diagnostic.type}: ${diagnostic.message}\n`);
+    }
+    context.on("pi/session-event", (event) => {
+      application.writeSessionEvent(event);
+    });
+    context.on("pi/extension-error", (error) => {
+      context.piHarnessStdio.writeError(`Extension error (${error.extensionPath}): ${error.error}\n`);
+    });
+    context.provide("piApplication", application);
+  },
+};

package/packages/core/src/plugins/tools.ts

@@ -0,0 +1,23 @@
+import type { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { PiToolRegistry } from "../services.js";
+
+export interface ToolsPluginConfig {
+  names?: string[];
+}
+
+const DEFAULT_TOOLS = ["read", "bash", "edit", "write"];
+
+export const Config: z<ToolsPluginConfig> = z.object({
+  names: z.array(z.string()).default(DEFAULT_TOOLS),
+});
+
+export default {
+  name: "pi-tools",
+  Config,
+  apply(context: Context, config: ToolsPluginConfig) {
+    const names = config.names ?? DEFAULT_TOOLS;
+    if (new Set(names).size !== names.length) throw new Error("Pi core tool names must be unique");
+    context.provide("piTools", new PiToolRegistry(names));
+  },
+};

package/packages/core/src/profile.ts

@@ -0,0 +1,31 @@
+import { access } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface ResolveProfileConfigOptions {
+  profile?: string;
+  configPath?: string;
+  cwd?: string;
+  profilesDir?: string;
+}
+
+export async function resolveProfileConfig(_options: ResolveProfileConfigOptions = {}): Promise<string> {
+  const options = _options;
+  if (options.profile !== undefined && options.configPath !== undefined) throw new Error("profile and configPath cannot be used together");
+  const cwd = options.cwd ?? process.cwd();
+  let configPath: string;
+  if (options.configPath !== undefined) {
+    configPath = resolve(cwd, options.configPath);
+  } else {
+    const profile = options.profile ?? "default";
+    if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(profile)) throw new Error(`Invalid profile name: ${profile}`);
+    const profilesDir = options.profilesDir ?? fileURLToPath(new URL("../profiles", import.meta.url));
+    configPath = resolve(profilesDir, profile, "cordis.yml");
+  }
+  try {
+    await access(configPath);
+  } catch (cause) {
+    throw new Error(`Pi Harness profile config does not exist or is not readable: ${configPath}`, { cause });
+  }
+  return configPath;
+}

package/packages/core/src/runtime.ts

@@ -0,0 +1,39 @@
+import type { AgentSession, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { PiRuntimeService } from "./services.js";
+
+export class PiRuntimeDisposedError extends Error {
+  override readonly name = "PiRuntimeDisposedError";
+
+  constructor() {
+    super("Pi runtime is disposed");
+  }
+}
+
+export class PiRuntime implements PiRuntimeService {
+  readonly sessionRuntime: AgentSessionRuntime;
+  #disposed = false;
+
+  constructor(sessionRuntime: AgentSessionRuntime) {
+    this.sessionRuntime = sessionRuntime;
+  }
+
+  get session(): AgentSession {
+    return this.sessionRuntime.session;
+  }
+
+  async prompt(text: string): Promise<void> {
+    if (this.#disposed) throw new PiRuntimeDisposedError();
+    await this.sessionRuntime.session.prompt(text);
+  }
+
+  async abort(): Promise<void> {
+    if (this.#disposed) return;
+    await this.sessionRuntime.session.abort();
+  }
+
+  async dispose(): Promise<void> {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    await this.sessionRuntime.dispose();
+  }
+}

package/packages/core/src/services.ts

@@ -0,0 +1,105 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { AgentSession, AgentSessionEvent, AgentSessionRuntime, AgentSessionServices, ExtensionError, SessionManager, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+
+export interface PiHarnessLaunch {
+  readonly cwd: string;
+  readonly agentDir: string;
+  readonly args: readonly string[];
+  requestExit(code: number): void;
+}
+
+export interface PiModelsService {
+  readonly runtime: ModelRuntime;
+  readonly model: Model<Api>;
+}
+
+export interface PiModelRuntimeService {
+  readonly runtime: ModelRuntime;
+  readonly provider: string;
+  readonly model: string;
+}
+
+export type PiResourcesService = AgentSessionServices & {
+  createForCwd(cwd: string): Promise<AgentSessionServices>;
+};
+
+export interface PiSessionService {
+  readonly manager: SessionManager;
+}
+
+export interface PiRuntimeService {
+  readonly session: AgentSession;
+  readonly sessionRuntime: AgentSessionRuntime;
+  prompt(text: string): Promise<void>;
+  abort(): Promise<void>;
+  dispose(): Promise<void>;
+}
+
+export interface PiToolsSnapshot {
+  readonly names: string[];
+  readonly customTools: ToolDefinition[];
+}
+
+export interface PiToolsLease extends PiToolsSnapshot {
+  release(): void;
+}
+
+export class PiToolRegistry {
+  readonly #names: string[];
+  readonly #customTools = new Map<string, ToolDefinition>();
+  #leases = 0;
+
+  constructor(names: readonly string[] = []) {
+    this.#names = [...names];
+  }
+
+  register(tool: ToolDefinition): () => void {
+    if (this.#leases > 0) throw new Error(`Pi tool registry is leased by pi-runtime; declare a Cordis injection that activates ${tool.name} before pi-runtime`);
+    if (this.#names.includes(tool.name) || this.#customTools.has(tool.name)) throw new Error(`Pi tool is already registered: ${tool.name}`);
+    this.#customTools.set(tool.name, tool);
+    return () => {
+      this.#customTools.delete(tool.name);
+    };
+  }
+
+  snapshot(): PiToolsSnapshot {
+    return { names: [...this.#names], customTools: [...this.#customTools.values()] };
+  }
+
+  acquire(): PiToolsLease {
+    this.#leases += 1;
+    let released = false;
+    return {
+      ...this.snapshot(),
+      release: () => {
+        if (released) return;
+        released = true;
+        this.#leases -= 1;
+      },
+    };
+  }
+}
+
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    piHarnessLaunch: PiHarnessLaunch;
+    piModelRuntime: PiModelRuntimeService;
+    piModels: PiModelsService;
+    piResources: PiResourcesService;
+    piSession: PiSessionService;
+    piTools: PiToolRegistry;
+    piRuntime: PiRuntimeService;
+  }
+
+  interface Events {
+    "pi/session-event"(event: AgentSessionEvent): void;
+    "pi/extension-error"(error: ExtensionError): void;
+  }
+}
+
+export function provideLaunchContext(context: Context, launch: PiHarnessLaunch): () => void {
+  const value: PiHarnessLaunch = Object.freeze({ ...launch, args: Object.freeze([...launch.args]) });
+  return context.provide("piHarnessLaunch", value);
+}