skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/agents/sandbox/registry.d.ts

@@ -0,0 +1,30 @@
+export type SandboxRegistryEntry = {
+    containerName: string;
+    sessionKey: string;
+    createdAtMs: number;
+    lastUsedAtMs: number;
+    image: string;
+    configHash?: string;
+};
+type SandboxRegistry = {
+    entries: SandboxRegistryEntry[];
+};
+export type SandboxBrowserRegistryEntry = {
+    containerName: string;
+    sessionKey: string;
+    createdAtMs: number;
+    lastUsedAtMs: number;
+    image: string;
+    cdpPort: number;
+    noVncPort?: number;
+};
+type SandboxBrowserRegistry = {
+    entries: SandboxBrowserRegistryEntry[];
+};
+export declare function readRegistry(): Promise<SandboxRegistry>;
+export declare function updateRegistry(entry: SandboxRegistryEntry): Promise<void>;
+export declare function removeRegistryEntry(containerName: string): Promise<void>;
+export declare function readBrowserRegistry(): Promise<SandboxBrowserRegistry>;
+export declare function updateBrowserRegistry(entry: SandboxBrowserRegistryEntry): Promise<void>;
+export declare function removeBrowserRegistryEntry(containerName: string): Promise<void>;
+export {};

package/dist/plugin-sdk/agents/sandbox/runtime-status.d.ts

@@ -0,0 +1,18 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SandboxConfig, SandboxToolPolicyResolved } from "./types.js";
+export declare function resolveSandboxRuntimeStatus(params: {
+    cfg?: SKYKOIConfig;
+    sessionKey?: string;
+}): {
+    agentId: string;
+    sessionKey: string;
+    mainSessionKey: string;
+    mode: SandboxConfig["mode"];
+    sandboxed: boolean;
+    toolPolicy: SandboxToolPolicyResolved;
+};
+export declare function formatSandboxToolPolicyBlockedMessage(params: {
+    cfg?: SKYKOIConfig;
+    sessionKey?: string;
+    toolName: string;
+}): string | undefined;

package/dist/plugin-sdk/agents/sandbox/shared.d.ts

@@ -0,0 +1,4 @@
+export declare function slugifySessionKey(value: string): string;
+export declare function resolveSandboxWorkspaceDir(root: string, sessionKey: string): string;
+export declare function resolveSandboxScopeKey(scope: "session" | "agent" | "shared", sessionKey: string): string;
+export declare function resolveSandboxAgentId(scopeKey: string): string | undefined;

package/dist/plugin-sdk/agents/sandbox/tool-policy.d.ts

@@ -0,0 +1,4 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SandboxToolPolicy, SandboxToolPolicyResolved } from "./types.js";
+export declare function isToolAllowed(policy: SandboxToolPolicy, name: string): boolean;
+export declare function resolveSandboxToolPolicyForAgent(cfg?: SKYKOIConfig, agentId?: string): SandboxToolPolicyResolved;

package/dist/plugin-sdk/agents/sandbox/types.d.ts

