@esso0428/pi-subagents 0.17.16 → 0.17.18

package/dist/workflow/worker-source.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker-source.js","sourceRoot":"","sources":["../../src/workflow/worker-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;GAMG;AACH,MAAM,mBAAmB,GACvB,6BAA6B;IAC7B,oCAAoC;IACpC,gCAAgC;IAChC,gFAAgF;IAChF,+EAA+E;IAC/E,KAAK;IACL,8DAA8D;IAC9D,gEAAgE;IAChE,+CAA+C;IAC/C,0FAA0F;IAC1F,KAAK;IACL,OAAO,CAAC;AAEV,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;kBAOX,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAisBpD,CAAC"}

package/dist/worktree.d.ts

@@ -1,53 +0,0 @@
-/**
- * worktree.ts — Git worktree isolation for agents.
- *
- * Creates a temporary git worktree so the agent works on an isolated copy of the repo.
- * On completion, if no changes were made, the worktree is cleaned up.
- * If changes exist, a branch is created and returned in the result.
- *
- * Every git call goes through `pi.exec` (async) rather than `execFileSync`: a
- * worktree copy can take seconds, and a session that spawns several isolated
- * agents at once would otherwise serialize them all on the TUI's event loop.
- */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-export interface WorktreeInfo {
-    /** Absolute path to the worktree directory (the copied repo's root). */
-    path: string;
-    /** Branch name created for this worktree (if changes exist). */
-    branch: string;
-    /** Commit SHA that the worktree was created from. */
-    baseSha: string;
-    /**
-     * Where the agent should work inside the worktree: the equivalent of the
-     * cwd the worktree was created from. Equals `path` when that cwd was the
-     * repo root; points at the copied subdirectory when it was deeper (e.g. a
-     * monorepo package), so the requested scoping survives isolation.
-     */
-    workPath: string;
-}
-export declare function setWorktreeIsolationEnabled(enabled: boolean): void;
-export declare function isWorktreeIsolationEnabled(): boolean;
-export interface WorktreeCleanupResult {
-    /** Whether changes were found in the worktree. */
-    hasChanges: boolean;
-    /** Branch name if changes were committed. */
-    branch?: string;
-    /** Worktree path if it was kept. */
-    path?: string;
-}
-/**
- * Create a temporary git worktree for an agent.
- * Returns the worktree path, or undefined if not in a git repo.
- */
-export declare function createWorktree(pi: ExtensionAPI, cwd: string, agentId: string): Promise<WorktreeInfo | undefined>;
-/**
- * Clean up a worktree after agent completion.
- * - If no changes: remove worktree entirely.
- * - If changes exist: create a branch, commit changes, return branch info.
- */
-export declare function cleanupWorktree(pi: ExtensionAPI, cwd: string, worktree: WorktreeInfo, agentDescription: string): Promise<WorktreeCleanupResult>;
-/**
- * Prune any orphaned worktrees (crash recovery).
- */
-export declare function pruneWorktrees(pi: ExtensionAPI, cwd: string): Promise<void>;
-//# sourceMappingURL=worktree.d.ts.map

package/dist/worktree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../src/worktree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAcD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAElE;AAED,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,MAAM,WAAW,qBAAqB;IACpC,kDAAkD;IAClD,UAAU,EAAE,OAAO,CAAC;IACpB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAmBD;;;GAGG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,YAAY,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CA6BnC;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,EAAE,EAAE,YAAY,EAChB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,YAAY,EACtB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,qBAAqB,CAAC,CAoDhC;AAgBD;;GAEG;AACH,wBAAsB,cAAc,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIjF"}

package/dist/worktree.js

