@pome-sh/cli 0.20.0 → 0.21.0

package/dist/examples/agents/scripted-triage-agent.js

@@ -1,92 +0,0 @@
-if (process.env.POME_PREFLIGHT === "1") {
-    console.log("preflight ok");
-    process.exit(0);
-}
-const task = requiredEnv("POME_TASK");
-const baseUrl = requiredEnv("POME_GITHUB_REST_URL");
-const authToken = process.env.POME_AUTH_TOKEN;
-const issueNumber = Number(task.match(/#(\d+)/)?.[1] ?? "1");
-const repo = (task.match(/in\s+([a-z0-9_.-]+\/[a-z0-9_.-]+)/i)?.[1] ?? "acme/api").replace(/[.,]+$/, "");
-const [owner, name] = repo.split("/");
-// Wrapped in main() rather than left at the top level so `npx tsx` works in
-// a project without `"type": "module"` (where top-level await fails CJS
-// transform).
-async function main() {
-    const issue = await github(`/repos/${owner}/${name}/issues/${issueNumber}`);
-    const existingClassification = issue.labels.find((label) => ["bug", "feature", "question"].includes(label.name));
-    if (existingClassification) {
-        console.log(JSON.stringify({ task, summary: `Issue #${issueNumber} is already triaged as ${existingClassification.name}.` }));
-        process.exit(0);
-    }
-    const classification = classifyIssue(issue);
-    await ensureLabelApplied(owner, name, issueNumber, classification.label);
-    if (classification.assignee) {
-        await github(`/repos/${owner}/${name}/issues/${issueNumber}/assignees`, {
-            method: "POST",
-            body: { assignees: [classification.assignee] }
-        });
-    }
-    console.log(JSON.stringify({
-        task,
-        summary: `Issue #${issueNumber} labeled ${classification.label}${classification.assignee ? ` and assigned to ${classification.assignee}` : ""}.`
-    }));
-}
-main().catch((err) => {
-    console.error(err);
-    process.exit(1);
-});
-async function ensureLabelApplied(owner, repo, issueNumber, label) {
-    const apply = await fetch(`${baseUrl}/repos/${owner}/${repo}/issues/${issueNumber}/labels`, {
-        method: "POST",
-        headers: authHeaders({ "content-type": "application/json" }),
-        body: JSON.stringify({ labels: [label] })
-    });
-    if (apply.status === 422) {
-        await github(`/repos/${owner}/${repo}/labels`, {
-            method: "POST",
-            body: { name: label, color: label === "bug" ? "d73a4a" : "ededed" }
-        });
-        await github(`/repos/${owner}/${repo}/issues/${issueNumber}/labels`, {
-            method: "POST",
-            body: { labels: [label] }
-        });
-        return;
-    }
-    if (!apply.ok) {
-        throw new Error(`Failed to apply label ${label}: ${apply.status} ${await apply.text()}`);
-    }
-}
-function authHeaders(extra = {}) {
-    return authToken ? { ...extra, Authorization: `Bearer ${authToken}` } : extra;
-}
-function classifyIssue(issue) {
-    const text = `${issue.title}\n${issue.body}`.toLowerCase();
-    if (text.includes("500") || text.includes("error") || text.includes("null") || text.includes("failing")) {
-        return {
-            label: "bug",
-            assignee: text.includes("auth") ? "bob" : "alice"
-        };
-    }
-    if (text.includes("add") || text.includes("export") || text.includes("feature")) {
-        return { label: "feature", assignee: null };
-    }
-    return { label: "question", assignee: null };
-}
-async function github(path, options = {}) {
-    const response = await fetch(`${baseUrl}${path}`, {
-        method: options.method ?? "GET",
-        headers: authHeaders(options.body ? { "content-type": "application/json" } : {}),
-        body: options.body ? JSON.stringify(options.body) : undefined
-    });
-    if (!response.ok) {
-        throw new Error(`${options.method ?? "GET"} ${path} failed: ${response.status} ${await response.text()}`);
-    }
-    return (await response.json());
-}
-function requiredEnv(name) {
-    const value = process.env[name]?.trim();
-    if (!value)
-        throw new Error(`${name} is required`);
-    return value;
-}
-export {};

package/dist/src/capture-server/egress.d.ts

@@ -1,19 +0,0 @@
-export declare const DEFAULT_LLM_PROVIDER_HOSTS: readonly string[];
-export interface BlockedEgress {
-    host: string;
-    port: number;
-    count: number;
-}
-export interface EgressRefusedRow {
-    ts: string;
-    kind: "EgressRefusedEvent";
-    host: string;
-    port: number;
-}
-export declare function isHostAllowed(host: string, patterns: readonly string[]): boolean;
-export declare function parseAllowCsv(csv: string | undefined): string[];
-export declare function buildEgressAllowlist(env: Record<string, string | undefined>, opts?: {
-    twinUrls?: readonly string[];
-    extraHosts?: readonly string[];
-}): string[];
-export declare function readBlockedEgress(path: string): Promise<BlockedEgress[]>;

package/dist/src/capture-server/egress.js

@@ -1,152 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// FDRS-635 — deny-by-default egress floor for the capture-server.
-//
-// "Prod-safety is a network control, not a rule" (north-star board block 06):
-// under `pome run` the CONNECT proxy refuses tunnels to any host outside the
-// allowlist — twin hosts + LLM provider hosts + loopback — so an agent that
-// strays to e.g. api.github.com gets connection-refused, not a silent
-// passthrough to production.
-//
-// The default provider set mirrors `DEFAULT_AGENT_ENV_ALLOWLIST` in
-// agentRunner.ts: a provider whose API key the runner forwards by default is
-// a provider the floor lets the agent dial by default. Everything else goes
-// through the paired valves — POME_AGENT_ENV_ALLOWLIST for the key,
-// POME_EGRESS_ALLOW for the host.
-//
-// Known boundary (by design, see FDRS-635): the floor only binds processes
-// that honor proxy env vars. Agents that bypass HTTPS_PROXY are caught by
-// `pome doctor`'s routing probe — the two layers are complementary.
-import { readFile } from "node:fs/promises";
-// Providers whose keys the runner forwards by default (agentRunner.ts).
-// `*.anthropic.com` (not just api.) keeps the Claude Agent SDK's own
-// telemetry (statsig.anthropic.com) from showing up as refused-egress noise
-// on every default-stack run. Deliberately NOT `*.googleapis.com` — that
-// would open storage.googleapis.com and friends.
-export const DEFAULT_LLM_PROVIDER_HOSTS = [
-    "*.anthropic.com", // ANTHROPIC_API_KEY
-    "anthropic.com",
-    "api.openai.com", // OPENAI_API_KEY
-    "generativelanguage.googleapis.com", // GOOGLE_API_KEY / GOOGLE_GENERATIVE_AI_API_KEY
-    "openrouter.ai", // OPENROUTER_API_KEY
-    "ai-gateway.vercel.sh", // AI_GATEWAY_API_KEY
-];
-// Custom LLM endpoints: when the runner's environment points a provider SDK
-// at a non-default base URL, that host joins the allowlist.
-const BASE_URL_ENV_VARS = ["ANTHROPIC_BASE_URL", "OPENAI_BASE_URL", "OPENAI_API_BASE"];
-function normalizeHost(host) {
-    let value = host.trim().toLowerCase();
-    if (value.endsWith("."))
-        value = value.slice(0, -1);
-    if (value.startsWith("[") && value.endsWith("]"))
-        value = value.slice(1, -1);
-    return value;
-}
-function isLoopback(host) {
-    if (host === "localhost" || host.endsWith(".localhost"))
-        return true;
-    if (host === "::1" || host === "0:0:0:0:0:0:0:1")
-        return true;
-    // 127.0.0.0/8 — the whole loopback block, not just 127.0.0.1.
-    return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host);
-}
-// `patterns` entries: exact hostname, `*.suffix` (any-depth subdomain, not
-// the apex), or bare `*` (allow everything — floor off). Ports never take
-// part in matching: the floor is a host-level control.
-export function isHostAllowed(host, patterns) {
-    const candidate = normalizeHost(host);
-    if (candidate.length === 0)
-        return false;
-    if (isLoopback(candidate))
-        return true;
-    for (const raw of patterns) {
-        const pattern = normalizeHost(raw);
-        if (pattern.length === 0)
-            continue;
-        if (pattern === "*")
-            return true;
-        if (pattern.startsWith("*.")) {
-            if (candidate.endsWith(pattern.slice(1)))
-                return true;
-            continue;
-        }
-        if (candidate === pattern)
-            return true;
-    }
-    return false;
-}
-export function parseAllowCsv(csv) {
-    return (csv ?? "")
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
-}
-// Compute the allowlist for one run: default LLM providers + custom LLM
-// base-URL hosts + the POME_EGRESS_ALLOW valve + the twin URLs the runner is
-// about to inject (loopback in self-host; hosted twin domains future-proof).
-//
-// FDRS-643 — `extraHosts` is the demo-mode valve: `pome demo` adds the
-// POME_API_BASE host so the bundled agent's anonymous-gateway calls
-// (POST /v1/demo/sessions/:id/llm) survive the deny-by-default floor. Same
-// pattern rules as everything else (exact host or `*.suffix`).
-export function buildEgressAllowlist(env, opts = {}) {
-    const patterns = [...DEFAULT_LLM_PROVIDER_HOSTS, ...(opts.extraHosts ?? [])];
-    for (const key of BASE_URL_ENV_VARS) {
-        const value = env[key]?.trim();
-        if (!value)
-            continue;
-        try {
-            patterns.push(new URL(value).hostname);
-        }
-        catch {
-            // Malformed base URL — the provider SDK will fail on it anyway; the
-            // floor doesn't need to.
-        }
-    }
-    patterns.push(...parseAllowCsv(env.POME_EGRESS_ALLOW));
-    for (const url of opts.twinUrls ?? []) {
-        try {
-            patterns.push(new URL(url).hostname);
-        }
-        catch {
-            // ignore malformed twin URLs
-        }
-    }
-    return [...new Set(patterns.map(normalizeHost).filter((p) => p.length > 0))];
-}
-// Read the egress sidecar and aggregate refusals per host:port, most-hit
-// first. Tolerates a missing file (no refusals — the common case) and junk
-// lines (partial writes on a crashed run).
-export async function readBlockedEgress(path) {
-    let raw;
-    try {
-        raw = await readFile(path, "utf8");
-    }
-    catch {
-        return [];
-    }
-    const counts = new Map();
-    for (const line of raw.split("\n")) {
-        if (line.trim().length === 0)
-            continue;
-        let row;
-        try {
-            row = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (typeof row !== "object" || row === null)
-            continue;
-        const { kind, host, port } = row;
-        if (kind !== "EgressRefusedEvent" || typeof host !== "string" || typeof port !== "number") {
-            continue;
-        }
-        const key = `${host}:${port}`;
-        const existing = counts.get(key);
-        if (existing)
-            existing.count += 1;
-        else
-            counts.set(key, { host, port, count: 1 });
-    }
-    return [...counts.values()].sort((a, b) => b.count - a.count);
-}

package/dist/src/capture-server/index.d.ts

@@ -1,12 +0,0 @@
-export interface CaptureServerOptions {
-    port: number;
-    eventsOut: string;
-    allowHosts?: readonly string[];
-    egressOut?: string;
-}
-export interface CaptureServerHandle {
-    port: number;
-    flush: () => Promise<void>;
-    close: () => Promise<void>;
-}
-export declare function runCaptureServer(options: CaptureServerOptions): Promise<CaptureServerHandle>;

package/dist/src/capture-server/index.js

@@ -1,198 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// FDRS-406 — HTTP CONNECT-tunnel proxy that emits one `LlmCallEvent` row per
-// tunnel into `events.jsonl`. Spawned by `pome run` (FDRS-399) as a child
-// process; agent traffic flows through it via `HTTPS_PROXY`.
-//
-// Mode: CONNECT-only (no TLS termination). The proxy never sees plaintext
-// request/response bodies — the inner bytes are TLS-encrypted and forwarded
-// opaquely. That is the v1 deliberate trade-off (PR/FAQ §Why; M0 milestone):
-// zero-config trace baseline (host / port / latency / bytes) for ANY agent
-// with no CA install, no SDK patch. Per-call token / model / cost arrive in
-// v2's opt-in TLS-terminate mode.
-import { randomUUID } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { createServer as createHttpServer } from "node:http";
-import { connect as netConnect } from "node:net";
-import { dirname } from "node:path";
-import { redactEvent } from "../recorder/redaction.js";
-import { isHostAllowed } from "./egress.js";
-export async function runCaptureServer(options) {
-    await mkdir(dirname(options.eventsOut), { recursive: true });
-    const writer = createWriteStream(options.eventsOut, { flags: "a" });
-    const allowHosts = options.allowHosts ?? [];
-    let egressWriter = null;
-    if (options.egressOut) {
-        await mkdir(dirname(options.egressOut), { recursive: true });
-        egressWriter = createWriteStream(options.egressOut, { flags: "a" });
-    }
-    const pendingWrites = new Set();
-    const liveSockets = new Set();
-    let shuttingDown = false;
-    const server = createHttpServer((_req, res) => {
-        // Anything other than CONNECT is a misconfiguration on the client side.
-        // 405 is unambiguous; 426 (Upgrade Required) would be misleading since we
-        // don't speak HTTP/2.
-        res.writeHead(405, { "content-type": "text/plain", connection: "close" });
-        res.end("pome capture-server accepts CONNECT only\n");
-    });
-    server.on("connect", (req, clientSocket, head) => {
-        handleConnect({ req, clientSocket, head, writer, egressWriter, allowHosts, liveSockets, pendingWrites });
-    });
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(options.port, "127.0.0.1", () => resolve());
-    });
-    const addr = server.address();
-    const port = typeof addr === "object" && addr !== null ? addr.port : options.port;
-    const flush = async () => {
-        while (pendingWrites.size > 0) {
-            await Promise.all([...pendingWrites]);
-        }
-    };
-    const close = async () => {
-        if (shuttingDown) {
-            await flush();
-            return;
-        }
-        shuttingDown = true;
-        // Stop accepting new connections first so we don't grow the in-flight set
-        // while draining.
-        const serverClosed = new Promise((resolve) => server.close(() => resolve()));
-        // Destroy in-flight sockets so their `close` handlers fire and finalize
-        // writes the trailing LlmCallEvent rows. Without this, `server.close()`
-        // would wait forever on long-lived tunnels.
-        for (const sock of liveSockets)
-            sock.destroy();
-        await serverClosed;
-        await flush();
-        await new Promise((resolve) => writer.end(() => resolve()));
-        if (egressWriter) {
-            const ew = egressWriter;
-            await new Promise((resolve) => ew.end(() => resolve()));
-        }
-    };
-    return { port, flush, close };
-}
-function handleConnect({ req, clientSocket, head, writer, egressWriter, allowHosts, liveSockets, pendingWrites, }) {
-    const target = parseConnectTarget(req.url ?? "");
-    if (!target) {
-        clientSocket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
-        return;
-    }
-    const { host, port } = target;
-    // FDRS-635 — the egress floor: refuse the tunnel BEFORE dialing upstream.
-    // The refusal is recorded in the egress sidecar so `pome run` can name the
-    // blocked host in its output.
-    if (!isHostAllowed(host, allowHosts)) {
-        if (egressWriter) {
-            const row = {
-                ts: new Date().toISOString(),
-                kind: "EgressRefusedEvent",
-                host,
-                port,
-            };
-            const ew = egressWriter;
-            const write = new Promise((resolve) => {
-                ew.write(JSON.stringify(row) + "\n", () => resolve());
-            });
-            pendingWrites.add(write);
-            void write.finally(() => pendingWrites.delete(write));
-        }
-        clientSocket.end("HTTP/1.1 403 Forbidden\r\ncontent-type: text/plain\r\nconnection: close\r\n\r\n" +
-            `pome egress floor: CONNECT to ${host}:${port} refused — not on the allowlist (twin hosts + LLM providers + localhost). Extend with POME_EGRESS_ALLOW=<host,...> if this host is intentional.\r\n`);
-        return;
-    }
-    // Pause until upstream is ready. Without pausing, the client might send
-    // payload bytes between now and the upstream connect, and they'd be dropped
-    // because no `data` listener exists yet.
-    clientSocket.pause();
-    const start = Date.now();
-    let bytesOut = head.length; // bytes from client → upstream (TLS ClientHello often arrives in `head`)
-    let bytesIn = 0; // bytes from upstream → client
-    let finalized = false;
-    const upstream = netConnect({ host, port });
-    liveSockets.add(clientSocket);
-    liveSockets.add(upstream);
-    const finalize = () => {
-        if (finalized)
-            return;
-        finalized = true;
-        liveSockets.delete(clientSocket);
-        liveSockets.delete(upstream);
-        if (!clientSocket.destroyed)
-            clientSocket.destroy();
-        if (!upstream.destroyed)
-            upstream.destroy();
-        const row = {
-            ts: new Date().toISOString(),
-            event_id: randomUUID(),
-            parent_event_id: null,
-            kind: "LlmCallEvent",
-            host,
-            port,
-            latency_ms: Date.now() - start,
-            bytes_in: bytesIn,
-            bytes_out: bytesOut,
-            url: null,
-            method: null,
-            status: null,
-            model: null,
-            prompt_tokens: null,
-            completion_tokens: null,
-            cost_usd: null,
-        };
-        const redacted = redactEvent(row);
-        const write = new Promise((resolve) => {
-            writer.write(JSON.stringify(redacted) + "\n", () => resolve());
-        });
-        pendingWrites.add(write);
-        void write.finally(() => pendingWrites.delete(write));
-    };
-    upstream.once("connect", () => {
-        clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
-        if (head.length > 0)
-            upstream.write(head);
-        clientSocket.on("data", (chunk) => {
-            bytesOut += chunk.length;
-        });
-        upstream.on("data", (chunk) => {
-            bytesIn += chunk.length;
-        });
-        clientSocket.pipe(upstream);
-        upstream.pipe(clientSocket);
-        clientSocket.resume();
-    });
-    upstream.once("error", () => {
-        if (!clientSocket.destroyed) {
-            try {
-                clientSocket.end("HTTP/1.1 502 Bad Gateway\r\n\r\n");
-            }
-            catch {
-                // socket already torn down — nothing useful to do
-            }
-        }
-        finalize();
-    });
-    clientSocket.once("error", finalize);
-    clientSocket.once("close", finalize);
-    upstream.once("close", finalize);
-}
-function parseConnectTarget(spec) {
-    // RFC 7230 §5.3: CONNECT request-target is authority-form `host:port`.
-    // IPv6 hosts arrive bracketed (`[::1]:443`).
-    if (spec.length === 0)
-        return null;
-    const lastColon = spec.lastIndexOf(":");
-    if (lastColon === -1)
-        return null;
-    let host = spec.slice(0, lastColon);
-    const port = Number(spec.slice(lastColon + 1));
-    if (!Number.isInteger(port) || port < 1 || port > 65535)
-        return null;
-    if (host.startsWith("[") && host.endsWith("]"))
-        host = host.slice(1, -1);
-    if (host.length === 0)
-        return null;
-    return { host, port };
-}