@@ -0,0 +1,73 @@
+import type { SandboxDockerConfig } from "./types.docker.js";
+export type { SandboxDockerConfig } from "./types.docker.js";
+export type SandboxToolPolicy = {
+    allow?: string[];
+    deny?: string[];
+};
+export type SandboxToolPolicySource = {
+    source: "agent" | "global" | "default";
+    /**
+     * Config key path hint for humans.
+     * (Arrays use `agents.list[].…` form.)
+     */
+    key: string;
+};
+export type SandboxToolPolicyResolved = {
+    allow: string[];
+    deny: string[];
+    sources: {
+        allow: SandboxToolPolicySource;
+        deny: SandboxToolPolicySource;
+    };
+};
+export type SandboxWorkspaceAccess = "none" | "ro" | "rw";
+export type SandboxBrowserConfig = {
+    enabled: boolean;
+    image: string;
+    containerPrefix: string;
+    cdpPort: number;
+    vncPort: number;
+    noVncPort: number;
+    headless: boolean;
+    enableNoVnc: boolean;
+    allowHostControl: boolean;
+    autoStart: boolean;
+    autoStartTimeoutMs: number;
+};
+export type SandboxPruneConfig = {
+    idleHours: number;
+    maxAgeDays: number;
+};
+export type SandboxScope = "session" | "agent" | "shared";
+export type SandboxConfig = {
+    mode: "off" | "non-main" | "all";
+    scope: SandboxScope;
+    workspaceAccess: SandboxWorkspaceAccess;
+    workspaceRoot: string;
+    docker: SandboxDockerConfig;
+    browser: SandboxBrowserConfig;
+    tools: SandboxToolPolicy;
+    prune: SandboxPruneConfig;
+};
+export type SandboxBrowserContext = {
+    bridgeUrl: string;
+    noVncUrl?: string;
+    containerName: string;
+};
+export type SandboxContext = {
+    enabled: boolean;
+    sessionKey: string;
+    workspaceDir: string;
+    agentWorkspaceDir: string;
+    workspaceAccess: SandboxWorkspaceAccess;
+    containerName: string;
+    containerWorkdir: string;
+    docker: SandboxDockerConfig;
+    tools: SandboxToolPolicy;
+    browserAllowHostControl: boolean;
+    browser?: SandboxBrowserContext;
+};
+export type SandboxWorkspaceInfo = {
+    workspaceDir: string;
+    containerWorkdir: string;
+};

package/dist/plugin-sdk/agents/sandbox/types.docker.d.ts

@@ -0,0 +1,25 @@
+export type SandboxDockerConfig = {
+    image: string;
+    containerPrefix: string;
+    workdir: string;
+    readOnlyRoot: boolean;
+    tmpfs: string[];
+    network: string;
+    user?: string;
+    capDrop: string[];
+    env?: Record<string, string>;
+    setupCommand?: string;
+    pidsLimit?: number;
+    memory?: string | number;
+    memorySwap?: string | number;
+    cpus?: number;
+    ulimits?: Record<string, string | number | {
+        soft?: number;
+        hard?: number;
+    }>;
+    seccompProfile?: string;
+    apparmorProfile?: string;
+    dns?: string[];
+    extraHosts?: string[];
+    binds?: string[];
+};

package/dist/plugin-sdk/agents/sandbox/workspace.d.ts

@@ -0,0 +1 @@
+export declare function ensureSandboxWorkspace(workspaceDir: string, seedFrom?: string, skipBootstrap?: boolean): Promise<void>;

package/dist/plugin-sdk/agents/sandbox-paths.d.ts

@@ -0,0 +1,21 @@
+export declare function resolveSandboxPath(params: {
+    filePath: string;
+    cwd: string;
+    root: string;
+}): {
+    resolved: string;
+    relative: string;
+};
+export declare function assertSandboxPath(params: {
+    filePath: string;
+    cwd: string;
+    root: string;
+}): Promise<{
+    resolved: string;
+    relative: string;
+}>;
+export declare function assertMediaNotDataUrl(media: string): void;
+export declare function resolveSandboxedMediaSource(params: {
+    media: string;
+    sandboxRoot: string;
+}): Promise<string>;

package/dist/plugin-sdk/agents/sandbox.d.ts

@@ -0,0 +1,8 @@
+export { resolveSandboxBrowserConfig, resolveSandboxConfigForAgent, resolveSandboxDockerConfig, resolveSandboxPruneConfig, resolveSandboxScope, } from "./sandbox/config.js";
+export { DEFAULT_SANDBOX_BROWSER_IMAGE, DEFAULT_SANDBOX_COMMON_IMAGE, DEFAULT_SANDBOX_IMAGE, } from "./sandbox/constants.js";
+export { ensureSandboxWorkspaceForSession, resolveSandboxContext } from "./sandbox/context.js";
+export { buildSandboxCreateArgs } from "./sandbox/docker.js";
+export { listSandboxBrowsers, listSandboxContainers, removeSandboxBrowserContainer, removeSandboxContainer, type SandboxBrowserInfo, type SandboxContainerInfo, } from "./sandbox/manage.js";
+export { formatSandboxToolPolicyBlockedMessage, resolveSandboxRuntimeStatus, } from "./sandbox/runtime-status.js";
+export { resolveSandboxToolPolicyForAgent } from "./sandbox/tool-policy.js";
+export type { SandboxBrowserConfig, SandboxBrowserContext, SandboxConfig, SandboxContext, SandboxDockerConfig, SandboxPruneConfig, SandboxScope, SandboxToolPolicy, SandboxToolPolicyResolved, SandboxToolPolicySource, SandboxWorkspaceAccess, SandboxWorkspaceInfo, } from "./sandbox/types.js";