@@ -1,165 +0,0 @@
-/**
- * worktree.ts — Git worktree isolation for agents.
- *
- * Creates a temporary git worktree so the agent works on an isolated copy of the repo.
- * On completion, if no changes were made, the worktree is cleaned up.
- * If changes exist, a branch is created and returned in the result.
- *
- * Every git call goes through `pi.exec` (async) rather than `execFileSync`: a
- * worktree copy can take seconds, and a session that spawns several isolated
- * agents at once would otherwise serialize them all on the TUI's event loop.
- */
-import { randomUUID } from "node:crypto";
-import { existsSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, relative } from "node:path";
-/**
- * Project-wide switch for worktree isolation (`worktreeIsolation` in
- * subagents.json). Default `true` — unchanged behaviour.
- *
- * The `"off"` isolation value gives a model a legal way to decline a worktree,
- * but it still depends on the model choosing it. This is the deterministic half
- * of the same fix: on a large repo where every worktree costs real time and
- * disk (#184), turning it off means no caller can create one, whatever it
- * passes.
- */
-let worktreeIsolationEnabled = true;
-export function setWorktreeIsolationEnabled(enabled) {
-    worktreeIsolationEnabled = enabled;
-}
-export function isWorktreeIsolationEnabled() {
-    return worktreeIsolationEnabled;
-}
-/**
- * Run git and return its trimmed stdout, throwing on failure so callers keep
- * the try/catch control flow `execFileSync` gave them.
- *
- * `pi.exec` never rejects — it reports failure in the result — and a command
- * killed by its timeout comes back as `killed` with an exit code of 0, so both
- * have to be checked to reproduce `execFileSync`'s "throws on anything but a
- * clean exit".
- */
-async function git(pi, cwd, args, timeout) {
-    const result = await pi.exec("git", args, { cwd, timeout });
-    if (result.killed || result.code !== 0) {
-        throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed (exit ${result.code})`);
-    }
-    return result.stdout.trim();
-}
-/**
- * Create a temporary git worktree for an agent.
- * Returns the worktree path, or undefined if not in a git repo.
- */
-export async function createWorktree(pi, cwd, agentId) {
-    // Verify we're in a git repo with at least one commit (HEAD must exist)
-    let baseSha;
-    let subdir;
-    try {
-        await git(pi, cwd, ["rev-parse", "--is-inside-work-tree"], 5000);
-        baseSha = await git(pi, cwd, ["rev-parse", "HEAD"], 5000);
-        // Where cwd sits inside the repo ("" at the root): the agent must work at
-        // the same subdirectory inside the copy, or a monorepo-package cwd would
-        // silently widen to the whole repo. realpath both sides — git emits
-        // resolved paths while cwd may arrive through a symlink (macOS /tmp).
-        const topLevel = await git(pi, cwd, ["rev-parse", "--show-toplevel"], 5000);
-        subdir = relative(realpathSync(topLevel), realpathSync(cwd));
-    }
-    catch {
-        return undefined;
-    }
-    const branch = `pi-agent-${agentId}`;
-    const suffix = randomUUID().slice(0, 8);
-    const worktreePath = join(tmpdir(), `pi-agent-${agentId}-${suffix}`);
-    try {
-        // Create detached worktree at HEAD
-        await git(pi, cwd, ["worktree", "add", "--detach", worktreePath, "HEAD"], 30000);
-        return { path: worktreePath, branch, baseSha, workPath: subdir ? join(worktreePath, subdir) : worktreePath };
-    }
-    catch {
-        // If worktree creation fails, return undefined (agent runs in normal cwd)
-        return undefined;
-    }
-}
-/**
- * Clean up a worktree after agent completion.
- * - If no changes: remove worktree entirely.
- * - If changes exist: create a branch, commit changes, return branch info.
- */
-export async function cleanupWorktree(pi, cwd, worktree, agentDescription) {
-    if (!existsSync(worktree.path)) {
-        return { hasChanges: false };
-    }
-    try {
-        // Check for uncommitted changes in the worktree
-        const status = await git(pi, worktree.path, ["status", "--porcelain"], 10000);
-        if (status) {
-            // Changes exist — stage, commit, and create a branch
-            await git(pi, worktree.path, ["add", "-A"], 10000);
-            // Truncate description for commit message (no shell sanitization needed — pi.exec uses argv)
-            const safeDesc = agentDescription.slice(0, 200);
-            const commitMsg = `pi-agent: ${safeDesc}`;
-            await git(pi, worktree.path, ["commit", "--no-verify", "-m", commitMsg], 10000);
-        }
-        else {
-            const currentSha = await git(pi, worktree.path, ["rev-parse", "HEAD"], 5000);
-            if (currentSha === worktree.baseSha) {
-                // No changes — remove worktree
-                await removeWorktree(pi, cwd, worktree.path);
-                return { hasChanges: false };
-            }
-        }
-        // Create a branch pointing to the worktree's HEAD.
-        // If the branch already exists, append a suffix to avoid overwriting previous work.
-        let branchName = worktree.branch;
-        try {
-            await git(pi, worktree.path, ["branch", branchName], 5000);
-        }
-        catch {
-            // Branch already exists — use a unique suffix
-            branchName = `${worktree.branch}-${Date.now()}`;
-            await git(pi, worktree.path, ["branch", branchName], 5000);
-        }
-        // Update branch name in worktree info for the caller
-        worktree.branch = branchName;
-        // Remove the worktree (branch persists in main repo)
-        await removeWorktree(pi, cwd, worktree.path);
-        return {
-            hasChanges: true,
-            branch: worktree.branch,
-            path: worktree.path,
-        };
-    }
-    catch {
-        // Best effort cleanup on error
-        try {
-            await removeWorktree(pi, cwd, worktree.path);
-        }
-        catch { /* ignore */ }
-        return { hasChanges: false };
-    }
-}
-/**
- * Force-remove a worktree.
- */
-async function removeWorktree(pi, cwd, worktreePath) {
-    try {
-        await git(pi, cwd, ["worktree", "remove", "--force", worktreePath], 10000);
-    }
-    catch {
-        // If git worktree remove fails, try pruning
-        try {
-            await git(pi, cwd, ["worktree", "prune"], 5000);
-        }
-        catch { /* ignore */ }
-    }
-}
-/**
- * Prune any orphaned worktrees (crash recovery).
- */
-export async function pruneWorktrees(pi, cwd) {
-    try {
-        await git(pi, cwd, ["worktree", "prune"], 5000);
-    }
-    catch { /* ignore */ }
-}
-//# sourceMappingURL=worktree.js.map

package/dist/worktree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"worktree.js","sourceRoot":"","sources":["../src/worktree.ts"],"names":[],"mappings":"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"}

package/dist/write-execution.d.ts

@@ -1,42 +0,0 @@
-import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
-/** Maximum UTF-8 size of the durable display diff plus unified patch. */
-export declare const MAX_DURABLE_DIFF_BYTES: number;
-/** Avoid retaining arbitrarily large previous files in the live-only store. */
-export declare const MAX_COMPARABLE_WRITE_BYTES = 512000;
-export declare const MAX_WRITE_METADATA_ENTRIES = 100;
-export interface DurableWriteDetails {
-    diff?: string;
-    patch?: string;
-    firstChangedLine?: number;
-    diffUnavailableReason?: string;
-}
-/** Ephemeral execution metadata used by the live renderer. Never persisted as a before/after pair. */
-export interface WriteExecutionMeta extends DurableWriteDetails {
-    fileExistedBeforeWrite: boolean;
-    previousContent?: string;
-}
-export declare class WriteExecutionMetadataStore {
-    readonly entries: Map<string, WriteExecutionMeta>;
-    set(toolCallId: string, metadata: WriteExecutionMeta): void;
-    get(toolCallId: unknown): WriteExecutionMeta | undefined;
-    delete(toolCallId: string): void;
-    clear(): void;
-}
-type WriteParams = {
-    path: string;
-    content: string;
-};
-export declare function executeWriteWithMetadata(store: WriteExecutionMetadataStore, toolCallId: string, params: WriteParams, signal: AbortSignal | undefined, cwd: string): Promise<{
-    content: Array<{
-        type: "text";
-        text: string;
-    }>;
-    details?: DurableWriteDetails;
-}>;
-/**
- * A session-local write definition. It retains Pi's public schema/description
- * and replaces only execution so the parent registry is never mutated.
- */
-export declare function createTrackedWriteTool(cwd: string, store?: WriteExecutionMetadataStore): ToolDefinition<any, DurableWriteDetails>;
-export {};
-//# sourceMappingURL=write-execution.d.ts.map

package/dist/write-execution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write-execution.d.ts","sourceRoot":"","sources":["../src/write-execution.ts"],"names":[],"mappings":"AAEA,OAAO,EAA8F,KAAK,cAAc,EAAyB,MAAM,iCAAiC,CAAC;AAEzL,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,QAAkB,CAAC;AACtD,+EAA+E;AAC/E,eAAO,MAAM,0BAA0B,SAAU,CAAC;AAClD,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,sGAAsG;AACtG,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,sBAAsB,EAAE,OAAO,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,2BAA2B;IACtC,QAAQ,CAAC,OAAO,kCAAyC;IAEzD,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAU3D,GAAG,CAAC,UAAU,EAAE,OAAO,GAAG,kBAAkB,GAAG,SAAS;IAIxD,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIhC,KAAK,IAAI,IAAI;CAGd;AAED,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AA2ErD,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,2BAA2B,EAClC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,mBAAmB,CAAA;CAAE,CAAC,CA0B5F;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,KAAK,8BAAoC,GACxC,cAAc,CAAC,GAAG,EAAE,mBAAmB,CAAC,CAc1C"}

package/dist/write-execution.js

@@ -1,138 +0,0 @@
-import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, resolve } from "node:path";
-import { createWriteToolDefinition, generateDiffString, generateUnifiedPatch, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-/** Maximum UTF-8 size of the durable display diff plus unified patch. */
-export const MAX_DURABLE_DIFF_BYTES = 4 * 1024 * 1024;
-/** Avoid retaining arbitrarily large previous files in the live-only store. */
-export const MAX_COMPARABLE_WRITE_BYTES = 512_000;
-export const MAX_WRITE_METADATA_ENTRIES = 100;
-export class WriteExecutionMetadataStore {
-    entries = new Map();
-    set(toolCallId, metadata) {
-        this.entries.delete(toolCallId);
-        this.entries.set(toolCallId, metadata);
-        while (this.entries.size > MAX_WRITE_METADATA_ENTRIES) {
-            const oldest = this.entries.keys().next().value;
-            if (oldest === undefined)
-                break;
-            this.entries.delete(oldest);
-        }
-    }
-    get(toolCallId) {
-        return typeof toolCallId === "string" ? this.entries.get(toolCallId) : undefined;
-    }
-    delete(toolCallId) {
-        this.entries.delete(toolCallId);
-    }
-    clear() {
-        this.entries.clear();
-    }
-}
-function resolveWritePath(path, cwd) {
-    if (path === "~")
-        return process.env.HOME ?? cwd;
-    if (path.startsWith("~/") || path.startsWith("~\\")) {
-        return resolve(process.env.HOME ?? cwd, path.slice(2));
-    }
-    return isAbsolute(path) ? path : resolve(cwd, path);
-}
-async function capturePreviousContent(absolutePath) {
-    let info;
-    try {
-        info = await lstat(absolutePath);
-    }
-    catch (error) {
-        if (error?.code === "ENOENT")
-            return { fileExistedBeforeWrite: false, previousContent: "" };
-        return {
-            fileExistedBeforeWrite: true,
-            diffUnavailableReason: "unable to inspect the previous file",
-        };
-    }
-    if (!info.isFile()) {
-        return {
-            fileExistedBeforeWrite: true,
-            diffUnavailableReason: "previous path is not a regular file",
-        };
-    }
-    if (info.size > MAX_COMPARABLE_WRITE_BYTES) {
-        return {
-            fileExistedBeforeWrite: true,
-            diffUnavailableReason: `previous file exceeds ${MAX_COMPARABLE_WRITE_BYTES} bytes`,
-        };
-    }
-    try {
-        const bytes = await readFile(absolutePath);
-        if (bytes.byteLength > MAX_COMPARABLE_WRITE_BYTES) {
-            return {
-                fileExistedBeforeWrite: true,
-                diffUnavailableReason: `previous file exceeds ${MAX_COMPARABLE_WRITE_BYTES} bytes`,
-            };
-        }
-        const previousContent = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-        return { fileExistedBeforeWrite: true, previousContent };
-    }
-    catch {
-        return {
-            fileExistedBeforeWrite: true,
-            diffUnavailableReason: "previous file is not comparable UTF-8 text",
-        };
-    }
-}
-function durableDetails(metadata, path, content) {
-    if (metadata.diffUnavailableReason) {
-        return { diffUnavailableReason: metadata.diffUnavailableReason };
-    }
-    const previousContent = metadata.previousContent ?? "";
-    const diffResult = generateDiffString(previousContent, content);
-    const patch = generateUnifiedPatch(path, previousContent, content);
-    const totalBytes = Buffer.byteLength(diffResult.diff, "utf8") + Buffer.byteLength(patch, "utf8");
-    if (totalBytes > MAX_DURABLE_DIFF_BYTES) {
-        return { diffUnavailableReason: `durable diff exceeds ${MAX_DURABLE_DIFF_BYTES} bytes` };
-    }
-    return {
-        diff: diffResult.diff,
-        patch,
-        firstChangedLine: diffResult.firstChangedLine,
-    };
-}
-export async function executeWriteWithMetadata(store, toolCallId, params, signal, cwd) {
-    const absolutePath = resolveWritePath(params.path, cwd);
-    store.delete(toolCallId);
-    return withFileMutationQueue(absolutePath, async () => {
-        const throwIfAborted = () => {
-            if (signal?.aborted)
-                throw new Error("Operation aborted");
-        };
-        throwIfAborted();
-        const metadata = await capturePreviousContent(absolutePath);
-        throwIfAborted();
-        await mkdir(dirname(absolutePath), { recursive: true });
-        throwIfAborted();
-        await writeFile(absolutePath, params.content, "utf8");
-        throwIfAborted();
-        const details = durableDetails(metadata, params.path, params.content);
-        store.set(toolCallId, { ...metadata, ...details });
-        return {
-            content: [{ type: "text", text: `Successfully wrote to ${params.path}` }],
-            details,
-        };
-    }).catch((error) => {
-        store.delete(toolCallId);
-        throw error;
-    });
-}
-/**
- * A session-local write definition. It retains Pi's public schema/description
- * and replaces only execution so the parent registry is never mutated.
- */
-export function createTrackedWriteTool(cwd, store = new WriteExecutionMetadataStore()) {
-    const nativeWrite = createWriteToolDefinition(cwd);
-    return {
-        ...nativeWrite,
-        async execute(toolCallId, params, signal, _onUpdate, ctx) {
-            return executeWriteWithMetadata(store, toolCallId, params, signal, ctx.cwd || cwd);
-        },
-    };
-}
-//# sourceMappingURL=write-execution.js.map

package/dist/write-execution.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"write-execution.js","sourceRoot":"","sources":["../src/write-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,yBAAyB,EAAyB,kBAAkB,EAAE,oBAAoB,EAAuB,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAEzL,yEAAyE;AACzE,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AACtD,+EAA+E;AAC/E,MAAM,CAAC,MAAM,0BAA0B,GAAG,OAAO,CAAC;AAClD,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAe9C,MAAM,OAAO,2BAA2B;IAC7B,OAAO,GAAG,IAAI,GAAG,EAA8B,CAAC;IAEzD,GAAG,CAAC,UAAkB,EAAE,QAA4B;QAClD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,0BAA0B,EAAE,CAAC;YACtD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YAChD,IAAI,MAAM,KAAK,SAAS;gBAAE,MAAM;YAChC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,GAAG,CAAC,UAAmB;QACrB,OAAO,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACnF,CAAC;IAED,MAAM,CAAC,UAAkB;QACvB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IAED,KAAK;QACH,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;CACF;AAID,SAAS,gBAAgB,CAAC,IAAY,EAAE,GAAW;IACjD,IAAI,IAAI,KAAK,GAAG;QAAE,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC;IACjD,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,OAAO,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACtD,CAAC;AAED,KAAK,UAAU,sBAAsB,CAAC,YAAoB;IACxD,IAAI,IAAuC,CAAC;IAC5C,IAAI,CAAC;QACH,IAAI,GAAG,MAAM,KAAK,CAAC,YAAY,CAAC,CAAC;IACnC,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,IAAI,KAAK,EAAE,IAAI,KAAK,QAAQ;YAAE,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC;QAC5F,OAAO;YACL,sBAAsB,EAAE,IAAI;YAC5B,qBAAqB,EAAE,qCAAqC;SAC7D,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;QACnB,OAAO;YACL,sBAAsB,EAAE,IAAI;YAC5B,qBAAqB,EAAE,qCAAqC;SAC7D,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,CAAC,IAAI,GAAG,0BAA0B,EAAE,CAAC;QAC3C,OAAO;YACL,sBAAsB,EAAE,IAAI;YAC5B,qBAAqB,EAAE,yBAAyB,0BAA0B,QAAQ;SACnF,CAAC;IACJ,CAAC;IAED,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,YAAY,CAAC,CAAC;QAC3C,IAAI,KAAK,CAAC,UAAU,GAAG,0BAA0B,EAAE,CAAC;YAClD,OAAO;gBACL,sBAAsB,EAAE,IAAI;gBAC5B,qBAAqB,EAAE,yBAAyB,0BAA0B,QAAQ;aACnF,CAAC;QACJ,CAAC;QACD,MAAM,eAAe,GAAG,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAChF,OAAO,EAAE,sBAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IAC3D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO;YACL,sBAAsB,EAAE,IAAI;YAC5B,qBAAqB,EAAE,4CAA4C;SACpE,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CACrB,QAA4B,EAC5B,IAAY,EACZ,OAAe;IAEf,IAAI,QAAQ,CAAC,qBAAqB,EAAE,CAAC;QACnC,OAAO,EAAE,qBAAqB,EAAE,QAAQ,CAAC,qBAAqB,EAAE,CAAC;IACnE,CAAC;IACD,MAAM,eAAe,GAAG,QAAQ,CAAC,eAAe,IAAI,EAAE,CAAC;IACvD,MAAM,UAAU,GAAG,kBAAkB,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,oBAAoB,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACnE,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACjG,IAAI,UAAU,GAAG,sBAAsB,EAAE,CAAC;QACxC,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,sBAAsB,QAAQ,EAAE,CAAC;IAC3F,CAAC;IACD,OAAO;QACL,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,KAAK;QACL,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;KAC9C,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,KAAkC,EAClC,UAAkB,EAClB,MAAmB,EACnB,MAA+B,EAC/B,GAAW;IAEX,MAAM,YAAY,GAAG,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACxD,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAEzB,OAAO,qBAAqB,CAAC,YAAY,EAAE,KAAK,IAAI,EAAE;QACpD,MAAM,cAAc,GAAG,GAAG,EAAE;YAC1B,IAAI,MAAM,EAAE,OAAO;gBAAE,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;QAC5D,CAAC,CAAC;QACF,cAAc,EAAE,CAAC;QACjB,MAAM,QAAQ,GAAG,MAAM,sBAAsB,CAAC,YAAY,CAAC,CAAC;QAC5D,cAAc,EAAE,CAAC;QACjB,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxD,cAAc,EAAE,CAAC;QACjB,MAAM,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACtD,cAAc,EAAE,CAAC;QAEjB,MAAM,OAAO,GAAG,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;QACtE,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,GAAG,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QACnD,OAAO;YACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,yBAAyB,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YAClF,OAAO;SACR,CAAC;IACJ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;QACjB,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QACzB,MAAM,KAAK,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACpC,GAAW,EACX,KAAK,GAAG,IAAI,2BAA2B,EAAE;IAEzC,MAAM,WAAW,GAAG,yBAAyB,CAAC,GAAG,CAAC,CAAC;IACnD,OAAO;QACL,GAAG,WAAW;QACd,KAAK,CAAC,OAAO,CACX,UAAkB,EAClB,MAAmB,EACnB,MAA+B,EAC/B,SAAkB,EAClB,GAAqB;YAErB,OAAO,wBAAwB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;QACrF,CAAC;KAC0C,CAAC;AAChD,CAAC"}

package/dist/xml.d.ts

@@ -1,11 +0,0 @@
-/**
- * xml.ts — escaping for the `<task-notification>` payloads.
- *
- * A module of its own because both notification builders need it and they sit
- * on opposite sides of a dependency edge: the agent one lives in `index.ts`,
- * which imports `workflow/task.ts`, so the workflow one cannot reach back for
- * it without a cycle.
- */
-/** Escape XML special characters to prevent injection in structured notifications. */
-export declare function escapeXml(s: string): string;
-//# sourceMappingURL=xml.d.ts.map

package/dist/xml.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../src/xml.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,sFAAsF;AACtF,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3C"}

package/dist/xml.js

@@ -1,13 +0,0 @@
-/**
- * xml.ts — escaping for the `<task-notification>` payloads.
- *
- * A module of its own because both notification builders need it and they sit
- * on opposite sides of a dependency edge: the agent one lives in `index.ts`,
- * which imports `workflow/task.ts`, so the workflow one cannot reach back for
- * it without a cycle.
- */
-/** Escape XML special characters to prevent injection in structured notifications. */
-export function escapeXml(s) {
-    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-//# sourceMappingURL=xml.js.map

package/dist/xml.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"xml.js","sourceRoot":"","sources":["../src/xml.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,sFAAsF;AACtF,MAAM,UAAU,SAAS,CAAC,CAAS;IACjC,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC9E,CAAC"}

package/src/abortable.ts

@@ -1,43 +0,0 @@
-/**
- * abortable.ts — race a promise against an AbortSignal without cancelling the
- * underlying work.
- *
- * Used by the `get_subagent_result` wait paths (top-level and nested): pressing
- * Esc cancels only the caller's wait; the background child keeps running and its
- * result stays unconsumed. The listener is removed on every settle path so the
- * signal accumulates no handlers, and a late settlement of the wrapped promise
- * after an abort is absorbed as a no-op (no unhandled rejection).
- */
-
-/** Await a promise until it settles or the caller cancels, without aborting the underlying work. */
-export function abortable<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
-  if (!signal) return promise;
-  if (signal.aborted) return Promise.reject(signal.reason);
-
-  return new Promise<T>((resolve, reject) => {
-    let settled = false;
-    const cleanup = () => signal.removeEventListener("abort", onAbort);
-    const onAbort = () => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      reject(signal.reason);
-    };
-
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        if (settled) return;
-        settled = true;
-        cleanup();
-        resolve(value);
-      },
-      (error: unknown) => {
-        if (settled) return;
-        settled = true;
-        cleanup();
-        reject(error);
-      },
-    );
-  });
-}