@noopolis/daimon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Noopolis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# Daimon
+
+Daimon is the Noopolis-native per-agent runtime harness.
+
+It defines a small per-agent contract and currently implements that contract on
+top of Pi. A Daimon runs one harnessed agent inside a caller-prepared workspace.
+
+Spawnfile should own orgs, nested teams, schedules, Moltnet wiring, workspace
+resource compilation, and the app that starts many harnessed agents. This package
+should not know what an org is.
+
+## Install
+
+```bash
+npm install @noopolis/daimon
+```
+
+## Tests
+
+The package has a non-live test suite for auth seeding and Pi model config
+generation:
+
+```bash
+npm test
+npm run typecheck
+npm run build
+```
+
+These tests do not call a model provider.
+
+## Model And Auth Helpers
+
+The Pi adapter supports the same model intent shape Spawnfile lowers for Pi:
+
+- OpenAI Codex subscription auth maps to Pi's `openai-codex` OAuth auth store.
+- Claude Code subscription auth maps to Pi's Anthropic auth store.
+- API-key credentials can be written directly into Pi auth storage.
+- Local and custom OpenAI-compatible endpoints render Pi `models.json`.
+
+For Ollama-style local models, use a local endpoint with `auth.method: none`.
+Pi still requires an API-key field for custom providers, so the helper writes the
+upstream-documented dummy `ollama` value.
+
+## Pi E2E
+
+The Pi E2E uses the local Codex CLI subscription auth file to seed an ignored Pi
+`auth.json` under `.runtime/`.
+
+```bash
+npm install
+npm run e2e:pi-agent
+```
+
+The example starts two harnessed Pi agents from plain caller code. The example
+creates the workspaces and shared resource itself to demonstrate the intended
+boundary: the caller prepares files, the harness runs agent turns.

package/dist/core/types.d.ts