package/dist/plugin-sdk/agents/schema/clean-for-gemini.d.ts

@@ -0,0 +1,2 @@
+export declare const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS: Set<string>;
+export declare function cleanSchemaForGemini(schema: unknown): unknown;

package/dist/plugin-sdk/agents/schema/typebox.d.ts

@@ -0,0 +1,14 @@
+type StringEnumOptions<T extends readonly string[]> = {
+    description?: string;
+    title?: string;
+    default?: T[number];
+};
+export declare function stringEnum<T extends readonly string[]>(values: T, options?: StringEnumOptions<T>): import("@sinclair/typebox").TUnsafe<T[number]>;
+export declare function optionalStringEnum<T extends readonly string[]>(values: T, options?: StringEnumOptions<T>): import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<T[number]>>;
+export declare function channelTargetSchema(options?: {
+    description?: string;
+}): import("@sinclair/typebox").TString;
+export declare function channelTargetsSchema(options?: {
+    description?: string;
+}): import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+export {};

package/dist/plugin-sdk/agents/session-file-repair.d.ts

@@ -0,0 +1,11 @@
+type RepairReport = {
+    repaired: boolean;
+    droppedLines: number;
+    backupPath?: string;
+    reason?: string;
+};
+export declare function repairSessionFileIfNeeded(params: {
+    sessionFile: string;
+    warn?: (message: string) => void;
+}): Promise<RepairReport>;
+export {};

package/dist/plugin-sdk/agents/session-slug.d.ts

@@ -0,0 +1 @@
+export declare function createSessionSlug(isTaken?: (id: string) => boolean): string;

package/dist/plugin-sdk/agents/session-tool-result-guard-wrapper.d.ts

@@ -0,0 +1,14 @@
+import type { SessionManager } from "@mariozechner/pi-coding-agent";
+export type GuardedSessionManager = SessionManager & {
+    /** Flush any synthetic tool results for pending tool calls. Idempotent. */
+    flushPendingToolResults?: () => void;
+};
+/**
+ * Apply the tool-result guard to a SessionManager exactly once and expose
+ * a flush method on the instance for easy teardown handling.
+ */
+export declare function guardSessionManager(sessionManager: SessionManager, opts?: {
+    agentId?: string;
+    sessionKey?: string;
+    allowSyntheticToolResults?: boolean;
+}): GuardedSessionManager;

package/dist/plugin-sdk/agents/session-tool-result-guard.d.ts

@@ -0,0 +1,21 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { SessionManager } from "@mariozechner/pi-coding-agent";
+export declare function installSessionToolResultGuard(sessionManager: SessionManager, opts?: {
+    /**
+     * Optional, synchronous transform applied to toolResult messages *before* they are
+     * persisted to the session transcript.
+     */
+    transformToolResultForPersistence?: (message: AgentMessage, meta: {
+        toolCallId?: string;
+        toolName?: string;
+        isSynthetic?: boolean;
+    }) => AgentMessage;
+    /**
+     * Whether to synthesize missing tool results to satisfy strict providers.
+     * Defaults to true.
+     */
+    allowSyntheticToolResults?: boolean;
+}): {
+    flushPendingToolResults: () => void;
+    getPendingIds: () => string[];
+};

package/dist/plugin-sdk/agents/session-transcript-repair.d.ts