package/dist/src/capture-server/run.d.ts

@@ -1,7 +0,0 @@
-export interface RunCaptureServerCommandOptions {
-    port: number;
-    eventsOut: string;
-    allowHosts?: readonly string[];
-    egressOut?: string;
-}
-export declare function runCaptureServerCommand(options: RunCaptureServerCommandOptions): Promise<void>;

package/dist/src/capture-server/run.js

@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// CLI entry for `pome capture-server`. Boots the proxy, wires SIGTERM/SIGINT
-// to a graceful shutdown that drains in-flight tunnels and flushes the events
-// file before exiting 0.
-import { resolve } from "node:path";
-import { runCaptureServer } from "./index.js";
-export async function runCaptureServerCommand(options) {
-    const eventsOut = resolve(options.eventsOut);
-    const egressOut = options.egressOut ? resolve(options.egressOut) : undefined;
-    const allowHosts = options.allowHosts ?? [];
-    const handle = await runCaptureServer({ port: options.port, eventsOut, allowHosts, egressOut });
-    console.error(`pome capture-server listening on 127.0.0.1:${handle.port} (events → ${eventsOut})`);
-    console.error(`pome capture-server egress floor: deny-by-default (${allowHosts.length} allowlisted pattern(s) + loopback)`);
-    let shuttingDown = false;
-    const shutdown = async (signal) => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        console.error(`pome capture-server: received ${signal}, draining…`);
-        await handle.close();
-        console.error("pome capture-server: stopped");
-        process.exit(0);
-    };
-    process.on("SIGTERM", () => void shutdown("SIGTERM"));
-    process.on("SIGINT", () => void shutdown("SIGINT"));
-}

