@agimon-ai/po-core 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/src/schemas/headless.d.mts

@@ -1,17 +1,17 @@
 import { SessionToolSurface } from "../types/server/sessionToolSurface.mjs";
-import { DoomSessionContext } from "./hubChannel.mjs";
-import { DoomNotificationRequest } from "./notification.mjs";
-import { DoomServerBundleEntry } from "./serverBundle.mjs";
+import { PoSessionContext } from "./hubChannel.mjs";
+import { PoNotificationRequest } from "./notification.mjs";
+import { PoServerBundleEntry } from "./serverBundle.mjs";
 import { Static, TSchema } from "typebox";
 import { Context } from "@deepseek-ai/cordis";
 import { CallToolResult, Tool } from "@modelcontextprotocol/server";
 import { ThinkingLevel } from "@earendil-works/pi-agent-core";
 //#region src/schemas/headless.d.ts
 /** Session-only contributions. This is not a Pi ExtensionAPI or a TUI adapter. */
-export declare const DOOM_HEADLESS_HOST_SERVICE = "doom/headless-host";
-export declare const DOOM_HEADLESS_OWNER: unique symbol;
-/** Admission is a host boundary, not an advisory facet-hook failure. */
-export declare class DoomHeadlessPromptAdmissionError extends Error {
+export declare const PO_HEADLESS_HOST_SERVICE = "po/headless-host";
+export declare const PO_HEADLESS_OWNER: unique symbol;
+/** Admission is a host boundary, not an advisory package-hook failure. */
+export declare class PoHeadlessPromptAdmissionError extends Error {
   constructor(cause: unknown);
 }
 /**
@@ -20,19 +20,19 @@ export declare class DoomHeadlessPromptAdmissionError extends Error {
  * Its message is written for the user and says what to do, so a server returns it as is
  * rather than hiding it behind a generic internal error.
  */
-export declare class DoomSessionSetupError extends Error {
+export declare class PoSessionSetupError extends Error {
   constructor(message: string);
 }
 /** Error identity must survive independently bundled server and extension graphs. */
-export declare function isDoomSessionSetupError(error: unknown): error is Error;
+export declare function isPoSessionSetupError(error: unknown): error is Error;
 /** Error identity must survive independently bundled server and extension graphs. */
-export declare function isDoomHeadlessPromptAdmissionError(error: unknown): boolean;
+export declare function isPoHeadlessPromptAdmissionError(error: unknown): boolean;
 /** The tool and its hooks have not started. */
-export declare class DoomHeadlessToolBusyError extends Error {
+export declare class PoHeadlessToolBusyError extends Error {
   constructor();
 }
-export declare function isDoomHeadlessToolBusyError(error: unknown): boolean;
-export interface DoomHeadlessSelection {
+export declare function isPoHeadlessToolBusyError(error: unknown): boolean;
+export interface PoHeadlessSelection {
   readonly majorMode: string;
   readonly activeLayers: readonly string[];
   readonly domains: readonly string[];
@@ -40,8 +40,8 @@ export interface DoomHeadlessSelection {
   /** Feature-owned activation sets, keyed by the contributing capability. */
   readonly state?: Readonly<Record<string, readonly string[]>>;
 }
-/** One package-owned selection transition. Server facets change exactly one axis per operation. */
-export type DoomHeadlessSelectionChange = {
+/** One package-owned selection transition. Server packages change exactly one axis per operation. */
+export type PoHeadlessSelectionChange = {
   readonly axis: 'majorMode';
   readonly majorMode: string;
 } | {
@@ -55,11 +55,11 @@ export type DoomHeadlessSelectionChange = {
   readonly key: string;
   readonly values: readonly string[];
 };
-export declare function readDoomHeadlessOwner(context: Context): DoomServerBundleEntry | undefined;
-export interface DoomHeadlessRegistration {
+export declare function readPoHeadlessOwner(context: Context): PoServerBundleEntry | undefined;
+export interface PoHeadlessRegistration {
   dispose(): void;
 }
-export type DoomHeadlessContent = {
+export type PoHeadlessContent = {
   type: 'text';
   text: string;
 } | {
@@ -67,8 +67,8 @@ export type DoomHeadlessContent = {
   data: string;
   mimeType: string;
 };
-export interface DoomHeadlessToolResult {
-  content: DoomHeadlessContent[];
+export interface PoHeadlessToolResult {
+  content: PoHeadlessContent[];
   /** Public MCP result data. Internal renderer details are not a remote result contract. */
   structuredContent?: Record<string, unknown>;
   /** Component-only MCP metadata, never inferred from internal renderer details. */
@@ -80,14 +80,14 @@ export interface DoomHeadlessToolResult {
  * Narrows a Pi tool result to the headless contract. Pi types `structuredContent` as any JSON
  * value, while MCP only accepts an object, so anything else is dropped rather than forwarded.
  */
-export declare function toDoomHeadlessToolResult(result: {
-  readonly content: DoomHeadlessContent[];
+export declare function toPoHeadlessToolResult(result: {
+  readonly content: PoHeadlessContent[];
   readonly details?: unknown;
   readonly structuredContent?: unknown;
   readonly _meta?: CallToolResult['_meta'];
   readonly isError?: boolean;
-}): DoomHeadlessToolResult;
-export interface DoomHeadlessClientRequest {
+}): PoHeadlessToolResult;
+export interface PoHeadlessClientRequest {
   kind: 'confirm' | 'select' | 'input';
   title: string;
   message?: string;
@@ -99,28 +99,29 @@ export interface DoomHeadlessClientRequest {
   initialValue?: string;
   multiline?: boolean;
 }
-export interface DoomHeadlessClient {
+export interface PoHeadlessClient {
   /**
    * Operator-facing surface only: the body is flattened to one line and capped at 4096 characters
    * by schemas/notification.ts:73-83, and the model never sees it. Use session.admitPrompt to
    * reach the model.
    */
-  notify(request: DoomNotificationRequest): void | Promise<void>;
-  request(request: DoomHeadlessClientRequest, signal?: AbortSignal): Promise<unknown>;
+  notify(request: PoNotificationRequest): void | Promise<void>;
+  request(request: PoHeadlessClientRequest, signal?: AbortSignal): Promise<unknown>;
+  /** Ignored once the session has closed, so a package can clear its status while it unwinds. */
   setStatus(source: string, text: string | undefined): void;
   appendComposerText?(text: string): void;
 }
-export interface DoomHeadlessModelSettings {
+export interface PoHeadlessModelSettings {
   model?: {
     provider: string;
     id: string;
   };
   thinkingLevel: ThinkingLevel;
 }
-export interface DoomHeadlessSession {
-  readModelSettings?(): Promise<DoomHeadlessModelSettings>;
+export interface PoHeadlessSession {
+  readModelSettings?(): Promise<PoHeadlessModelSettings>;
   setFastMode?(enabled: boolean): Promise<void>;
-  setModelSettings?(settings: Partial<DoomHeadlessModelSettings>): Promise<void>;
+  setModelSettings?(settings: Partial<PoHeadlessModelSettings>): Promise<void>;
   /** Query durable history on demand; hosts do not retain the entire transcript. */
   entries(query?: {
     type?: 'custom' | 'message';
@@ -164,7 +165,7 @@ export interface DoomHeadlessSession {
     }): Promise<string | undefined>;
     dispose(): void;
   };
-  /** Detached canonical model context before facet transformations, with context edits applied and no system message. */
+  /** Detached canonical model context before package transformations, with context edits applied and no system message. */
   contextMessages?(): Promise<readonly Record<string, unknown>[]>;
   /** The latest measured assistant usage and the selected model's context window. */
   contextUsage?(): Promise<{
@@ -194,16 +195,14 @@ export interface DoomHeadlessSession {
   }>;
   /** Renames the durable session and publishes the updated title to presentation clients. */
   setName?(name: string): Promise<void>;
-  /** Capture the current persisted branch for an in-process child fork. */
+  /** The current branch's newest entry, for a child that starts from this session's history. */
   forkSource?(): Promise<{
-    kind: 'v4-fork';
-    sessionFile: string;
-    branch: string;
+    kind: 'fork';
     entryId?: string;
   }>;
 }
 /** A grant-filtered skill view available only during one remote MCP tool invocation. */
-export interface DoomMcpSkillAccess {
+export interface PoMcpSkillAccess {
   list(): Promise<readonly {
     name: string;
     description: string;
@@ -211,15 +210,15 @@ export interface DoomMcpSkillAccess {
   read(name: string): Promise<string>;
 }
 /** A stateless auxiliary request. These tools are private to this request, never registered on the agent. */
-export interface DoomHeadlessToolCompletionRequest {
+export interface PoHeadlessToolCompletionRequest {
   systemPrompt: string;
   input: string;
   maxTokens: number;
   cacheRetention?: 'none' | 'short' | 'long';
   signal?: AbortSignal;
-  tools: readonly Pick<DoomHeadlessTool, 'name' | 'description' | 'parameters'>[];
+  tools: readonly Pick<PoHeadlessTool, 'name' | 'description' | 'parameters'>[];
 }
-export interface DoomHeadlessToolCompletionResult {
+export interface PoHeadlessToolCompletionResult {
   toolCalls: readonly {
     id: string;
     name: string;
@@ -229,8 +228,8 @@ export interface DoomHeadlessToolCompletionResult {
     totalTokens: number;
   };
 }
-/** Credential-free catalog metadata. Facets cannot obtain auth, headers, or a mutable registry. */
-export interface DoomHeadlessModelMetadata {
+/** Credential-free catalog metadata. Packages cannot obtain auth, headers, or a mutable registry. */
+export interface PoHeadlessModelMetadata {
   readonly provider: string;
   readonly id: string;
   readonly api?: string;
@@ -238,25 +237,25 @@ export interface DoomHeadlessModelMetadata {
   readonly name?: string;
   readonly compat?: Readonly<Record<string, boolean | string>>;
 }
-export interface DoomHeadlessExecutionContext {
+export interface PoHeadlessExecutionContext {
   readonly cwd: string;
   /** The checkout the session runs in, distinct from the tool execution directory. */
   readonly repoRoot: string;
   readonly sessionId: string;
   /** The session's baseline context, when its host knows its workspace. */
-  readonly sessionContext?: DoomSessionContext;
-  /** Immutable session configuration. Facets must not read or mutate process.env. */
+  readonly sessionContext?: PoSessionContext;
+  /** Immutable session configuration. Packages must not read or mutate process.env. */
   readonly environment: Readonly<Record<string, string | undefined>>;
-  readonly client: DoomHeadlessClient;
-  readonly session: DoomHeadlessSession;
-  readonly model?: DoomHeadlessModelMetadata;
+  readonly client: PoHeadlessClient;
+  readonly session: PoHeadlessSession;
+  readonly model?: PoHeadlessModelMetadata;
   /** Lookup in this session's catalog, including physical models named by finalized messages. */
-  readonly getModel?: (provider: string, id: string) => DoomHeadlessModelMetadata | undefined;
-  /** Detached credential-free authenticated chat catalog snapshot, without refreshing providers. */
-  readonly getAvailableModels?: () => readonly {
+  readonly getModel?: (provider: string, id: string) => PoHeadlessModelMetadata | undefined;
+  /** Detached credential-free authenticated chat catalog, read after refreshing provider availability. */
+  readonly getAvailableModels?: () => Promise<readonly {
     readonly provider: string;
     readonly id: string;
-  }[];
+  }[]>;
   /** Operation cancellation, supplied only for an active invocation. */
   readonly signal?: AbortSignal;
   readonly textCompletion?: {
@@ -278,7 +277,7 @@ export interface DoomHeadlessExecutionContext {
     }): Promise<string>;
   };
   readonly toolCompletion?: {
-    complete(reference: string, request: DoomHeadlessToolCompletionRequest): Promise<DoomHeadlessToolCompletionResult>;
+    complete(reference: string, request: PoHeadlessToolCompletionRequest): Promise<PoHeadlessToolCompletionResult>;
   };
   /** Guarded image operation. Credentials and transport configuration remain host-owned. */
   readonly imageGeneration?: {
@@ -319,13 +318,13 @@ export interface DoomHeadlessExecutionContext {
       results?: readonly Record<string, unknown>[];
     }>;
   };
-  readonly selection: DoomHeadlessSelection;
+  readonly selection: PoHeadlessSelection;
   /** Present only while an authenticated remote MCP tool is running. */
-  readonly mcpSkills?: DoomMcpSkillAccess;
+  readonly mcpSkills?: PoMcpSkillAccess;
   shutdown(): void;
 }
 /** Conditions narrow an eligible owner's contributions; they can never restore a disabled owner. */
-export interface DoomHeadlessCondition {
+export interface PoHeadlessCondition {
   state?: Readonly<Record<string, string>>;
   attribution?: {
     kind: 'minor' | 'domain';
@@ -334,8 +333,8 @@ export interface DoomHeadlessCondition {
   };
   domain?: string;
 }
-export interface DoomHeadlessToolRestriction {
-  when?: DoomHeadlessCondition;
+export interface PoHeadlessToolRestriction {
+  when?: PoHeadlessCondition;
   /** Optional capability ceiling. An empty list disables every tool. */
   allowedTools?: readonly string[];
   /**
@@ -344,8 +343,8 @@ export interface DoomHeadlessToolRestriction {
    */
   excludedTools?: readonly string[];
 }
-export interface DoomHeadlessTool<TParameters extends TSchema = TSchema> {
-  when?: DoomHeadlessCondition;
+export interface PoHeadlessTool<TParameters extends TSchema = TSchema> {
+  when?: PoHeadlessCondition;
   name: string;
   label?: string;
   description: string;
@@ -362,7 +361,7 @@ export interface DoomHeadlessTool<TParameters extends TSchema = TSchema> {
   promptSnippet?: string;
   promptGuidelines?: readonly string[];
   executionMode?: 'parallel' | 'serial';
-  execute(toolCallId: string, parameters: Static<TParameters>, signal: AbortSignal | undefined, onUpdate: ((result: DoomHeadlessToolResult) => void) | undefined, context: DoomHeadlessExecutionContext): Promise<DoomHeadlessToolResult>;
+  execute(toolCallId: string, parameters: Static<TParameters>, signal: AbortSignal | undefined, onUpdate: ((result: PoHeadlessToolResult) => void) | undefined, context: PoHeadlessExecutionContext): Promise<PoHeadlessToolResult>;
 }
 /**
  * One package contribution to the session's resource surface.
@@ -378,26 +377,26 @@ export interface DoomHeadlessTool<TParameters extends TSchema = TSchema> {
  *
  * The rule in one line: if it is a file the package ships, it is a `skill`.
  */
-export interface DoomHeadlessResource {
-  when?: DoomHeadlessCondition;
+export interface PoHeadlessResource {
+  when?: PoHeadlessCondition;
   name: string;
   /** Model-visible selection signal. A `skill` without one tells the agent nothing. */
   description?: string;
   /** Absolute path of the file `read()` returns, so an advertised skill is one the agent can open. */
   path?: string;
   kind: 'prompt' | 'skill' | 'context';
-  read(context: DoomHeadlessExecutionContext): string | Promise<string>;
+  read(context: PoHeadlessExecutionContext): string | Promise<string>;
 }
-export interface DoomHeadlessCommand {
-  when?: DoomHeadlessCondition;
+export interface PoHeadlessCommand {
+  when?: PoHeadlessCondition;
   name: string;
   description: string;
   /** Selection-only control allowed after a coherent selection fails admission. */
   selectionRecovery?: boolean;
-  execute(args: string, context: DoomHeadlessExecutionContext): void | Promise<void>;
+  execute(args: string, context: PoHeadlessExecutionContext): void | Promise<void>;
 }
-export type DoomHeadlessEventName = 'session_start' | 'session_shutdown' | 'session_tree' | 'before_agent_start' | 'agent_start' | 'agent_end' | 'agent_settled' | 'turn_start' | 'turn_end' | 'context' | 'before_provider_request' | 'message_start' | 'message_update' | 'message_end' | 'tool_call' | 'tool_execution_start' | 'tool_execution_update' | 'tool_execution_end' | 'tool_result' | 'model_select' | 'session_before_compact' | 'session_compact';
-export type DoomHeadlessHookEvent<E extends DoomHeadlessEventName> = E extends 'before_provider_request' ? {
+export type PoHeadlessEventName = 'session_start' | 'session_shutdown' | 'session_tree' | 'before_agent_start' | 'agent_start' | 'agent_end' | 'agent_settled' | 'turn_start' | 'turn_end' | 'context' | 'before_provider_request' | 'message_start' | 'message_update' | 'message_end' | 'tool_call' | 'tool_execution_start' | 'tool_execution_update' | 'tool_execution_end' | 'tool_result' | 'model_select' | 'session_before_compact' | 'session_compact';
+export type PoHeadlessHookEvent<E extends PoHeadlessEventName> = E extends 'before_provider_request' ? {
   lane: string;
   runId: string;
   model: {
@@ -417,19 +416,19 @@ export type DoomHeadlessHookEvent<E extends DoomHeadlessEventName> = E extends '
     id: string;
   };
 } : Readonly<Record<string, unknown>>;
-export interface DoomHeadlessCompactionResult {
+export interface PoHeadlessCompactionResult {
   summary: string;
   tokensBefore: number;
   retainedTail: Record<string, unknown>[];
   usage?: Record<string, unknown>;
   details?: unknown;
 }
-export type DoomHeadlessHookResult<E extends DoomHeadlessEventName> = E extends 'before_provider_request' ? {
+export type PoHeadlessHookResult<E extends PoHeadlessEventName> = E extends 'before_provider_request' ? {
   payload: unknown;
 } | void : E extends 'session_before_compact' ? {
   cancel?: boolean;
   decline?: boolean;
-  compaction?: DoomHeadlessCompactionResult;
+  compaction?: PoHeadlessCompactionResult;
 } | void : E extends 'context' ? {
   messages?: unknown[];
   systemPrompt?: string;
@@ -442,70 +441,70 @@ export type DoomHeadlessHookResult<E extends DoomHeadlessEventName> = E extends
     terminate?: boolean;
   };
 } | void : E extends 'tool_result' ? {
-  content?: DoomHeadlessContent[];
+  content?: PoHeadlessContent[];
   details?: unknown;
   isError?: boolean;
   usage?: Record<string, unknown>;
   terminate?: boolean;
 } | void : unknown;
-export type DoomHeadlessHook<E extends DoomHeadlessEventName = DoomHeadlessEventName> = E extends DoomHeadlessEventName ? {
-  when?: DoomHeadlessCondition;
+export type PoHeadlessHook<E extends PoHeadlessEventName = PoHeadlessEventName> = E extends PoHeadlessEventName ? {
+  when?: PoHeadlessCondition;
   event: E;
-  handle(event: Readonly<DoomHeadlessHookEvent<E>>, context: DoomHeadlessExecutionContext): DoomHeadlessHookResult<E> | Promise<DoomHeadlessHookResult<E>>;
+  handle(event: Readonly<PoHeadlessHookEvent<E>>, context: PoHeadlessExecutionContext): PoHeadlessHookResult<E> | Promise<PoHeadlessHookResult<E>>;
 } : never;
-/** A retained facet can register activity without starting disabled watchers or services. */
-export interface DoomHeadlessActivity {
-  when?: DoomHeadlessCondition;
+/** A retained package can register activity without starting disabled watchers or services. */
+export interface PoHeadlessActivity {
+  when?: PoHeadlessCondition;
   name: string;
-  start(context: DoomHeadlessExecutionContext): (() => void | Promise<void>) | Promise<() => void | Promise<void>>;
+  start(context: PoHeadlessExecutionContext): (() => void | Promise<void>) | Promise<() => void | Promise<void>>;
 }
 /** Read-only metadata for the currently applied session, never executable declarations or resource bodies. */
-export interface DoomHeadlessCapability {
+export interface PoHeadlessCapability {
   readonly source: string;
   readonly name: string;
   readonly kind: 'tool' | 'skill';
-  readonly when?: DoomHeadlessCondition;
+  readonly when?: PoHeadlessCondition;
   readonly active: boolean;
   readonly discoverable: boolean;
   readonly reason?: 'inactive' | 'restricted' | 'shadowed' | 'unavailable' | 'not-discoverable';
 }
 /** Visibility controls model discovery only, never admission for external execution. */
-export declare function isDoomHeadlessToolModelVisible(tool: Pick<DoomHeadlessTool, '_meta'>): boolean;
-export interface DoomHeadlessCapabilitySnapshot {
+export declare function isPoHeadlessToolModelVisible(tool: Pick<PoHeadlessTool, '_meta'>): boolean;
+export interface PoHeadlessCapabilitySnapshot {
   readonly revision: number;
   readonly ready: boolean;
-  readonly capabilities: readonly DoomHeadlessCapability[];
+  readonly capabilities: readonly PoHeadlessCapability[];
 }
-/** Registrations inherit package ownership from the caller's Cordis facet. */
+/** Registrations inherit package ownership from the caller's Cordis fiber. */
 /**
  * The tool a server session loads skills through. When a session carries it, the prompt lists
  * every skill by name and points here, so a skill needs no file the agent could read.
  */
-export declare const DOOM_LOAD_SKILL_TOOL = "load_skill";
-export interface DoomHeadlessHostService {
-  readonly context: DoomHeadlessExecutionContext;
+export declare const PO_LOAD_SKILL_TOOL = "load_skill";
+export interface PoHeadlessHostService {
+  readonly context: PoHeadlessExecutionContext;
   /** Admitted external execution, sharing native hooks, restrictions and session lifetime. */
   readonly toolSurface?: Pick<SessionToolSurface, 'readSurface' | 'invokeTool'>;
   /** The instructions of an applied skill by exact name, or undefined when none is applied. */
   readSkill(name: string): string | undefined;
-  changeSelection(change: DoomHeadlessSelectionChange): Promise<void>;
+  changeSelection(change: PoHeadlessSelectionChange): Promise<void>;
   assertActive(source?: string): void;
-  subscribeSelection(listener: (selection: DoomHeadlessSelection) => void | Promise<void>): () => void;
+  subscribeSelection(listener: (selection: PoHeadlessSelection) => void | Promise<void>): () => void;
   /** Inspect only a coherently applied generation. A transition returns ready=false and no partial inventory. */
-  inspectCapabilities(): DoomHeadlessCapabilitySnapshot;
-  registerToolRestriction(restriction: DoomHeadlessToolRestriction): DoomHeadlessRegistration;
-  registerTool<TParameters extends TSchema>(tool: DoomHeadlessTool<TParameters>): DoomHeadlessRegistration;
-  registerResource(resource: DoomHeadlessResource): DoomHeadlessRegistration;
-  registerCommand(command: DoomHeadlessCommand): DoomHeadlessRegistration;
-  registerHook(hook: DoomHeadlessHook): DoomHeadlessRegistration;
-  registerActivity(activity: DoomHeadlessActivity): DoomHeadlessRegistration;
+  inspectCapabilities(): PoHeadlessCapabilitySnapshot;
+  registerToolRestriction(restriction: PoHeadlessToolRestriction): PoHeadlessRegistration;
+  registerTool<TParameters extends TSchema>(tool: PoHeadlessTool<TParameters>): PoHeadlessRegistration;
+  registerResource(resource: PoHeadlessResource): PoHeadlessRegistration;
+  registerCommand(command: PoHeadlessCommand): PoHeadlessRegistration;
+  registerHook(hook: PoHeadlessHook): PoHeadlessRegistration;
+  registerActivity(activity: PoHeadlessActivity): PoHeadlessRegistration;
 }
 declare module '@deepseek-ai/cordis' {
   interface Context {
-    'doom/headless-host': DoomHeadlessHostService;
+    'po/headless-host': PoHeadlessHostService;
   }
 }
-export declare function readDoomHeadlessHost(context: Context): DoomHeadlessHostService | undefined;
-export declare function requireDoomHeadlessHost(context: Context): DoomHeadlessHostService;
+export declare function readPoHeadlessHost(context: Context): PoHeadlessHostService | undefined;
+export declare function requirePoHeadlessHost(context: Context): PoHeadlessHostService;
 //#endregion
 //# sourceMappingURL=headless.d.mts.map

package/dist/src/schemas/headless.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"headless.d.mts","names":[],"sources":["../../../src/schemas/headless.ts"],"mappings":"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"}
+{"version":3,"file":"headless.d.mts","names":[],"sources":["../../../src/schemas/headless.ts"],"mappings":"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"}

package/dist/src/schemas/headless.mjs

@@ -1,55 +1,55 @@
 //#region src/schemas/headless.ts
 /** Session-only contributions. This is not a Pi ExtensionAPI or a TUI adapter. */
-const DOOM_HEADLESS_HOST_SERVICE = "doom/headless-host";
-const DOOM_HEADLESS_OWNER = Symbol.for("doom/headless-owner");
-const PROMPT_ADMISSION_ERROR = "DoomHeadlessPromptAdmissionError";
-/** Admission is a host boundary, not an advisory facet-hook failure. */
-var DoomHeadlessPromptAdmissionError = class extends Error {
+const PO_HEADLESS_HOST_SERVICE = "po/headless-host";
+const PO_HEADLESS_OWNER = Symbol.for("po/headless-owner");
+const PROMPT_ADMISSION_ERROR = "PoHeadlessPromptAdmissionError";
+/** Admission is a host boundary, not an advisory package-hook failure. */
+var PoHeadlessPromptAdmissionError = class extends Error {
 	constructor(cause) {
 		super(cause instanceof Error ? cause.message : String(cause), { cause });
 		this.name = PROMPT_ADMISSION_ERROR;
 	}
 };
-const SESSION_SETUP_ERROR = "DoomSessionSetupError";
+const SESSION_SETUP_ERROR = "PoSessionSetupError";
 /**
 * A session cannot start until the user fixes their setup, such as configuring a model.
 *
 * Its message is written for the user and says what to do, so a server returns it as is
 * rather than hiding it behind a generic internal error.
 */
-var DoomSessionSetupError = class extends Error {
+var PoSessionSetupError = class extends Error {
 	constructor(message) {
 		super(message);
 		this.name = SESSION_SETUP_ERROR;
 	}
 };
 /** Error identity must survive independently bundled server and extension graphs. */
-function isDoomSessionSetupError(error) {
+function isPoSessionSetupError(error) {
 	return error instanceof Error && error.name === SESSION_SETUP_ERROR;
 }
 /** Error identity must survive independently bundled server and extension graphs. */
-function isDoomHeadlessPromptAdmissionError(error) {
+function isPoHeadlessPromptAdmissionError(error) {
 	return error instanceof Error && error.name === PROMPT_ADMISSION_ERROR;
 }
-const TOOL_BUSY_ERROR = "DoomHeadlessToolBusyError";
+const TOOL_BUSY_ERROR = "PoHeadlessToolBusyError";
 /** The tool and its hooks have not started. */
-var DoomHeadlessToolBusyError = class extends Error {
+var PoHeadlessToolBusyError = class extends Error {
 	constructor() {
 		super("An operation is already running");
 		this.name = TOOL_BUSY_ERROR;
 	}
 };
-function isDoomHeadlessToolBusyError(error) {
+function isPoHeadlessToolBusyError(error) {
 	return error instanceof Error && error.name === TOOL_BUSY_ERROR;
 }
-function readDoomHeadlessOwner(context) {
-	return context[DOOM_HEADLESS_OWNER];
+function readPoHeadlessOwner(context) {
+	return context[PO_HEADLESS_OWNER];
 }
 /**
 * Narrows a Pi tool result to the headless contract. Pi types `structuredContent` as any JSON
 * value, while MCP only accepts an object, so anything else is dropped rather than forwarded.
 */
-function toDoomHeadlessToolResult(result) {
+function toPoHeadlessToolResult(result) {
 	const { structuredContent } = result;
 	return {
 		content: result.content,
@@ -60,25 +60,25 @@ function toDoomHeadlessToolResult(result) {
 	};
 }
 /** Visibility controls model discovery only, never admission for external execution. */
-function isDoomHeadlessToolModelVisible(tool) {
+function isPoHeadlessToolModelVisible(tool) {
 	const visibility = tool._meta?.ui?.visibility;
 	return visibility === void 0 || visibility.includes("model");
 }
-/** Registrations inherit package ownership from the caller's Cordis facet. */
+/** Registrations inherit package ownership from the caller's Cordis fiber. */
 /**
 * The tool a server session loads skills through. When a session carries it, the prompt lists
 * every skill by name and points here, so a skill needs no file the agent could read.
 */
-const DOOM_LOAD_SKILL_TOOL = "load_skill";
-function readDoomHeadlessHost(context) {
-	return context.get(DOOM_HEADLESS_HOST_SERVICE);
+const PO_LOAD_SKILL_TOOL = "load_skill";
+function readPoHeadlessHost(context) {
+	return context.get(PO_HEADLESS_HOST_SERVICE);
 }
-function requireDoomHeadlessHost(context) {
-	const host = readDoomHeadlessHost(context);
-	if (!host) throw new Error("This contribution requires the Doom headless session host.");
+function requirePoHeadlessHost(context) {
+	const host = readPoHeadlessHost(context);
+	if (!host) throw new Error("This contribution requires the Po headless session host.");
 	return host;
 }
 //#endregion
-export { DOOM_HEADLESS_HOST_SERVICE, DOOM_HEADLESS_OWNER, DOOM_LOAD_SKILL_TOOL, DoomHeadlessPromptAdmissionError, DoomHeadlessToolBusyError, DoomSessionSetupError, isDoomHeadlessPromptAdmissionError, isDoomHeadlessToolBusyError, isDoomHeadlessToolModelVisible, isDoomSessionSetupError, readDoomHeadlessHost, readDoomHeadlessOwner, requireDoomHeadlessHost, toDoomHeadlessToolResult };
+export { PO_HEADLESS_HOST_SERVICE, PO_HEADLESS_OWNER, PO_LOAD_SKILL_TOOL, PoHeadlessPromptAdmissionError, PoHeadlessToolBusyError, PoSessionSetupError, isPoHeadlessPromptAdmissionError, isPoHeadlessToolBusyError, isPoHeadlessToolModelVisible, isPoSessionSetupError, readPoHeadlessHost, readPoHeadlessOwner, requirePoHeadlessHost, toPoHeadlessToolResult };
 
 //# sourceMappingURL=headless.mjs.map