@@ -0,0 +1,26 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+declare function makeMissingToolResult(params: {
+    toolCallId: string;
+    toolName?: string;
+}): Extract<AgentMessage, {
+    role: "toolResult";
+}>;
+export { makeMissingToolResult };
+export type ToolCallInputRepairReport = {
+    messages: AgentMessage[];
+    droppedToolCalls: number;
+    droppedAssistantMessages: number;
+};
+export declare function repairToolCallInputs(messages: AgentMessage[]): ToolCallInputRepairReport;
+export declare function sanitizeToolCallInputs(messages: AgentMessage[]): AgentMessage[];
+export declare function sanitizeToolUseResultPairing(messages: AgentMessage[]): AgentMessage[];
+export type ToolUseRepairReport = {
+    messages: AgentMessage[];
+    added: Array<Extract<AgentMessage, {
+        role: "toolResult";
+    }>>;
+    droppedDuplicateCount: number;
+    droppedOrphanCount: number;
+    moved: boolean;
+};
+export declare function repairToolUseResultPairing(messages: AgentMessage[]): ToolUseRepairReport;

package/dist/plugin-sdk/agents/session-write-lock.d.ts

@@ -0,0 +1,21 @@
+declare const CLEANUP_SIGNALS: readonly ["SIGINT", "SIGTERM", "SIGQUIT", "SIGABRT"];
+type CleanupSignal = (typeof CLEANUP_SIGNALS)[number];
+/**
+ * Synchronously release all held locks.
+ * Used during process exit when async operations aren't reliable.
+ */
+declare function releaseAllLocksSync(): void;
+declare function handleTerminationSignal(signal: CleanupSignal): void;
+export declare function acquireSessionWriteLock(params: {
+    sessionFile: string;
+    timeoutMs?: number;
+    staleMs?: number;
+}): Promise<{
+    release: () => Promise<void>;
+}>;
+export declare const __testing: {
+    cleanupSignals: ("SIGABRT" | "SIGINT" | "SIGQUIT" | "SIGTERM")[];
+    handleTerminationSignal: typeof handleTerminationSignal;
+    releaseAllLocksSync: typeof releaseAllLocksSync;
+};
+export {};

package/dist/plugin-sdk/agents/shell-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function getShellConfig(): {
+    shell: string;
+    args: string[];
+};
+export declare function detectRuntimeShell(): string | undefined;
+export declare function sanitizeBinaryOutput(text: string): string;
+export declare function killProcessTree(pid: number): void;

package/dist/plugin-sdk/agents/skills/bundled-dir.d.ts

@@ -0,0 +1,7 @@
+export type BundledSkillsResolveOptions = {
+    argv1?: string;
+    moduleUrl?: string;
+    cwd?: string;
+    execPath?: string;
+};
+export declare function resolveBundledSkillsDir(opts?: BundledSkillsResolveOptions): string | undefined;

package/dist/plugin-sdk/agents/skills/config.d.ts

@@ -0,0 +1,14 @@
+import type { SKYKOIConfig, SkillConfig } from "../../config/config.js";
+import type { SkillEligibilityContext, SkillEntry } from "./types.js";
+export declare function resolveConfigPath(config: SKYKOIConfig | undefined, pathStr: string): unknown;
+export declare function isConfigPathTruthy(config: SKYKOIConfig | undefined, pathStr: string): boolean;
+export declare function resolveSkillConfig(config: SKYKOIConfig | undefined, skillKey: string): SkillConfig | undefined;
+export declare function resolveRuntimePlatform(): string;
+export declare function resolveBundledAllowlist(config?: SKYKOIConfig): string[] | undefined;
+export declare function isBundledSkillAllowed(entry: SkillEntry, allowlist?: string[]): boolean;
+export declare function hasBinary(bin: string): boolean;
+export declare function shouldIncludeSkill(params: {
+    entry: SkillEntry;
+    config?: SKYKOIConfig;
+    eligibility?: SkillEligibilityContext;
+}): boolean;

package/dist/plugin-sdk/agents/skills/env-overrides.d.ts

@@ -0,0 +1,10 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SkillEntry, SkillSnapshot } from "./types.js";
+export declare function applySkillEnvOverrides(params: {
+    skills: SkillEntry[];
+    config?: SKYKOIConfig;
+}): () => void;
+export declare function applySkillEnvOverridesFromSnapshot(params: {
+    snapshot?: SkillSnapshot;
+    config?: SKYKOIConfig;
+}): () => void;