package/dist/src/cli/agent-identity.d.ts

@@ -1,20 +0,0 @@
-export interface RunAgentIdentity {
-    /** The resolved agent id to send at session create; absent = unattributed. */
-    agentId?: string;
-    /** `--agent-version` override, else the manifest's `agent.version`. */
-    agentVersion?: string;
-    /** The manifest's `agent.framework` — the run's "SDK badge" on the dashboard. */
-    framework?: string;
-    /** The manifest's `agent.slug`, when a manifest is present. */
-    agentSlug?: string;
-}
-export interface ResolveRunAgentIdentityInput {
-    /** Directory to discover the manifest + link cache from (walks up). */
-    startDir: string;
-    apiBaseUrl: string;
-    /** `--agent-version` flag value; wins over the manifest's version. */
-    agentVersionOverride?: string;
-    /** Test seam — forwarded to resolveCredentials. */
-    credentialsPath?: string;
-}
-export declare function resolveRunAgentIdentity(input: ResolveRunAgentIdentityInput): Promise<RunAgentIdentity>;

package/dist/src/cli/agent-identity.js

@@ -1,64 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// Run-path agent identity (F-819). Resolves the `agt_` id + version to stamp on
-// a hosted session from the committed manifest + gitignored `.pome/link.json`.
-//
-// The cached id is trusted only when its `team_id` matches the caller's team: a
-// re-clone under the same team short-circuits with no network (Champion TTHW);
-// a fork or team switch silently re-resolves the slug via `POST /v1/agents` so
-// a run never sends a foreign `agt_` id and self-onboards with zero extra
-// commands. A resolver hiccup degrades to "unattributed" rather than blocking a
-// local twin run.
-import { dirname } from "node:path";
-import { postAgentResolver, resolveSeams, } from "./agent-resolver.js";
-import { resolveCredentials } from "./credentials.js";
-import { ensurePomeGitignored, readLinkCache, resolveCachedAgentId, writeLinkCache, } from "./link-cache.js";
-import { normalizeManifestTwins, readManifest } from "./project-config.js";
-export async function resolveRunAgentIdentity(input) {
-    const manifestRead = await readManifest(input.startDir);
-    if (!manifestRead) {
-        return input.agentVersionOverride
-            ? { agentVersion: input.agentVersionOverride }
-            : {};
-    }
-    const { agent } = manifestRead.manifest;
-    const agentVersion = input.agentVersionOverride ?? agent.version;
-    const base = {
-        agentVersion,
-        framework: agent.framework,
-        agentSlug: agent.slug,
-    };
-    const projectDir = dirname(manifestRead.path);
-    try {
-        const creds = await resolveCredentials({
-            apiBaseUrl: input.apiBaseUrl,
-            credentialsPath: input.credentialsPath,
-        });
-        const cachedId = resolveCachedAgentId(await readLinkCache(projectDir), creds.teamId);
-        if (cachedId) {
-            return { ...base, agentId: cachedId };
-        }
-        // Silent re-resolution — a run never prompts for a near-miss. Send the
-        // manifest's twins so a fork / first `pome run` that auto-creates the agent
-        // enables the declared services instead of the server's `github` default
-        // (F-926); the server merges additively, so this is safe when the agent
-        // already exists.
-        const resolved = await postAgentResolver(creds, {
-            name: agent.name ?? agent.slug,
-            slug: agent.slug,
-            description: agent.description,
-            version: agent.version,
-            framework: agent.framework,
-            twins: normalizeManifestTwins(manifestRead.manifest.twins),
-        }, resolveSeams({ stdinIsTTY: false }));
-        if (creds.teamId) {
-            await writeLinkCache(projectDir, { agent_id: resolved.id, team_id: creds.teamId });
-            await ensurePomeGitignored(projectDir);
-        }
-        return { ...base, agentId: resolved.id };
-    }
-    catch (err) {
-        console.error(`pome: could not resolve agent identity (${err instanceof Error ? err.message : String(err)}); running unattributed.`);
-        return base;
-    }
-}

