@webpresso/agent-kit 3.1.30 → 3.3.0

package/dist/esm/mcp/tools/run-wait.js

@@ -0,0 +1,593 @@
+import { z } from "zod";
+import { createSummaryOutputSchema, createSummaryResult } from "#mcp/tools/_shared/result.js";
+import { redactText } from "#mcp/tools/_shared/redact.js";
+import { isMissingBinary, isRunFailure, runCommand } from "#mcp/tools/_shared/run-command.js";
+import { readonlyOpsBaseSchema, resolveReadonlyCwd, runReadonlyCommand, } from "#mcp/tools/_readonly-ops.js";
+export const RUN_WAIT_UNTIL_VALUES = ["run_terminal", "all_jobs_terminal"];
+const SELECTOR_REQUIRED_MESSAGE = "wp run wait requires a selector: pass --sha <head-sha> or --run-id <id> (no implicit latest-run guessing)";
+const SELECTOR_CONFLICT_MESSAGE = "wp run wait accepts exactly one selector: pass either --sha or --run-id, not both";
+const runIdSchema = z.union([
+    z.number().int().positive(),
+    z
+        .string()
+        .regex(/^[1-9][0-9]*$/u, "runId must be a positive integer (no signs, decimals, or suffixes)"),
+]);
+const inputSchema = readonlyOpsBaseSchema
+    .extend({
+    // Workflow-run JSON (jobs + steps) is much larger than PR metadata, so the
+    // effective default budget is the shared schema's ceiling rather than 4 KB.
+    maxOutputBytes: z.number().int().positive().max(64_000).optional().default(64_000),
+    sha: z.string().min(1).optional(),
+    runId: runIdSchema.optional(),
+    workflow: z.string().min(1).optional(),
+    until: z.enum(RUN_WAIT_UNTIL_VALUES).optional().default("run_terminal"),
+    pollIntervalMs: z.number().int().positive().max(300_000).optional().default(15_000),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const hasSha = value.sha !== undefined;
+    const hasRunId = value.runId !== undefined;
+    if (!hasSha && !hasRunId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: SELECTOR_REQUIRED_MESSAGE,
+            path: ["sha"],
+        });
+    }
+    if (hasSha && hasRunId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: SELECTOR_CONFLICT_MESSAGE,
+            path: ["runId"],
+        });
+    }
+});
+const runWaitJobSchema = z.object({
+    name: z.string(),
+    status: z.string(),
+    conclusion: z.string().nullable(),
+    failedStep: z.string().optional(),
+    errorTail: z.string().optional(),
+    upstreamCulprits: z.array(z.string()).optional(),
+    classification: z.literal("blocked_upstream").optional(),
+    transient: z.string().optional(),
+});
+const outputSchema = createSummaryOutputSchema({
+    counts: z.record(z.string(), z.number()),
+    details: z.object({
+        cwd: z.string(),
+        sha: z.string().optional(),
+        runId: z.number().optional(),
+        workflow: z.string().optional(),
+        until: z.enum(RUN_WAIT_UNTIL_VALUES),
+        timeoutMs: z.number(),
+        pollIntervalMs: z.number(),
+        pollCount: z.number(),
+        elapsedMs: z.number(),
+        commands: z.array(z.record(z.string(), z.unknown())),
+    }),
+}).extend({
+    status: z.enum(["success", "failed", "timed_out", "no_run"]),
+    verdict: z.enum(["passed", "failed", "pending"]),
+    terminalReason: z.enum([
+        "run_terminal",
+        "all_jobs_terminal",
+        "run_failed",
+        "timeout",
+        "no_run",
+        "command_failed",
+    ]),
+    conclusion: z.string().nullable(),
+    runId: z.number().nullable(),
+    runUrl: z.string().optional(),
+    workflowName: z.string().optional(),
+    headSha: z.string().optional(),
+    until: z.enum(RUN_WAIT_UNTIL_VALUES),
+    jobs: z.array(runWaitJobSchema),
+});
+const RUN_VIEW_FIELDS = "databaseId,status,conclusion,workflowName,headSha,url,name,event,jobs";
+const RUN_LIST_FIELDS = "databaseId,headSha,workflowName,status,conclusion,createdAt,url,name,event";
+const PROBE_TIMEOUT_MS = 30_000;
+const MAX_ERROR_TAIL_LINES = 50;
+const MAX_ERROR_TAIL_BYTES = 2_000;
+const MAX_FAILURE_SNIPPET_CHARS = 200;
+/**
+ * Terminal job conclusions that warrant failure diagnostics (failed step,
+ * error tail, transient classification, upstream-culprit attribution).
+ * `skipped` and `neutral` are terminal but not unsuccessful.
+ */
+const UNSUCCESSFUL_JOB_CONCLUSIONS = new Set([
+    "failure",
+    "timed_out",
+    "cancelled",
+    "action_required",
+]);
+// Transient classifier v1 — regex on (failed-step name + errorTail).
+const TRANSIENT_CLASSIFIERS = [
+    {
+        id: "pulumi-stack-lock",
+        pattern: /\[409\] Conflict: Another update is currently in progress/u,
+    },
+    { id: "node-gyp-cache-perms", pattern: /gyp .*Permission denied/u },
+    {
+        id: "playwright-browser-missing",
+        pattern: /Executable doesn't exist.*playwright|playwright.*Executable doesn't exist/iu,
+    },
+];
+export function classifyTransient(text) {
+    for (const classifier of TRANSIENT_CLASSIFIERS) {
+        if (classifier.pattern.test(text))
+            return classifier.id;
+    }
+    return undefined;
+}
+/** Distinguish provider-level failures so they never collapse into a generic command_failed. */
+function classifyGhFailure(id, output) {
+    if (!output)
+        return undefined;
+    if (/rate limit|HTTP 429|secondary rate/iu.test(output)) {
+        return `github-rate-limited: ${id} hit a GitHub API rate limit`;
+    }
+    if (/HTTP 401|Bad credentials|authentication|gh auth login/iu.test(output)) {
+        return `github-auth-failed: ${id} could not authenticate with GitHub`;
+    }
+    return undefined;
+}
+function skippedResult(id, args) {
+    return {
+        id,
+        command: { command: "gh", args },
+        passed: false,
+        skipped: true,
+        warnings: [`${id} skipped: timeout budget exhausted`],
+    };
+}
+/**
+ * Deadline-aware gh probe through the shared bounded read-only path
+ * (`runReadonlyCommand`): output is budget-clipped and redacted, spawn
+ * diagnostics (stderr, timedOut, aborted) are preserved, and no probe starts
+ * once the overall deadline is spent. Per-probe timeout is the remaining
+ * budget capped at PROBE_TIMEOUT_MS — never a fixed floor past the deadline.
+ */
+async function runGhBounded(id, args, options) {
+    const remainingMs = options.deadline - Date.now();
+    if (remainingMs <= 0)
+        return skippedResult(id, args);
+    const result = await runReadonlyCommand(id, "gh", args, {
+        cwd: options.cwd,
+        timeoutMs: Math.min(remainingMs, PROBE_TIMEOUT_MS),
+        maxOutputBytes: options.maxOutputBytes,
+        signal: options.signal,
+        parseJson: options.parseJson,
+    });
+    if (result.passed || result.missingBinary)
+        return result;
+    const warnings = [...(result.warnings ?? [])];
+    const classified = classifyGhFailure(id, result.rawOutput);
+    if (classified)
+        warnings.push(classified);
+    if (result.timedOut)
+        warnings.push(`${id} timed out before completing`);
+    if (result.aborted)
+        warnings.push(`${id} aborted by cancellation`);
+    if (warnings.length === 0) {
+        const snippet = (result.rawOutput ?? "").slice(0, MAX_FAILURE_SNIPPET_CHARS).trim();
+        warnings.push(`${id} failed (exit ${result.exitCode ?? "unknown"})${snippet ? `: ${snippet}` : ""}`);
+    }
+    return { ...result, warnings };
+}
+function toSlimCommand(result) {
+    return {
+        id: result.id,
+        command: result.command.command,
+        args: result.command.args,
+        passed: result.passed,
+        ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
+        ...(result.timedOut ? { timedOut: true } : {}),
+        ...(result.aborted ? { aborted: true } : {}),
+        ...(result.missingBinary ? { missingBinary: true } : {}),
+        ...(result.skipped ? { skipped: true } : {}),
+    };
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** UTF-8-byte-bounded suffix; strips a split leading multibyte character. */
+function tailBytes(text, maxBytes) {
+    const buffer = Buffer.from(text, "utf8");
+    if (buffer.byteLength <= maxBytes)
+        return text;
+    return buffer
+        .subarray(buffer.byteLength - maxBytes)
+        .toString("utf8")
+        .replace(/^�+/u, "");
+}
+function boundedLogTail(text) {
+    const lines = text.split(/\r?\n/u).filter((line) => line.length > 0);
+    const tail = lines.slice(-MAX_ERROR_TAIL_LINES).join("\n");
+    const redacted = redactText(tail) ?? "";
+    return tailBytes(redacted, MAX_ERROR_TAIL_BYTES);
+}
+/**
+ * Exact-match selection on top of the server-side `gh run list --commit
+ * <sha>` filter: entries missing headSha are NOT matches and there is no
+ * fallback pool. Because list output flows through the shared redactor
+ * (which masks 40+-char tokens, including full commit SHAs), equality also
+ * accepts the deterministic mask of the requested SHA — never any other
+ * value. Workflow filtering is delegated to `gh run list --workflow`, which
+ * accepts both file names and display names — a local name-equality
+ * re-filter would wrongly exclude file-name selectors.
+ */
+function selectNewestRunId(entries, sha) {
+    const accepted = new Set([sha, redactText(sha) ?? sha]);
+    const matching = entries.filter((entry) => {
+        const headSha = asString(entry.headSha);
+        return headSha !== undefined && accepted.has(headSha);
+    });
+    const newest = [...matching].sort((a, b) => (asString(b.createdAt) ?? "").localeCompare(asString(a.createdAt) ?? ""));
+    for (const entry of newest) {
+        const runId = asNumber(entry.databaseId);
+        if (runId !== undefined)
+            return runId;
+    }
+    return undefined;
+}
+function firstUnsuccessfulStep(job) {
+    if (!Array.isArray(job.steps))
+        return undefined;
+    for (const step of job.steps) {
+        const conclusion = asString(step.conclusion);
+        if (conclusion !== undefined && UNSUCCESSFUL_JOB_CONCLUSIONS.has(conclusion)) {
+            const name = asString(step.name);
+            return name === undefined ? undefined : redactText(name);
+        }
+    }
+    return undefined;
+}
+function runIsTerminal(run) {
+    return asString(run.status) === "completed";
+}
+function jobsAllTerminal(jobs) {
+    return jobs.every((job) => asString(job.status) === "completed");
+}
+function isDone(until, run, jobs) {
+    if (!runIsTerminal(run))
+        return false;
+    if (until === "all_jobs_terminal")
+        return jobsAllTerminal(jobs);
+    return true;
+}
+async function fetchErrorTail(job, _run, context) {
+    const jobId = asNumber(job.databaseId);
+    if (jobId === undefined)
+        return undefined;
+    // gh substitutes {owner}/{repo} from the checkout's repository (and host),
+    // so no URL parsing is needed — job/run URLs pass through the shared
+    // redactor and are not reliable to parse.
+    const args = ["api", `repos/{owner}/{repo}/actions/jobs/${jobId}/logs`];
+    const remainingMs = context.deadline - Date.now();
+    if (remainingMs <= 0) {
+        context.commands.push(skippedResult("run_wait_job_logs", args));
+        context.warnings.push(`error-tail enrichment skipped for job ${String(asString(job.name) ?? jobId)}: timeout budget exhausted`);
+        return undefined;
+    }
+    // Deviates from runReadonlyCommand on purpose: its budget clip keeps the
+    // HEAD of the output, but failure diagnostics live at the TAIL of a job
+    // log. Spawn diagnostics are still preserved in the command record and the
+    // returned tail is line- and UTF-8-byte-bounded plus redacted; raw log
+    // bytes never enter the result payload.
+    const outcome = await runCommand("gh", args, {
+        cwd: context.cwd,
+        timeoutMs: Math.min(remainingMs, PROBE_TIMEOUT_MS),
+        signal: context.signal,
+    });
+    if (isRunFailure(outcome)) {
+        context.commands.push({
+            id: "run_wait_job_logs",
+            command: { command: "gh", args },
+            passed: false,
+            missingBinary: isMissingBinary(outcome),
+            warnings: [
+                isMissingBinary(outcome)
+                    ? "missing binary: gh"
+                    : `failed to spawn gh: ${outcome.error.message}`,
+            ],
+        });
+        return undefined;
+    }
+    const failureWarning = outcome.exitCode === 0
+        ? undefined
+        : (classifyGhFailure("run_wait_job_logs", outcome.stderr) ??
+            `run_wait_job_logs failed (exit ${outcome.exitCode})`);
+    context.commands.push({
+        id: "run_wait_job_logs",
+        command: { command: "gh", args },
+        passed: outcome.exitCode === 0,
+        exitCode: outcome.exitCode,
+        timedOut: outcome.timedOut || undefined,
+        aborted: outcome.aborted || undefined,
+        ...(failureWarning ? { warnings: [failureWarning] } : {}),
+    });
+    if (outcome.exitCode !== 0)
+        return undefined;
+    const tail = boundedLogTail(outcome.stdout);
+    return tail.length > 0 ? tail : undefined;
+}
+async function normalizeJobs(rawJobs, run, context, options) {
+    const unsuccessfulNames = rawJobs
+        .filter((job) => {
+        const conclusion = asString(job.conclusion);
+        return conclusion !== undefined && UNSUCCESSFUL_JOB_CONCLUSIONS.has(conclusion);
+    })
+        .map((job) => asString(job.name) ?? "")
+        .filter((name) => name.length > 0);
+    const jobs = [];
+    for (const raw of rawJobs) {
+        const name = asString(raw.name) ?? "";
+        const status = (asString(raw.status) ?? "");
+        const conclusion = (asString(raw.conclusion) ?? null);
+        const job = { name, status, conclusion };
+        if (conclusion !== null && UNSUCCESSFUL_JOB_CONCLUSIONS.has(conclusion)) {
+            const failedStep = firstUnsuccessfulStep(raw);
+            if (failedStep)
+                job.failedStep = failedStep;
+            const errorTail = options.fetchLogs ? await fetchErrorTail(raw, run, context) : undefined;
+            if (errorTail)
+                job.errorTail = errorTail;
+            const transient = classifyTransient(`${failedStep ?? ""}\n${errorTail ?? ""}`);
+            if (transient)
+                job.transient = transient;
+        }
+        if (conclusion === "skipped" && unsuccessfulNames.length > 0) {
+            job.classification = "blocked_upstream";
+            job.upstreamCulprits = unsuccessfulNames;
+        }
+        jobs.push(job);
+    }
+    return jobs;
+}
+function counts(pollCount, jobs) {
+    return {
+        pollCount,
+        jobCount: jobs.length,
+        failedJobCount: jobs.filter((job) => job.conclusion !== null && UNSUCCESSFUL_JOB_CONCLUSIONS.has(job.conclusion)).length,
+    };
+}
+function extractRawJobs(run, warnings) {
+    const rawValue = Array.isArray(run.jobs) ? run.jobs : [];
+    const jobs = rawValue.filter((entry) => typeof entry === "object" && entry !== null && typeof entry.name === "string");
+    if (jobs.length !== rawValue.length) {
+        warnings.push("some job entries were omitted by the output-budget sanitizer");
+    }
+    return jobs;
+}
+async function sleep(ms, signal) {
+    if (ms <= 0)
+        return;
+    await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        const timer = setTimeout(finish, ms);
+        const onAbort = () => finish();
+        if (signal) {
+            if (signal.aborted)
+                finish();
+            else
+                signal.addEventListener("abort", onAbort, { once: true });
+        }
+    });
+}
+export async function runRunWait(raw, extra) {
+    const input = inputSchema.parse(raw ?? {});
+    const cwd = resolveReadonlyCwd(input);
+    const startedAt = Date.now();
+    const deadline = startedAt + input.timeoutMs;
+    const signal = extra?.signal;
+    const commands = [];
+    const warnings = [];
+    let pollCount = 0;
+    const finish = (outcome, jobs, run) => {
+        const allWarnings = [...commands.flatMap((command) => command.warnings ?? []), ...warnings];
+        const workflowName = asString(run?.workflowName);
+        const runUrl = asString(run?.url);
+        const headSha = asString(run?.headSha);
+        return {
+            ...outcome,
+            ...(runUrl ? { runUrl } : {}),
+            ...(workflowName ? { workflowName } : {}),
+            ...(headSha ? { headSha } : {}),
+            until: input.until,
+            jobs,
+            counts: counts(pollCount, jobs),
+            details: {
+                cwd,
+                sha: input.sha,
+                runId: typeof input.runId === "number" ? input.runId : undefined,
+                workflow: input.workflow,
+                until: input.until,
+                timeoutMs: input.timeoutMs,
+                pollIntervalMs: input.pollIntervalMs,
+                pollCount,
+                elapsedMs: Date.now() - startedAt,
+                commands: commands.map(toSlimCommand),
+            },
+            ...(allWarnings.length > 0 ? { warnings: allWarnings } : {}),
+        };
+    };
+    const commandFailed = (summary) => finish({
+        status: "failed",
+        passed: false,
+        verdict: "failed",
+        summary,
+        terminalReason: "command_failed",
+        conclusion: null,
+        runId: null,
+    }, []);
+    // Resolve the selector to a run id ONCE, then watch only that run: a rerun
+    // appearing mid-watch must never silently replace the run being watched.
+    let boundRunId;
+    if (input.runId !== undefined) {
+        boundRunId = typeof input.runId === "number" ? input.runId : Number.parseInt(input.runId, 10);
+    }
+    else {
+        const sha = input.sha;
+        const listArgs = [
+            "run",
+            "list",
+            "--commit",
+            sha,
+            ...(input.workflow ? ["--workflow", input.workflow] : []),
+            "--limit",
+            "20",
+            "--json",
+            RUN_LIST_FIELDS,
+        ];
+        const list = await runGhBounded("run_wait_list", listArgs, {
+            cwd,
+            deadline,
+            maxOutputBytes: input.maxOutputBytes,
+            signal,
+        });
+        commands.push(list);
+        if (list.missingBinary)
+            return commandFailed("run wait failed: missing binary gh");
+        if (!list.passed)
+            return commandFailed("run wait failed while listing workflow runs");
+        if (list.truncated) {
+            warnings.push("run list output exceeded the output budget; raise maxOutputBytes or use --run-id");
+            return commandFailed("run wait failed: run list output exceeded the output budget");
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(list.rawOutput?.trim() || "[]");
+        }
+        catch {
+            return commandFailed("run wait failed: run list returned invalid JSON");
+        }
+        const resolved = Array.isArray(parsed)
+            ? selectNewestRunId(parsed, sha)
+            : undefined;
+        if (resolved === undefined) {
+            return finish({
+                status: "no_run",
+                passed: false,
+                verdict: "failed",
+                summary: `run wait found no workflow run with head sha ${sha}${input.workflow ? ` for workflow ${input.workflow}` : ""}`,
+                terminalReason: "no_run",
+                conclusion: null,
+                runId: null,
+            }, []);
+        }
+        boundRunId = resolved;
+    }
+    const viewArgs = ["run", "view", String(boundRunId), "--json", RUN_VIEW_FIELDS];
+    let lastRun;
+    let lastJobs = [];
+    while (!signal?.aborted && Date.now() < deadline) {
+        pollCount += 1;
+        const view = await runGhBounded("run_wait_view", viewArgs, {
+            cwd,
+            deadline,
+            maxOutputBytes: input.maxOutputBytes,
+            signal,
+            parseJson: true,
+        });
+        commands.push(view);
+        if (view.skipped)
+            break;
+        if (view.missingBinary)
+            return commandFailed("run wait failed: missing binary gh");
+        if (!view.passed)
+            return commandFailed("run wait failed while reading workflow run state");
+        const run = (view.details ?? {});
+        const jobs = extractRawJobs(run, warnings);
+        lastRun = run;
+        lastJobs = jobs;
+        if (isDone(input.until, run, jobs)) {
+            const context = {
+                cwd,
+                deadline,
+                maxOutputBytes: input.maxOutputBytes,
+                signal,
+                commands,
+                warnings,
+            };
+            const enriched = await normalizeJobs(jobs, run, context, { fetchLogs: true });
+            const conclusion = (asString(run.conclusion) ?? null);
+            const green = conclusion === "success";
+            const terminalReason = green
+                ? input.until === "all_jobs_terminal"
+                    ? "all_jobs_terminal"
+                    : "run_terminal"
+                : "run_failed";
+            const workflowName = asString(run.workflowName);
+            return finish({
+                status: green ? "success" : "failed",
+                passed: green,
+                verdict: green ? "passed" : "failed",
+                summary: green
+                    ? `run wait reached ${terminalReason} for run ${boundRunId}${workflowName ? ` (${workflowName})` : ""} with conclusion success`
+                    : `run wait: run ${boundRunId}${workflowName ? ` (${workflowName})` : ""} finished with conclusion ${conclusion ?? "unknown"}`,
+                terminalReason,
+                conclusion,
+                runId: boundRunId,
+            }, enriched, run);
+        }
+        const sleepMs = Math.min(input.pollIntervalMs, deadline - Date.now());
+        if (sleepMs <= 0)
+            break;
+        await sleep(sleepMs, signal);
+    }
+    // Timeout / cancellation: report the last-observed job states (normalized,
+    // no log downloads) instead of discarding known partial progress.
+    const timeoutContext = {
+        cwd,
+        deadline,
+        maxOutputBytes: input.maxOutputBytes,
+        signal,
+        commands,
+        warnings,
+    };
+    const partialJobs = lastRun
+        ? await normalizeJobs(lastJobs, lastRun, timeoutContext, { fetchLogs: false })
+        : [];
+    return finish({
+        status: "timed_out",
+        passed: false,
+        verdict: "pending",
+        summary: `run wait timed out after ${input.timeoutMs}ms waiting for ${input.until}`,
+        terminalReason: "timeout",
+        conclusion: (asString(lastRun?.conclusion) ?? null),
+        runId: boundRunId,
+    }, partialJobs, lastRun);
+}
+const tool = {
+    name: "wp_run_wait",
+    description: "Read-only GitHub workflow-run waiter via the gh CLI: blocks until a push/dispatch run (e.g. a production deploy on main) reaches run-terminal or all-jobs-terminal state, then reports conclusion, failed-step tails, transient classification, and blocked-upstream culprits. Selector is required and exclusive (--sha newest exact-match run, or --run-id direct); timeoutMs (<=300000) is an overall deadline covering probes and log enrichment. Does not mutate run state.",
+    inputSchema,
+    outputSchema,
+    annotations: {
+        title: "Workflow run wait",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (raw, extra) => {
+        const payload = await runRunWait(raw, extra);
+        return createSummaryResult(payload, {
+            isError: payload.status !== "success",
+        });
+    },
+};
+export default tool;

package/dist/esm/mcp/tools/session-fetch-and-index.d.ts

@@ -1,6 +1,6 @@
 import type { ToolDescriptor, ToolHandlerExtra, ToolHandlerResult } from "#mcp/auto-discover";
 export interface SessionFetchAndIndexDeps {
-    readonly fetchImpl?: typeof fetch;
+    readonly fetchImpl?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 }
 export declare function handleSessionFetchAndIndex(raw: unknown, extra?: ToolHandlerExtra, deps?: SessionFetchAndIndexDeps): Promise<ToolHandlerResult>;
 declare const tool: ToolDescriptor;

package/dist/esm/mcp/tools/session-id.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDescriptor } from "#mcp/auto-discover";
+declare const tool: ToolDescriptor;
+export default tool;