package/dist/plugin-sdk/agents/skills/frontmatter.d.ts

@@ -0,0 +1,6 @@
+import type { Skill } from "@mariozechner/pi-coding-agent";
+import type { SKYKOISkillMetadata, ParsedSkillFrontmatter, SkillEntry, SkillInvocationPolicy } from "./types.js";
+export declare function parseFrontmatter(content: string): ParsedSkillFrontmatter;
+export declare function resolveSKYKOIMetadata(frontmatter: ParsedSkillFrontmatter): SKYKOISkillMetadata | undefined;
+export declare function resolveSkillInvocationPolicy(frontmatter: ParsedSkillFrontmatter): SkillInvocationPolicy;
+export declare function resolveSkillKey(skill: Skill, entry?: SkillEntry): string;

package/dist/plugin-sdk/agents/skills/plugin-skills.d.ts

@@ -0,0 +1,5 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+export declare function resolvePluginSkillDirs(params: {
+    workspaceDir: string;
+    config?: SKYKOIConfig;
+}): string[];

package/dist/plugin-sdk/agents/skills/refresh.d.ts

@@ -0,0 +1,19 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+type SkillsChangeEvent = {
+    workspaceDir?: string;
+    reason: "watch" | "manual" | "remote-node";
+    changedPath?: string;
+};
+export declare const DEFAULT_SKILLS_WATCH_IGNORED: RegExp[];
+export declare function registerSkillsChangeListener(listener: (event: SkillsChangeEvent) => void): () => void;
+export declare function bumpSkillsSnapshotVersion(params?: {
+    workspaceDir?: string;
+    reason?: SkillsChangeEvent["reason"];
+    changedPath?: string;
+}): number;
+export declare function getSkillsSnapshotVersion(workspaceDir?: string): number;
+export declare function ensureSkillsWatcher(params: {
+    workspaceDir: string;
+    config?: SKYKOIConfig;
+}): void;
+export {};

package/dist/plugin-sdk/agents/skills/serialize.d.ts

@@ -0,0 +1 @@
+export declare function serializeByKey<T>(key: string, task: () => Promise<T>): Promise<T>;

package/dist/plugin-sdk/agents/skills/types.d.ts

@@ -0,0 +1,80 @@
+import type { Skill } from "@mariozechner/pi-coding-agent";
+export type SkillInstallSpec = {
+    id?: string;
+    kind: "brew" | "node" | "go" | "uv" | "download";
+    label?: string;
+    bins?: string[];
+    os?: string[];
+    formula?: string;
+    package?: string;
+    module?: string;
+    url?: string;
+    archive?: string;
+    extract?: boolean;
+    stripComponents?: number;
+    targetDir?: string;
+};
+export type SKYKOISkillMetadata = {
+    always?: boolean;
+    skillKey?: string;
+    primaryEnv?: string;
+    emoji?: string;
+    homepage?: string;
+    os?: string[];
+    requires?: {
+        bins?: string[];
+        anyBins?: string[];
+        env?: string[];
+        config?: string[];
+    };
+    install?: SkillInstallSpec[];
+};
+export type SkillInvocationPolicy = {
+    userInvocable: boolean;
+    disableModelInvocation: boolean;
+};
+export type SkillCommandDispatchSpec = {
+    kind: "tool";
+    /** Name of the tool to invoke (AnyAgentTool.name). */
+    toolName: string;
+    /**
+     * How to forward user-provided args to the tool.
+     * - raw: forward the raw args string (no core parsing).
+     */
+    argMode?: "raw";
+};
+export type SkillCommandSpec = {
+    name: string;
+    skillName: string;
+    description: string;
+    /** Optional deterministic dispatch behavior for this command. */
+    dispatch?: SkillCommandDispatchSpec;
+};
+export type SkillsInstallPreferences = {
+    preferBrew: boolean;
+    nodeManager: "npm" | "pnpm" | "yarn" | "bun";
+};
+export type ParsedSkillFrontmatter = Record<string, string>;
+export type SkillEntry = {
+    skill: Skill;
+    frontmatter: ParsedSkillFrontmatter;
+    metadata?: SKYKOISkillMetadata;
+    invocation?: SkillInvocationPolicy;
+};
+export type SkillEligibilityContext = {
+    remote?: {
+        platforms: string[];
+        hasBin: (bin: string) => boolean;
+        hasAnyBin: (bins: string[]) => boolean;
+        note?: string;
+    };
+};
+export type SkillSnapshot = {
+    prompt: string;
+    skills: Array<{
+        name: string;
+        primaryEnv?: string;
+    }>;
+    resolvedSkills?: Skill[];
+    version?: number;
+};

