@proagentstore/cli 0.4.97 → 0.4.99

package/dist/browser-runner/local-apply/contract.js

@@ -46,6 +46,18 @@ export const LOCAL_APPLY_HANDOFF_FRAME_PATH = "/local-apply/handoff/frame";
 export const LOCAL_APPLY_HANDOFF_INPUT_PATH = "/local-apply/handoff/input";
 export const LOCAL_APPLY_HANDOFF_RESUME_PATH = "/local-apply/handoff/resume";
 export const LOCAL_APPLY_HANDOFF_END_PATH = "/local-apply/handoff/end";
+/**
+ * A separate, browser-only receipt/history check for an already-ended uncertain attempt.  This is
+ * deliberately not an application run: it receives no engine, sources, artifacts or submit gate.
+ */
+export const LOCAL_APPLY_RECONCILIATION_RUN_PATH = "/local-apply/reconciliation/run";
+export const LOCAL_APPLY_RECONCILIATION_STATUS_PATH = "/local-apply/reconciliation/status";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_PATH = "/local-apply/reconciliation/handoff";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_STATUS_PATH = "/local-apply/reconciliation/handoff-status";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_FRAME_PATH = "/local-apply/reconciliation/handoff/frame";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_INPUT_PATH = "/local-apply/reconciliation/handoff/input";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_RESUME_PATH = "/local-apply/reconciliation/handoff/resume";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_END_PATH = "/local-apply/reconciliation/handoff/end";
 export const LOCAL_APPLY_ENGINES = ["claude", "codex"];
 export const LOCAL_APPLY_AUTH_MODES = ["machine", "subscription"];
 export const LOCAL_APPLY_MODES = ["fill_and_review", "auto_submit"];

package/dist/browser-runner/local-apply/live-run-browser.js

@@ -10,6 +10,20 @@ export function createLocalApplyBrowserFactory(options) {
         return { ...browser, handoffPage: options.sharedPage };
     };
 }
+/**
+ * Keep local-apply's browser construction out of `runner.ts`: research uses the generic factory,
+ * while application runs get a page-owning isolated context for the scoped handoff.
+ */
+export function createRunnerBrowserFactories(options) {
+    const browserFor = async (profile, runDir) => {
+        if (profile === "default")
+            return { tools: await options.defaultTools(), stop: async () => undefined };
+        const mcp = new McpRuntime();
+        await mcp.start({ userDataDir: join(runDir, "profile"), headless: options.headless });
+        return { tools: mcp, stop: () => mcp.stop() };
+    };
+    return { browserFor, applyBrowserFor: createLocalApplyBrowserFactory({ headless: options.headless, defaultBrowser: browserFor, sharedPage: options.sharedPage }) };
+}
 /**
  * Start the disposable browser context for one application run and retain only its current live
  * page for the bounded takeover adapter.  This deliberately does not seed, copy, or persist an

package/dist/browser-runner/local-apply/reconciliation-routes.js

@@ -0,0 +1,24 @@
+/** Separate from apply and generic tasks: this surface has no bridge/fill/submit operation. */
+export async function routeLocalApplyReconciliation(runtime, method, path, read) {
+    if (method !== "POST")
+        return undefined;
+    if (path === "/local-apply/reconciliation/run")
+        return runtime.start(await read());
+    if (path === "/local-apply/reconciliation/status")
+        return runtime.status(await read());
+    if (path === "/local-apply/reconciliation/handoff")
+        return runtime.handoff(await read());
+    if (path === "/local-apply/reconciliation/handoff-status")
+        return runtime.status(await read());
+    if (path === "/local-apply/reconciliation/handoff/frame")
+        return runtime.handoffFrame(await read());
+    if (path === "/local-apply/reconciliation/handoff/input") {
+        await runtime.handoffInput(await read());
+        return { ok: true };
+    }
+    if (path === "/local-apply/reconciliation/handoff/resume")
+        return runtime.resume(await read());
+    if (path === "/local-apply/reconciliation/handoff/end")
+        return runtime.end(await read());
+    return undefined;
+}