@@ -0,0 +1,49 @@
+export type AgentId = string;
+export interface AgentStartInput {
+    id: AgentId;
+    name: string;
+    instructions: string;
+    workspacePath: string;
+    runtimeHomePath: string;
+    tools?: string[];
+}
+export interface HarnessModelEndpoint {
+    baseUrl: string;
+    compatibility: "anthropic" | "openai";
+}
+export interface HarnessModelSpec {
+    auth?: {
+        keyEnv?: string;
+        method: "api_key" | "claude-code" | "codex" | "none";
+    };
+    endpoint?: HarnessModelEndpoint;
+    name: string;
+    provider: string;
+}
+export interface WakeEvent {
+    id: string;
+    kind: "manual" | "message" | "schedule";
+    from?: string;
+    text: string;
+}
+export interface WakeResult {
+    agentId: AgentId;
+    text: string;
+    durationMs: number;
+}
+export interface AgentStatus {
+    agentId: AgentId;
+    state: "starting" | "idle" | "running" | "stopped" | "failed";
+    lastWakeAt?: string;
+    lastError?: string;
+}
+export interface AgentHandle {
+    id: AgentId;
+    wake(event: WakeEvent): Promise<WakeResult>;
+    status(): AgentStatus;
+    stop(): Promise<void>;
+}
+export interface AgentHarnessAdapter {
+    startAgent(input: AgentStartInput): Promise<AgentHandle>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,WAAW,GAAG,QAAQ,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;KACtD,CAAC;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,IAAI,WAAW,CAAC;IACtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC1D"}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/examples/pi-agent.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pi-agent.d.ts.map

package/dist/examples/pi-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi-agent.d.ts","sourceRoot":"","sources":["../../src/examples/pi-agent.ts"],"names":[],"mappings":""}

package/dist/examples/pi-agent.js

@@ -0,0 +1,108 @@
+import { access, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { seedPiOpenAICodexAuthFromCodex } from "../pi/auth.js";
+import { PiHarnessAdapter } from "../pi/piHarness.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const daimonRoot = path.resolve(__dirname, "../..");
+const runtimeRoot = path.join(daimonRoot, ".runtime", "pi-agent");
+const sharedProjectPath = path.join(runtimeRoot, "shared", "product");
+const piAuthPath = path.join(runtimeRoot, "auth", "auth.json");
+const codexAuthPath = path.join(process.env.HOME ?? "", ".codex", "auth.json");
+const ensureFile = async (filePath) => {
+    await access(filePath);
+    return readFile(filePath, "utf8");
+};
+const assertContains = (content, expected, filePath) => {
+    if (!content.includes(expected)) {
+        throw new Error(`${filePath} does not contain expected text: ${expected}`);
+    }
+};
+const prepareWorkspace = async (agentId) => {
+    const workspacePath = path.join(runtimeRoot, "agents", agentId, "workspace");
+    const runtimeHomePath = path.join(runtimeRoot, "agents", agentId, "runtime");
+    await mkdir(path.join(workspacePath, "repos"), { recursive: true });
+    await mkdir(runtimeHomePath, { recursive: true });
+    await writeFile(path.join(workspacePath, "AGENTS.md"), `# ${agentId}\n\nThis workspace was prepared by caller code, not by the Daimon package.\n`);
+    await symlink(sharedProjectPath, path.join(workspacePath, "repos", "product"));
+    return { workspacePath, runtimeHomePath };
+};
+const setupRuntime = async () => {
+    await rm(runtimeRoot, { recursive: true, force: true });
+    await mkdir(sharedProjectPath, { recursive: true });
+    await writeFile(path.join(sharedProjectPath, "source.txt"), [
+        "Daimon E2E source file.",
+        "The caller prepares shared files and Daimon runs agent turns.",
+        "Expected marker: daimon-e2e"
+    ].join("\n"));
+    await seedPiOpenAICodexAuthFromCodex({ codexAuthPath, piAuthPath });
+};
+const startHarnessedAgent = async (adapter, input) => {
+    const paths = await prepareWorkspace(input.id);
+    return adapter.startAgent({
+        ...input,
+        ...paths
+    });
+};
+const run = async () => {
+    await setupRuntime();
+    const adapter = new PiHarnessAdapter({
+        authPath: piAuthPath,
+        model: {
+            provider: "openai-codex",
+            name: process.env.HARNESS_PI_MODEL ?? "gpt-5.4-mini"
+        }
+    });
+    const mapper = await startHarnessedAgent(adapter, {
+        id: "mapper",
+        name: "Mapper",
+        instructions: "You map project inputs into concise markdown notes. Prefer editing files over long chat responses."
+    });
+    const reviewer = await startHarnessedAgent(adapter, {
+        id: "reviewer",
+        name: "Reviewer",
+        instructions: "You review files written by another harnessed agent and produce a final check note."
+    });
+    try {
+        console.log("started", JSON.stringify([mapper.status(), reviewer.status()], null, 2));
+        const mapped = await mapper.wake({
+            id: "wake-mapper-1",
+            kind: "manual",
+            from: "caller",
+            text: [
+                "Read repos/product/source.txt.",
+                "Create repos/product/agent-output/mapper.md.",
+                "The file must contain the exact marker MAPPER_OK and the phrase daimon-e2e.",
+                "Reply with one short sentence naming the file."
+            ].join("\n")
+        });
+        console.log("mapper", JSON.stringify(mapped, null, 2));
+        const reviewed = await reviewer.wake({
+            id: "wake-reviewer-1",
+            kind: "message",
+            from: "mapper",
+            text: [
+                "Read repos/product/agent-output/mapper.md.",
+                "Create repos/product/agent-output/review.md.",
+                "The file must contain the exact marker REVIEW_OK and mention MAPPER_OK.",
+                "Reply with one short sentence naming the file."
+            ].join("\n")
+        });
+        console.log("reviewer", JSON.stringify(reviewed, null, 2));
+        const mapperFile = path.join(sharedProjectPath, "agent-output", "mapper.md");
+        const reviewFile = path.join(sharedProjectPath, "agent-output", "review.md");
+        assertContains(await ensureFile(mapperFile), "MAPPER_OK", mapperFile);
+        assertContains(await ensureFile(mapperFile), "daimon-e2e", mapperFile);
+        assertContains(await ensureFile(reviewFile), "REVIEW_OK", reviewFile);
+        assertContains(await ensureFile(reviewFile), "MAPPER_OK", reviewFile);
+        console.log("final-status", JSON.stringify([mapper.status(), reviewer.status()], null, 2));
+        console.log("e2e:pi-agent ok");
+    }
+    finally {
+        await Promise.all([mapper.stop(), reviewer.stop()]);
+    }
+};
+run().catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./core/types.js";
+export * from "./pi/auth.js";
+export * from "./pi/modelConfig.js";
+export * from "./pi/piHarness.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./core/types.js";
+export * from "./pi/auth.js";
+export * from "./pi/modelConfig.js";
+export * from "./pi/piHarness.js";

package/dist/pi/auth.d.ts

@@ -0,0 +1,20 @@
+export declare function seedPiOpenAICodexAuthFromCodex(input: {
+    codexAuthPath: string;
+    piAuthPath: string;
+}): Promise<void>;
+export declare function seedPiAnthropicAuthFromClaudeCode(input: {
+    claudeCredentialsPath: string;
+    piAuthPath: string;
+}): Promise<void>;
+export declare function seedPiApiKeyAuth(input: {
+    apiKey: string;
+    env?: Record<string, string>;
+    piAuthPath: string;
+    provider: string;
+}): Promise<void>;
+export declare function createPiOpenAICodexAuthFromCodexToken(input: {
+    access: string;
+    accountId?: string;
+    refresh: string;
+}): Record<string, unknown>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/pi/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/pi/auth.ts"],"names":[],"mappings":"AA2DA,wBAAsB,8BAA8B,CAAC,KAAK,EAAE;IAC1D,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBhB;AAED,wBAAsB,iCAAiC,CAAC,KAAK,EAAE;IAC7D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBhB;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhB;AAED,wBAAgB,qCAAqC,CAAC,KAAK,EAAE;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAU1B"}

package/dist/pi/auth.js

@@ -0,0 +1,98 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+const decodeJwtPayload = (token) => {
+    const payload = token.split(".")[1];
+    if (!payload) {
+        return null;
+    }
+    try {
+        return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+};
+const resolveExpires = (accessToken) => {
+    const payload = decodeJwtPayload(accessToken);
+    const exp = payload?.exp;
+    return typeof exp === "number" ? exp * 1000 : Date.now() + 30 * 60 * 1000;
+};
+const readJsonFile = async (filePath) => JSON.parse(await readFile(filePath, "utf8"));
+const readPiAuth = async (piAuthPath) => {
+    try {
+        return await readJsonFile(piAuthPath);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+};
+const writePiAuth = async (piAuthPath, next) => {
+    await mkdir(path.dirname(piAuthPath), { recursive: true });
+    await writeFile(piAuthPath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+};
+export async function seedPiOpenAICodexAuthFromCodex(input) {
+    const codex = await readJsonFile(input.codexAuthPath);
+    const access = codex.tokens?.access_token;
+    const refresh = codex.tokens?.refresh_token;
+    const accountId = codex.tokens?.account_id;
+    if (!access || !refresh || !accountId) {
+        throw new Error(`Codex auth file is missing access_token, refresh_token, or account_id: ${input.codexAuthPath}`);
+    }
+    const piAuth = await readPiAuth(input.piAuthPath);
+    piAuth["openai-codex"] = {
+        type: "oauth",
+        access,
+        refresh,
+        expires: resolveExpires(access),
+        accountId
+    };
+    await writePiAuth(input.piAuthPath, piAuth);
+}
+export async function seedPiAnthropicAuthFromClaudeCode(input) {
+    const claude = await readJsonFile(input.claudeCredentialsPath);
+    const access = claude.claudeAiOauth?.accessToken;
+    const refresh = claude.claudeAiOauth?.refreshToken;
+    const expires = claude.claudeAiOauth?.expiresAt;
+    if (!access || typeof expires !== "number") {
+        throw new Error(`Claude Code credentials are missing accessToken or expiresAt: ${input.claudeCredentialsPath}`);
+    }
+    const piAuth = await readPiAuth(input.piAuthPath);
+    piAuth.anthropic = refresh
+        ? {
+            type: "oauth",
+            access,
+            refresh,
+            expires
+        }
+        : {
+            type: "api_key",
+            key: access
+        };
+    await writePiAuth(input.piAuthPath, piAuth);
+}
+export async function seedPiApiKeyAuth(input) {
+    if (input.apiKey.length === 0) {
+        throw new Error(`API key for ${input.provider} must not be empty`);
+    }
+    const piAuth = await readPiAuth(input.piAuthPath);
+    piAuth[input.provider] = {
+        type: "api_key",
+        key: input.apiKey,
+        ...(input.env ? { env: input.env } : {})
+    };
+    await writePiAuth(input.piAuthPath, piAuth);
+}
+export function createPiOpenAICodexAuthFromCodexToken(input) {
+    return {
+        "openai-codex": {
+            type: "oauth",
+            access: input.access,
+            refresh: input.refresh,
+            expires: resolveExpires(input.access),
+            ...(input.accountId ? { accountId: input.accountId } : {})
+        }
+    };
+}

package/dist/pi/modelConfig.d.ts

@@ -0,0 +1,37 @@
+import type { HarnessModelSpec } from "../core/types.js";
+type PiApi = "anthropic-messages" | "openai-completions";
+interface PiModelProviderConfig {
+    api: PiApi;
+    apiKey: string;
+    baseUrl: string;
+    models: Array<{
+        api: PiApi;
+        baseUrl: string;
+        contextWindow: number;
+        cost: {
+            cacheRead: number;
+            cacheWrite: number;
+            input: number;
+            output: number;
+        };
+        id: string;
+        input: Array<"image" | "text">;
+        maxTokens: number;
+        name: string;
+        reasoning: boolean;
+    }>;
+}
+export interface PiModelResolution {
+    model: {
+        name: string;
+        provider: string;
+    };
+    modelsConfig: {
+        providers: Record<string, PiModelProviderConfig>;
+    };
+}
+export declare const createPiProviderId: (model: HarnessModelSpec) => string;
+export declare const resolvePiHarnessModel: (model: HarnessModelSpec) => PiModelResolution;
+export declare const renderPiModelsConfig: (models: HarnessModelSpec[]) => string;
+export {};
+//# sourceMappingURL=modelConfig.d.ts.map

package/dist/pi/modelConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelConfig.d.ts","sourceRoot":"","sources":["../../src/pi/modelConfig.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,KAAK,KAAK,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;AAEzD,UAAU,qBAAqB;IAC7B,GAAG,EAAE,KAAK,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,CAAC;QACZ,GAAG,EAAE,KAAK,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,EAAE;YACJ,SAAS,EAAE,MAAM,CAAC;YAClB,UAAU,EAAE,MAAM,CAAC;YACnB,KAAK,EAAE,MAAM,CAAC;YACd,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;QACF,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,EAAE,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,CAAC;QAC/B,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,OAAO,CAAC;KACpB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACZ,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;KAClD,CAAC;CACH;AA2CD,eAAO,MAAM,kBAAkB,GAAI,OAAO,gBAAgB,KAAG,MAG5D,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,gBAAgB,KAAG,iBAiD/D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,QAAQ,gBAAgB,EAAE,KAAG,MAajE,CAAC"}

package/dist/pi/modelConfig.js

@@ -0,0 +1,94 @@
+import { createHash } from "node:crypto";
+const stableStringify = (value) => {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+};
+const slugify = (value) => value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+const shortHash = (value) => createHash("sha1").update(value).digest("hex").slice(0, 8);
+const endpointApi = (compatibility) => compatibility === "anthropic" ? "anthropic-messages" : "openai-completions";
+const endpointApiKey = (model) => model.auth?.method === "api_key"
+    ? `$${model.auth.keyEnv ?? `${model.provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`}`
+    : "ollama";
+const assertSupportedEndpointAuth = (model) => {
+    const method = model.auth?.method ?? "none";
+    if (method === "none" || method === "api_key") {
+        return;
+    }
+    throw new Error(`Pi endpoint models only support none or api_key auth, got ${method}`);
+};
+export const createPiProviderId = (model) => {
+    const base = slugify(`${model.provider}-${model.endpoint?.compatibility ?? "builtin"}-${model.name}`);
+    return `${base || "model"}-${shortHash(stableStringify(model))}`;
+};
+export const resolvePiHarnessModel = (model) => {
+    if (!model.endpoint) {
+        return {
+            model: {
+                name: model.name,
+                provider: model.provider === "openai" && model.auth?.method === "codex"
+                    ? "openai-codex"
+                    : model.provider
+            },
+            modelsConfig: { providers: {} }
+        };
+    }
+    assertSupportedEndpointAuth(model);
+    const provider = createPiProviderId(model);
+    const api = endpointApi(model.endpoint.compatibility);
+    return {
+        model: {
+            name: model.name,
+            provider
+        },
+        modelsConfig: {
+            providers: {
+                [provider]: {
+                    api,
+                    apiKey: endpointApiKey(model),
+                    baseUrl: model.endpoint.baseUrl,
+                    models: [
+                        {
+                            api,
+                            baseUrl: model.endpoint.baseUrl,
+                            contextWindow: 128000,
+                            cost: {
+                                cacheRead: 0,
+                                cacheWrite: 0,
+                                input: 0,
+                                output: 0
+                            },
+                            id: model.name,
+                            input: ["text"],
+                            maxTokens: 16384,
+                            name: model.name,
+                            reasoning: false
+                        }
+                    ]
+                }
+            }
+        }
+    };
+};
+export const renderPiModelsConfig = (models) => {
+    const providers = new Map();
+    for (const model of models) {
+        const resolution = resolvePiHarnessModel(model);
+        for (const [provider, config] of Object.entries(resolution.modelsConfig.providers)) {
+            providers.set(provider, config);
+        }
+    }
+    return `${JSON.stringify({
+        providers: Object.fromEntries([...providers.entries()].sort(([left], [right]) => left.localeCompare(right)))
+    }, null, 2)}\n`;
+};

package/dist/pi/piHarness.d.ts

@@ -0,0 +1,19 @@
+import type { AgentHandle, AgentHarnessAdapter, AgentStartInput, HarnessModelSpec } from "../core/types.js";
+export interface PiHarnessOptions {
+    authPath: string;
+    model?: {
+        auth?: HarnessModelSpec["auth"];
+        endpoint?: HarnessModelSpec["endpoint"];
+        provider: string;
+        name: string;
+    };
+    modelsPath?: string;
+}
+export declare class PiHarnessAdapter implements AgentHarnessAdapter {
+    private readonly options;
+    private readonly authStorage;
+    private readonly modelRegistry;
+    constructor(options: PiHarnessOptions);
+    startAgent(input: AgentStartInput): Promise<AgentHandle>;
+}
+//# sourceMappingURL=piHarness.d.ts.map

package/dist/pi/piHarness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"piHarness.d.ts","sourceRoot":"","sources":["../../src/pi/piHarness.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,eAAe,EAEf,gBAAgB,EAGjB,MAAM,kBAAkB,CAAC;AAM1B,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACxC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA4HD,qBAAa,gBAAiB,YAAW,mBAAmB;IAI9C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;gBAEjB,OAAO,EAAE,gBAAgB;IAKhD,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;CAgC/D"}

package/dist/pi/piHarness.js

@@ -0,0 +1,153 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { AuthStorage, createAgentSession, createExtensionRuntime, ModelRegistry, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { resolvePiHarnessModel } from "./modelConfig.js";
+const createModelRegistry = (authStorage, options) => {
+    const registry = options.modelsPath
+        ? ModelRegistry.create(authStorage, options.modelsPath)
+        : ModelRegistry.inMemory(authStorage);
+    if (!options.modelsPath && options.model?.endpoint) {
+        const { modelsConfig } = resolvePiHarnessModel(options.model);
+        for (const [provider, config] of Object.entries(modelsConfig.providers)) {
+            registry.registerProvider(provider, {
+                api: config.api,
+                apiKey: config.apiKey,
+                baseUrl: config.baseUrl,
+                models: config.models
+            });
+        }
+    }
+    return registry;
+};
+class PiAgentHandle {
+    id;
+    session;
+    state = "idle";
+    lastWakeAt;
+    lastError;
+    constructor(id, session) {
+        this.id = id;
+        this.session = session;
+    }
+    async wake(event) {
+        const startedAt = Date.now();
+        const chunks = [];
+        this.state = "running";
+        this.lastWakeAt = new Date().toISOString();
+        this.lastError = undefined;
+        const unsubscribe = this.session.subscribe((piEvent) => {
+            if (piEvent.type !== "turn_end") {
+                return;
+            }
+            const message = piEvent.message;
+            const content = message.content;
+            if (typeof content === "string") {
+                chunks.push(content);
+            }
+            else if (Array.isArray(content)) {
+                chunks.push(content
+                    .filter((item) => {
+                    const candidate = item;
+                    return candidate.type === "text" && typeof candidate.text === "string";
+                })
+                    .map((item) => item.text)
+                    .join(""));
+            }
+        });
+        try {
+            await this.session.prompt(formatWakePrompt(event), { expandPromptTemplates: false });
+            this.state = "idle";
+            return {
+                agentId: this.id,
+                text: chunks.join("\n").trim(),
+                durationMs: Date.now() - startedAt
+            };
+        }
+        catch (error) {
+            this.state = "failed";
+            this.lastError = error instanceof Error ? error.message : String(error);
+            throw error;
+        }
+        finally {
+            unsubscribe();
+        }
+    }
+    status() {
+        return {
+            agentId: this.id,
+            state: this.state,
+            lastWakeAt: this.lastWakeAt,
+            lastError: this.lastError
+        };
+    }
+    async stop() {
+        this.session.dispose();
+        this.state = "stopped";
+    }
+}
+const formatWakePrompt = (event) => `Wake event:
+- id: ${event.id}
+- kind: ${event.kind}
+- from: ${event.from ?? "operator"}
+
+${event.text}`;
+const createResourceLoader = (input) => {
+    const systemPrompt = [
+        `You are ${input.name} (${input.id}).`,
+        input.instructions,
+        "You are running inside a harnessed workspace prepared by the caller.",
+        "Use the available coding tools when asked to read, write, edit, or inspect files.",
+        "Keep responses brief and report the exact files you created or modified."
+    ].join("\n\n");
+    return {
+        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+        getSkills: () => ({ skills: [], diagnostics: [] }),
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgentsFiles: () => ({ agentsFiles: [] }),
+        getSystemPrompt: () => systemPrompt,
+        getAppendSystemPrompt: () => [],
+        extendResources: () => { },
+        reload: async () => { }
+    };
+};
+export class PiHarnessAdapter {
+    options;
+    authStorage;
+    modelRegistry;
+    constructor(options) {
+        this.options = options;
+        this.authStorage = AuthStorage.create(options.authPath);
+        this.modelRegistry = createModelRegistry(this.authStorage, options);
+    }
+    async startAgent(input) {
+        await mkdir(input.runtimeHomePath, { recursive: true });
+        await mkdir(input.workspacePath, { recursive: true });
+        const modelSpec = this.options.model ?? {
+            auth: { method: "codex" },
+            provider: "openai",
+            name: "gpt-5.4-mini"
+        };
+        const resolvedModel = resolvePiHarnessModel(modelSpec).model;
+        const model = this.modelRegistry.find(resolvedModel.provider, resolvedModel.name);
+        if (!model) {
+            throw new Error(`Pi model not found: ${resolvedModel.provider}/${resolvedModel.name}`);
+        }
+        const { session } = await createAgentSession({
+            cwd: input.workspacePath,
+            agentDir: input.runtimeHomePath,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+            model,
+            thinkingLevel: "off",
+            resourceLoader: createResourceLoader(input),
+            tools: input.tools ?? ["read", "write", "edit", "bash", "grep", "find", "ls"],
+            sessionManager: SessionManager.create(input.workspacePath, path.join(input.runtimeHomePath, "sessions")),
+            settingsManager: SettingsManager.inMemory({
+                compaction: { enabled: false },
+                retry: { enabled: true, maxRetries: 1 }
+            })
+        });
+        return new PiAgentHandle(input.id, session);
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@noopolis/daimon",
+  "version": "0.1.0",
+  "description": "Noopolis native per-agent runtime harness built on Pi.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/noopolis/daimon.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "test": "node --import tsx --test \"src/**/*.test.ts\"",
+    "e2e:pi-agent": "tsx src/examples/pi-agent.ts"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dependencies": {
+    "@earendil-works/pi-ai": "^0.79.9",
+    "@earendil-works/pi-coding-agent": "^0.79.9"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}