package/dist/plugin-sdk/agents/skills/workspace.d.ts

@@ -0,0 +1,49 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { SkillEligibilityContext, SkillCommandSpec, SkillEntry, SkillSnapshot } from "./types.js";
+export declare function buildWorkspaceSkillSnapshot(workspaceDir: string, opts?: {
+    config?: SKYKOIConfig;
+    managedSkillsDir?: string;
+    bundledSkillsDir?: string;
+    entries?: SkillEntry[];
+    /** If provided, only include skills with these names */
+    skillFilter?: string[];
+    eligibility?: SkillEligibilityContext;
+    snapshotVersion?: number;
+}): SkillSnapshot;
+export declare function buildWorkspaceSkillsPrompt(workspaceDir: string, opts?: {
+    config?: SKYKOIConfig;
+    managedSkillsDir?: string;
+    bundledSkillsDir?: string;
+    entries?: SkillEntry[];
+    /** If provided, only include skills with these names */
+    skillFilter?: string[];
+    eligibility?: SkillEligibilityContext;
+}): string;
+export declare function resolveSkillsPromptForRun(params: {
+    skillsSnapshot?: SkillSnapshot;
+    entries?: SkillEntry[];
+    config?: SKYKOIConfig;
+    workspaceDir: string;
+}): string;
+export declare function loadWorkspaceSkillEntries(workspaceDir: string, opts?: {
+    config?: SKYKOIConfig;
+    managedSkillsDir?: string;
+    bundledSkillsDir?: string;
+}): SkillEntry[];
+export declare function syncSkillsToWorkspace(params: {
+    sourceWorkspaceDir: string;
+    targetWorkspaceDir: string;
+    config?: SKYKOIConfig;
+    managedSkillsDir?: string;
+    bundledSkillsDir?: string;
+}): Promise<void>;
+export declare function filterWorkspaceSkillEntries(entries: SkillEntry[], config?: SKYKOIConfig): SkillEntry[];
+export declare function buildWorkspaceSkillCommandSpecs(workspaceDir: string, opts?: {
+    config?: SKYKOIConfig;
+    managedSkillsDir?: string;
+    bundledSkillsDir?: string;
+    entries?: SkillEntry[];
+    skillFilter?: string[];
+    eligibility?: SkillEligibilityContext;
+    reservedNames?: Set<string>;
+}): SkillCommandSpec[];

package/dist/plugin-sdk/agents/skills.d.ts

@@ -0,0 +1,7 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import type { SkillsInstallPreferences } from "./skills/types.js";
+export { hasBinary, isBundledSkillAllowed, isConfigPathTruthy, resolveBundledAllowlist, resolveConfigPath, resolveRuntimePlatform, resolveSkillConfig, } from "./skills/config.js";
+export { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, } from "./skills/env-overrides.js";
+export type { SKYKOISkillMetadata, SkillEligibilityContext, SkillCommandSpec, SkillEntry, SkillInstallSpec, SkillSnapshot, SkillsInstallPreferences, } from "./skills/types.js";
+export { buildWorkspaceSkillSnapshot, buildWorkspaceSkillsPrompt, buildWorkspaceSkillCommandSpecs, filterWorkspaceSkillEntries, loadWorkspaceSkillEntries, resolveSkillsPromptForRun, syncSkillsToWorkspace, } from "./skills/workspace.js";
+export declare function resolveSkillsInstallPreferences(config?: SKYKOIConfig): SkillsInstallPreferences;