package/dist/browser-runner/local-apply/reconciliation-runtime.js

@@ -0,0 +1,241 @@
+/**
+ * Read-only reconciliation for an ended `submit_unconfirmed` attempt.
+ *
+ * This is intentionally independent of ApplyBridge: it launches no CLI, receives no source or
+ * artifact paths and has no action surface capable of filling, uploading or submitting.  The only
+ * page inspection remains in this process and returns a closed evidence vocabulary to PAGS.
+ */
+import { join } from "node:path";
+import { RunnerInputError } from "../errors.js";
+import { domainWithin } from "../local-browser/bridge.js";
+const SAFE_ID = /^[A-Za-z0-9_.:-]{1,300}$/;
+const TTL_MS = 10 * 60_000;
+/** Dedicated runtime; there is deliberately no bridge, engine, or generic browser-task fallback. */
+export class LocalApplyReconciliationRuntime {
+    deps;
+    sessions = new Map();
+    now;
+    schedule;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? (() => Date.now());
+        this.schedule = deps.schedule ?? ((task, delayMs) => {
+            const timer = setTimeout(task, delayMs);
+            return () => clearTimeout(timer);
+        });
+    }
+    async start(raw) {
+        const envelope = parseEnvelope(raw);
+        const existing = this.sessions.get(envelope.reconciliationId);
+        if (existing) {
+            if (existing.envelope.runId !== envelope.runId || existing.envelope.applicationId !== envelope.applicationId || existing.envelope.instanceId !== envelope.instanceId || existing.envelope.browserProfile !== envelope.browserProfile)
+                throw new RunnerInputError("The reconciliation id is already bound to another attempt", 409);
+            return this.view(existing);
+        }
+        const browser = await this.deps.browserFor(envelope.browserProfile, join(this.deps.dataDir, "reconciliation", envelope.reconciliationId));
+        const session = { envelope, browser, state: "running", expiresAt: this.now() + TTL_MS };
+        this.sessions.set(envelope.reconciliationId, session);
+        // The deadline belongs to the Runner, not to Console polling.  It is installed before
+        // navigation so an abandoned client cannot retain an owned browser/liveWork indefinitely.
+        session.cancelDeadline = this.schedule(() => { void this.expire(session); }, TTL_MS);
+        try {
+            const page = this.page(session);
+            if (!page)
+                return await this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+            await page.goto(envelope.applicationUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
+            return await this.inspect(session);
+        }
+        catch {
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        }
+    }
+    async status(raw) {
+        const session = this.require(raw);
+        if (session.state === "ended")
+            return this.view(session);
+        if (session.expiresAt <= this.now())
+            return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+        if (!this.page(session))
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        if (session.handoff?.state === "ready" && (session.handoff.expiresAt <= this.now() || !this.deps.takeover || await this.deps.takeover.state(session.handoff.id) !== "ready")) {
+            await this.closeHandoff(session, session.handoff.expiresAt <= this.now() ? "expired" : "page_lost");
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        }
+        return this.view(session);
+    }
+    async handoff(raw) {
+        const request = this.handoffRequest(raw);
+        const session = this.require(request);
+        this.assertHandoffBinding(session, request);
+        if (session.state !== "paused" || !session.pauseReason)
+            throw new RunnerInputError("Reconciliation handoff is available only for a live login or CAPTCHA pause", 409);
+        if (session.handoff)
+            throw new RunnerInputError("A reconciliation handoff already exists", 409);
+        const page = this.page(session);
+        if (!page || !this.deps.takeover)
+            return this.closedHandoff(session, request.handoffId, "profile_unavailable");
+        try {
+            await this.deps.takeover.open(request, page);
+        }
+        catch {
+            return this.closedHandoff(session, request.handoffId, "page_lost");
+        }
+        session.handoff = { id: request.handoffId, expiresAt: this.now() + TTL_MS, state: "ready" };
+        return this.view(session);
+    }
+    async handoffFrame(raw) {
+        const session = await this.liveHandoff(raw);
+        try {
+            return await this.deps.takeover.frame(session.handoff.id);
+        }
+        catch {
+            await this.closeHandoff(session, "page_lost");
+            await this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+            throw new RunnerInputError("The reconciliation page is no longer available", 409);
+        }
+    }
+    async handoffInput(raw) {
+        const request = raw && typeof raw === "object" ? raw : {};
+        const session = await this.liveHandoff(request);
+        if (!request.input || typeof request.input !== "object")
+            throw new RunnerInputError("handoff input is required");
+        // A person may authenticate/solve a CAPTCHA, but once that wall is gone this session accepts
+        // no further controls. It can never become an application fill/submit surface.
+        const blocker = await this.blocker(this.page(session));
+        if (!blocker)
+            throw new RunnerInputError("The read-only reconciliation handoff no longer accepts browser input", 409);
+        try {
+            await this.deps.takeover.input(session.handoff.id, request.input);
+        }
+        catch {
+            await this.closeHandoff(session, "page_lost");
+            await this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+            throw new RunnerInputError("The reconciliation page is no longer available", 409);
+        }
+    }
+    async resume(raw) {
+        const session = await this.liveHandoff(raw);
+        return this.inspect(session);
+    }
+    async end(raw) {
+        const request = this.handoffRequest(raw);
+        const session = this.require(request);
+        this.assertHandoffBinding(session, request);
+        if (session.handoff?.id !== request.handoffId)
+            throw new RunnerInputError("The reconciliation handoff is closed", 409);
+        if (session.handoff?.state === "ready")
+            await this.closeHandoff(session, "unavailable");
+        return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+    }
+    liveWork() { return [...this.sessions.values()].filter((s) => s.state !== "ended").map((s) => `reconciliation:${s.envelope.reconciliationId}`); }
+    closeAll() { for (const session of this.sessions.values())
+        void this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" }); }
+    async inspect(session) {
+        const page = this.page(session);
+        if (!page)
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        const state = await this.pageState(page).catch(() => null);
+        if (!state || !this.permitted(session, state.url))
+            return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+        if (state.login || state.captcha) {
+            session.state = "paused";
+            session.pauseReason = state.captcha ? "captcha" : "login_required";
+            return this.view(session);
+        }
+        // A handoff which has just cleared authentication is the one case where we retain the
+        // bounded browser.  It lets the owner inspect their authenticated account/job view without
+        // turning generic page prose into an outcome.  Explicit end or the ten-minute deadline
+        // resolves it as ambiguous unless a future provider-specific verifier supplies exact proof.
+        if (session.handoff?.state === "ready") {
+            session.state = "running";
+            session.pauseReason = undefined;
+            return this.view(session);
+        }
+        // SEEK has no validated account/job receipt or history contract in this runtime. Generic
+        // prose, receipt-like URLs, unauthenticated pages and absent receipts prove nothing.
+        return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+    }
+    async expire(session) {
+        if (session.state !== "ended" && session.expiresAt <= this.now())
+            await this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+    }
+    async finish(session, result) {
+        if (session.finishing)
+            return session.finishing;
+        if (session.state === "ended")
+            return this.view(session);
+        // Set terminal state synchronously, before any async teardown.  Concurrent End/timeout/page
+        // loss callers then converge on the same result and liveWork stops advertising ownership.
+        session.state = "ended";
+        session.pauseReason = undefined;
+        session.result = result;
+        session.cancelDeadline?.();
+        session.cancelDeadline = undefined;
+        session.finishing = (async () => {
+            if (session.handoff?.state === "ready")
+                await this.closeHandoff(session, "unavailable");
+            await session.browser.stop().catch(() => undefined);
+            return this.view(session);
+        })();
+        return session.finishing;
+    }
+    async closeHandoff(session, reason) {
+        if (!session.handoff || session.handoff.state === "closed")
+            return;
+        session.handoff.state = "closed";
+        session.handoff.reason = reason;
+        await this.deps.takeover?.end(session.handoff.id).catch(() => undefined);
+    }
+    async closedHandoff(session, id, reason) {
+        session.handoff = { id, expiresAt: this.now(), state: "closed", reason };
+        return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+    }
+    page(session) { const page = session.browser.handoffPage?.(); return page && !page.isClosed() ? page : null; }
+    permitted(session, raw) { try {
+        const host = new URL(raw).hostname.toLowerCase();
+        return session.envelope.allowDomains.some((d) => domainWithin(host, d));
+    }
+    catch {
+        return false;
+    } }
+    async blocker(page) { const state = page ? await this.pageState(page).catch(() => null) : null; return !!state && (state.login || state.captcha); }
+    async pageState(page) {
+        return page.evaluate(() => {
+            const text = (document.body?.innerText ?? "").toLowerCase();
+            const captcha = !!document.querySelector('iframe[src*="hcaptcha.com"], .h-captcha, iframe[src*="challenges.cloudflare.com"], .cf-turnstile, iframe[src*="arkoselabs"], .geetest_holder') || /confirm (that )?you('?re| are) not a robot|i'?m not a robot|verify (that )?you('?re| are) (a )?human|checking (if the site connection is secure|your browser)/.test(text);
+            // Kept in the page: site prose never crosses the runner boundary.  This is deliberately
+            // narrower than a guess; anything unrecognised becomes `ambiguous`.
+            const password = !!document.querySelector("input[type=password]");
+            const otp = !!document.querySelector("input[autocomplete='one-time-code'], input[name*='otp' i], input[name*='verification' i], input[id*='otp' i], input[id*='verification' i]");
+            const emailSignIn = !!document.querySelector("form[action*='login' i] input[type=email], form[action*='sign-in' i] input[type=email], [data-auth-screen] input[type=email]");
+            return { url: location.href, login: password || otp || emailSignIn, captcha };
+        });
+    }
+    require(raw) { const id = typeof raw?.reconciliationId === "string" ? raw.reconciliationId : ""; if (!SAFE_ID.test(id))
+        throw new RunnerInputError("reconciliationId is required"); const session = this.sessions.get(id); if (!session)
+        throw new RunnerInputError("Reconciliation session not found", 404); return session; }
+    handoffRequest(raw) { const o = raw && typeof raw === "object" ? raw : {}; const handoffId = typeof o.handoffId === "string" ? o.handoffId : ""; const runId = typeof o.runId === "string" ? o.runId : ""; const applicationId = typeof o.applicationId === "string" ? o.applicationId : ""; const reconciliationId = typeof o.reconciliationId === "string" ? o.reconciliationId : ""; const browserProfile = o.browserProfile === "isolated" || o.browserProfile === "default" ? o.browserProfile : null; if (![handoffId, runId, applicationId, reconciliationId].every((v) => SAFE_ID.test(v)) || !browserProfile)
+        throw new RunnerInputError("reconciliation handoff needs opaque ids and browserProfile"); return { handoffId, runId, applicationId, reconciliationId, browserProfile }; }
+    assertHandoffBinding(session, request) { const e = session.envelope; if (e.reconciliationId !== request.reconciliationId || e.runId !== request.runId || e.applicationId !== request.applicationId || e.browserProfile !== request.browserProfile)
+        throw new RunnerInputError("The reconciliation handoff does not match this exact attempt", 403); }
+    async liveHandoff(raw) { const request = this.handoffRequest(raw); const session = this.require(request); this.assertHandoffBinding(session, request); if ((session.state !== "paused" && session.state !== "running") || session.handoff?.id !== request.handoffId || session.handoff.state !== "ready")
+        throw new RunnerInputError("The reconciliation handoff is closed", 409); if (session.handoff.expiresAt <= this.now()) {
+        await this.closeHandoff(session, "expired");
+        await this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+        throw new RunnerInputError("The reconciliation handoff is closed", 409);
+    } return session; }
+    view(session) { const e = session.envelope; return { reconciliationId: e.reconciliationId, runId: e.runId, applicationId: e.applicationId, browserProfile: e.browserProfile, context: "separate_read_only_context", state: session.state, ...(session.pauseReason ? { pauseReason: session.pauseReason } : {}), ...(session.result ? { result: session.result } : {}) }; }
+}
+function parseEnvelope(raw) {
+    const o = raw && typeof raw === "object" ? raw : {};
+    const ids = ["reconciliationId", "runId", "instanceId", "applicationId"];
+    for (const key of ids)
+        if (typeof o[key] !== "string" || !SAFE_ID.test(o[key]))
+            throw new RunnerInputError(`Invalid reconciliation: ${key} is required`);
+    if (o.type !== "local_browser.apply.reconciliation" || (o.browserProfile !== "isolated" && o.browserProfile !== "default") || typeof o.applicationUrl !== "string" || !/^https?:\/\/[^\s/]+/i.test(o.applicationUrl))
+        throw new RunnerInputError("Invalid read-only reconciliation envelope");
+    const allowDomains = Array.isArray(o.allowDomains) ? o.allowDomains.filter((d) => typeof d === "string" && /^[a-z0-9.-]+$/i.test(d)).map((d) => d.toLowerCase()) : [];
+    if (!allowDomains.length || typeof o.jobIdentity !== "string" || !o.materialFingerprint || typeof o.materialFingerprint !== "object")
+        throw new RunnerInputError("Invalid reconciliation binding");
+    return { type: o.type, reconciliationId: o.reconciliationId, runId: o.runId, instanceId: o.instanceId, applicationId: o.applicationId, browserProfile: o.browserProfile, applicationUrl: o.applicationUrl, allowDomains, jobIdentity: o.jobIdentity, materialFingerprint: o.materialFingerprint };
+}

package/dist/browser-runner/runner.js

@@ -17,8 +17,9 @@ import { LOCAL_BROWSER_TASK_TYPE } from "./local-browser/contract.js";
 import { LocalArtifactRuntime } from "./local-artifact/runtime.js";
 import { LOCAL_ARTIFACT_TASK_TYPE } from "./local-artifact/contract.js";
 import { LocalApplyRuntime } from "./local-apply/runtime.js";
+import { LocalApplyReconciliationRuntime } from "./local-apply/reconciliation-runtime.js";
 import { LOCAL_APPLY_TASK_TYPE } from "./local-apply/contract.js";
-import { createLocalApplyBrowserFactory } from "./local-apply/live-run-browser.js";
+import { createRunnerBrowserFactories } from "./local-apply/live-run-browser.js";
 import { createLocalApplyTakeoverAdapter, isLocalApplyTakeover } from "./local-apply/takeover-adapter.js";
 import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
 /** True for a plain object. */
@@ -87,6 +88,8 @@ export class LocalRunner {
     localArtifact;
     /** Local application execution (#957): a signed-in CLI filling one application through the apply bridge. */
     localApply;
+    /** Browser-only, no-bridge reconciliation for an ended uncertain apply attempt. */
+    localApplyReconciliation;
     /** This runner's own local URL, once the server listens — the bridge forwarder calls back to it. */
     selfUrl = null;
     /** Live human-takeover sessions, keyed by task id (the page is kept alive). */
@@ -96,24 +99,17 @@ export class LocalRunner {
         mkdirSync(config.dataDir, { recursive: true });
         this.store = new RunnerStore(config.dataDir);
         this.coding = new CodingRuntime(join(config.dataDir, "repos"));
-        // `default` is the runner's own signed-in browser, shared and never closed by a run;
-        // `isolated` is a fresh profile inside the run's folder, removed with it.
-        const browserFor = async (profile, runDir) => {
-            if (profile === "default")
-                return { tools: await this.getMcp(), stop: async () => undefined };
-            const mcp = new McpRuntime();
-            await mcp.start({ userDataDir: join(runDir, "profile"), headless: config.headless });
-            return { tools: mcp, stop: () => mcp.stop() };
-        };
-        const applyBrowserFor = createLocalApplyBrowserFactory({ headless: config.headless, defaultBrowser: browserFor, sharedPage: () => this.activePage });
+        const { browserFor, applyBrowserFor } = createRunnerBrowserFactories({ headless: config.headless, defaultTools: () => this.getMcp(), sharedPage: () => this.activePage });
         this.localBrowser = new LocalBrowserRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, browserFor });
         this.localArtifact = new LocalArtifactRuntime({ dataDir: config.dataDir });
+        const localApplyTakeover = createLocalApplyTakeoverAdapter({ get: (id) => this.takeovers.get(id), set: (id, page) => this.takeovers.set(id, { page, reason: "local_apply", humanDone: false }), frame: (id) => this.takeoverFrame(id), input: (id, input) => this.takeoverInput(id, input), end: (id) => this.endTakeover(id) });
         this.localApply = new LocalApplyRuntime({
             dataDir: config.dataDir,
             selfUrl: () => this.selfUrl,
             browserFor: applyBrowserFor,
-            takeover: createLocalApplyTakeoverAdapter({ get: (id) => this.takeovers.get(id), set: (id, page) => this.takeovers.set(id, { page, reason: "local_apply", humanDone: false }), frame: (id) => this.takeoverFrame(id), input: (id, input) => this.takeoverInput(id, input), end: (id) => this.endTakeover(id) }),
+            takeover: localApplyTakeover,
         });
+        this.localApplyReconciliation = new LocalApplyReconciliationRuntime({ dataDir: config.dataDir, browserFor: applyBrowserFor, takeover: localApplyTakeover });
         // Tasks paused/running on a previous process are orphaned now — their
         // pages and takeover sessions are gone. Fail them so the board is clean.
         const expired = this.store.expireInFlightTasks();
@@ -131,7 +127,7 @@ export class LocalRunner {
      */
     liveWork() {
         const coding = this.coding.liveWork();
-        const local = [...this.localBrowser.liveWork(), ...this.localArtifact.liveWork(), ...this.localApply.liveWork()];
+        const local = [...this.localBrowser.liveWork(), ...this.localArtifact.liveWork(), ...this.localApply.liveWork(), ...this.localApplyReconciliation.liveWork()];
         return { codingTurns: coding.length, localRuns: local.length, detail: [...coding, ...local].slice(0, 10) };
     }
     capabilities() {
@@ -292,6 +288,7 @@ export class LocalRunner {
         this.localBrowser.closeAll();
         this.localArtifact.closeAll();
         this.localApply.closeAll();
+        this.localApplyReconciliation.closeAll();
         try {
             this.coding.closeAll();
         }

package/dist/browser-runner/server.js

@@ -5,6 +5,7 @@ import { probeGitSshIdentity } from "./coding/repo.js";
 import { checkEngine } from "./coding/engine-check.js";
 import { listGithubOrgs, listGithubRepos, searchGithubRepos, getGithubRepoDetail, getGithubCredentialScope } from "./coding/github-browse.js";
 import { routeLocalApplyHandoff } from "./local-apply/handoff-routes.js";
+import { routeLocalApplyReconciliation } from "./local-apply/reconciliation-routes.js";
 export function createRunnerServer(runner) {
     return createServer(async (req, res) => {
         try {
@@ -239,6 +240,9 @@ async function route(runner, req, res) {
     const handoff = await routeLocalApplyHandoff(runner.localApply, req.method, path, () => readJson(req));
     if (handoff)
         return json(res, 200, handoff);
+    const reconciliation = await routeLocalApplyReconciliation(runner.localApplyReconciliation, req.method, path, () => readJson(req));
+    if (reconciliation !== undefined)
+        return json(res, 200, reconciliation);
     if (req.method === "POST" && path === "/local-apply/resume") {
         return json(res, 200, runner.localApply.resume(await readJson(req)));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-	"version": "0.4.97",
+  "version": "0.4.99",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",