package/dist/src/cli/agent-resolver.d.ts

@@ -1,29 +0,0 @@
-import { type AgentResponse } from "@pome-sh/shared-types";
-import type { ResolvedCredentials } from "./credentials.js";
-/** Test seams — default to a live TTY [y/N] prompt (mirrors install.ts). */
-export interface InteractiveSeams {
-    stdinIsTTY?: boolean;
-    confirm?: (question: string) => Promise<boolean>;
-    /** Free-text prompt. Added by F-1074: picking a check from a numbered list and
-     *  filling its typed parameters needs an answer, not a yes/no. */
-    ask?: (question: string) => Promise<string>;
-}
-/** The manifest identity fields POSTed to the resolver. */
-export interface AgentPostBody {
-    name: string;
-    slug?: string;
-    description?: string;
-    version?: string;
-    framework?: string;
-    twins?: string[];
-    confirm?: boolean;
-}
-export declare function resolveSeams(opts: InteractiveSeams): Required<InteractiveSeams>;
-/** Extract the near-miss suggested slug from a 409 conflict envelope. F-820
- *  returns it under `error.details.suggestion`; we also tolerate `suggestions[]`
- *  and `slug` as forward-compatible fallbacks. */
-export declare function nearMissSuggestion(json: unknown): string | undefined;
-/** POST the manifest identity, resolving a 409 near-miss per the confirmation
- *  UX: interactive → "did you mean X?" (yes re-resolves X, no force-creates the
- *  typed slug); non-TTY/CI → warn + force-create (`confirm: true`). */
-export declare function postAgentResolver(creds: ResolvedCredentials, body: AgentPostBody, seams: Required<InteractiveSeams>): Promise<AgentResponse>;