package/dist/plugin-sdk/agents/subagent-announce-queue.d.ts

@@ -0,0 +1,22 @@
+import { type QueueDropPolicy, type QueueMode } from "../auto-reply/reply/queue.js";
+import { type DeliveryContext } from "../utils/delivery-context.js";
+export type AnnounceQueueItem = {
+    prompt: string;
+    summaryLine?: string;
+    enqueuedAt: number;
+    sessionKey: string;
+    origin?: DeliveryContext;
+    originKey?: string;
+};
+export type AnnounceQueueSettings = {
+    mode: QueueMode;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: QueueDropPolicy;
+};
+export declare function enqueueAnnounce(params: {
+    key: string;
+    item: AnnounceQueueItem;
+    settings: AnnounceQueueSettings;
+    send: (item: AnnounceQueueItem) => Promise<void>;
+}): boolean;

package/dist/plugin-sdk/agents/subagent-announce.d.ts

@@ -0,0 +1,28 @@
+import { type DeliveryContext } from "../utils/delivery-context.js";
+export declare function buildSubagentSystemPrompt(params: {
+    requesterSessionKey?: string;
+    requesterOrigin?: DeliveryContext;
+    childSessionKey: string;
+    label?: string;
+    task?: string;
+}): string;
+export type SubagentRunOutcome = {
+    status: "ok" | "error" | "timeout" | "unknown";
+    error?: string;
+};
+export declare function runSubagentAnnounceFlow(params: {
+    childSessionKey: string;
+    childRunId: string;
+    requesterSessionKey: string;
+    requesterOrigin?: DeliveryContext;
+    requesterDisplayKey: string;
+    task: string;
+    timeoutMs: number;
+    cleanup: "delete" | "keep";
+    roundOneReply?: string;
+    waitForCompletion?: boolean;
+    startedAt?: number;
+    endedAt?: number;
+    label?: string;
+    outcome?: SubagentRunOutcome;
+}): Promise<boolean>;

package/dist/plugin-sdk/agents/subagent-registry.d.ts

@@ -0,0 +1,35 @@
+import { type DeliveryContext } from "../utils/delivery-context.js";
+import { type SubagentRunOutcome } from "./subagent-announce.js";
+export type SubagentRunRecord = {
+    runId: string;
+    childSessionKey: string;
+    requesterSessionKey: string;
+    requesterOrigin?: DeliveryContext;
+    requesterDisplayKey: string;
+    task: string;
+    cleanup: "delete" | "keep";
+    label?: string;
+    createdAt: number;
+    startedAt?: number;
+    endedAt?: number;
+    outcome?: SubagentRunOutcome;
+    archiveAtMs?: number;
+    cleanupCompletedAt?: number;
+    cleanupHandled?: boolean;
+};
+export declare function registerSubagentRun(params: {
+    runId: string;
+    childSessionKey: string;
+    requesterSessionKey: string;
+    requesterOrigin?: DeliveryContext;
+    requesterDisplayKey: string;
+    task: string;
+    cleanup: "delete" | "keep";
+    label?: string;
+    runTimeoutSeconds?: number;
+}): void;
+export declare function resetSubagentRegistryForTests(): void;
+export declare function addSubagentRunForTests(entry: SubagentRunRecord): void;
+export declare function releaseSubagentRun(runId: string): void;
+export declare function listSubagentRunsForRequester(requesterSessionKey: string): SubagentRunRecord[];
+export declare function initSubagentRegistry(): void;

package/dist/plugin-sdk/agents/subagent-registry.store.d.ts

@@ -0,0 +1,5 @@
+import type { SubagentRunRecord } from "./subagent-registry.js";
+export type PersistedSubagentRegistryVersion = 1 | 2;
+export declare function resolveSubagentRegistryPath(): string;
+export declare function loadSubagentRegistryFromDisk(): Map<string, SubagentRunRecord>;
+export declare function saveSubagentRegistryToDisk(runs: Map<string, SubagentRunRecord>): void;