package/dist/esm/mcp/tools/session-id.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { readCurrentSessionId } from "#session-memory/current-session.js";
+import { createSummaryOutputSchema, createSummaryResult } from "./_shared/result.js";
+const inputSchema = z
+    .object({
+    cwd: z.string().optional(),
+})
+    .strict();
+const outputSchema = createSummaryOutputSchema({
+    details: z.object({
+        sessionId: z.string(),
+    }),
+}).extend({
+    sessionId: z.string(),
+});
+function effectiveCwd(cwd) {
+    return cwd ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+}
+const tool = {
+    name: "wp_session_id",
+    description: "Report only the current agent session id (empty if unknown), skipping the cross-worktree execution-model scan `wp_session_info` performs. Cheaper for hot paths — this is the lookup `wp_pr_upsert` uses internally to auto-resolve an omitted `description.sessionId`. Prefer `wp_session_info` when the observed execution model(s) are also needed.",
+    inputSchema,
+    outputSchema,
+    annotations: {
+        title: "Session id",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (raw) => {
+        const input = inputSchema.parse(raw ?? {});
+        const sessionId = readCurrentSessionId(effectiveCwd(input.cwd), process.env);
+        const payload = {
+            passed: true,
+            summary: sessionId
+                ? `session id ${sessionId}`
+                : "no live or captured session id found; use Session-skip in the PR disclosure",
+            sessionId,
+            details: { sessionId },
+        };
+        return createSummaryResult(payload);
+    },
+};
+export default tool;

package/dist/esm/mcp/tools/session-info.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDescriptor } from "#mcp/auto-discover";
+declare const tool: ToolDescriptor;
+export default tool;