@proagentstore/cli 0.4.141 → 0.4.143

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

@@ -262,9 +262,11 @@ export function parseLocalApplyResult(raw) {
         const gateId = str(s.gateId, 100);
         if (mode !== "auto_submit")
             return { error: "a submitted outcome requires a run in auto_submit mode" };
-        if (!url || !isHttpUrl(url) || !at || Number.isNaN(Date.parse(at)) || !gateId)
+        if (!url || !isHttpUrl(url) || !traceUrl(url) || !at || Number.isNaN(Date.parse(at)) || !gateId)
             return { error: "a submitted outcome needs the confirmed url, its time and the gateId" };
-        out.submitted = { url, at, gateId };
+        // A page URL kept as a fact keeps origin and path only, as a trace's does (#1069): a confirmation
+        // page's query can carry session or application tokens, and the receipt is the page, not its query.
+        out.submitted = { url: traceUrl(url), at, gateId };
         out.submitAttempted = true;
     }
     // #975 — accepted ONLY as the closed vocabulary it declares. A runner that sends prose here gets
@@ -296,10 +298,10 @@ export function parseLocalApplyResult(raw) {
             const reason = oneOf(LOCAL_APPLY_UNAVAILABLE_REASONS, evidence.reason);
             const url = str(evidence.url, 2000);
             const observedAt = str(evidence.observedAt, 40);
-            if (!reason || !url || !isHttpUrl(url) || !observedAt || Number.isNaN(Date.parse(observedAt)) || evidence.source !== "page_notice") {
+            if (!reason || !url || !isHttpUrl(url) || !traceUrl(url) || !observedAt || Number.isNaN(Date.parse(observedAt)) || evidence.source !== "page_notice") {
                 return { error: "a job_unavailable result needs runner-verified unavailable evidence (reason, url, observedAt, source)" };
             }
-            out.unavailable = { reason, url, observedAt, source: "page_notice" };
+            out.unavailable = { reason, url: traceUrl(url), observedAt, source: "page_notice" };
         }
         else if (o.unavailable !== undefined)
             return { error: "unavailable evidence is only valid for a job_unavailable result" };

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

@@ -116,6 +116,18 @@ export function parseApplyEnvelope(raw) {
     if (Object.values(limits).some((v) => !v))
         throw bad("limits are out of range");
     const opt = (v) => (typeof v === "string" && v.trim() ? v.trim().slice(0, 300) : undefined);
+    // #1079: the owner's kept answers, within a resume's bounds — never an instruction. One over a bound is
+    // dropped, never cut: a shortened answer would be grounding the owner never wrote.
+    const ownerAnswers = [];
+    for (const a of Array.isArray(o.ownerAnswers) ? o.ownerAnswers : []) {
+        if (ownerAnswers.length >= LOCAL_APPLY_CAPS.answers)
+            break;
+        const r = (a && typeof a === "object" ? a : {});
+        const question = typeof r.question === "string" ? r.question.trim() : "";
+        const answer = typeof r.answer === "string" ? r.answer.trim() : "";
+        if (question && answer && question.length <= LOCAL_APPLY_CAPS.questionChars && answer.length <= LOCAL_APPLY_CAPS.answerChars)
+            ownerAnswers.push({ question, answer });
+    }
     return {
         type: LOCAL_APPLY_TASK_TYPE,
         runId: o.runId,
@@ -132,6 +144,7 @@ export function parseApplyEnvelope(raw) {
         artifacts,
         policy: { mode: p.mode, allowDomains, ...(p.mode === "auto_submit" && gateId ? { submitGate: { gateId } } : {}), ...(p.screenshots === false ? { screenshots: false } : {}) },
         limits,
+        ...(ownerAnswers.length ? { ownerAnswers } : {}),
     };
 }
 /**
@@ -371,6 +384,9 @@ export class LocalApplyRuntime {
                 throw new Blocked("artifact_changed", [`${v.error} Re-run tailoring for this application.`]);
             blocks.push({ label: a.kind, text: v.text });
         }
+        // #1079: answers the owner already gave this application, as a source — the same shape a resume's answers take.
+        if (e.ownerAnswers?.length)
+            blocks.push({ label: "owner answers", text: e.ownerAnswers.map((a) => `Q: ${a.question}\nA: ${a.answer}`).join("\n\n") });
         run.grounding = blocks.map((b) => b.text);
         const bridgeScript = this.deps.bridgeScript ?? fileURLToPath(new URL("../local-browser/bridge-stdio.js", import.meta.url));
         const spec = buildApplyEngineSpec(e, applyPrompt(e, blocks), { command: process.execPath, args: [bridgeScript], env: { [BRIDGE_ENV.url]: selfUrl, [BRIDGE_ENV.runId]: e.runId, [BRIDGE_ENV.token]: run.token } }, join(run.dir, "mcp.json"));

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

@@ -122,6 +122,20 @@ export function redactDetail(detail, depth = 0, secrets = []) {
 const str = (v, max) => (typeof v === "string" && v.trim() ? v.trim().slice(0, max) : null);
 const isHttpUrl = (v) => /^https?:\/\/[^\s/]+/i.test(v);
 const oneOf = (list, v) => (list.includes(v) ? v : null);
+/**
+ * A page URL as a trace may keep it (#1069): origin and path — no query, no fragment, no credentials
+ * (`origin` never carries a `user:pass@`). The same rule as the local-apply contract's `traceUrl`;
+ * restated here because each vendored contract imports nothing. Empty when it is not an http(s) URL.
+ */
+export function traceUrl(raw) {
+    try {
+        const u = new URL(raw);
+        return u.protocol === "http:" || u.protocol === "https:" ? `${u.origin}${u.pathname}` : "";
+    }
+    catch {
+        return "";
+    }
+}
 /** A validated event, or null. */
 export function parseLocalBrowserEvent(raw) {
     if (!raw || typeof raw !== "object")
@@ -132,9 +146,14 @@ export function parseLocalBrowserEvent(raw) {
     if (!type || !at || Number.isNaN(Date.parse(at)))
         return null;
     const event = { type, at };
+    // Origin and path only (#1069): a research trace keeps where the browser went, never a page's query
+    // or fragment — a sign-in page's OAuth state/nonce/PKCE values or a session id ride there.
     const url = str(o.url, 2000);
-    if (url && isHttpUrl(url))
-        event.url = url;
+    if (url && isHttpUrl(url)) {
+        const kept = traceUrl(url);
+        if (kept)
+            event.url = kept;
+    }
     const domain = str(o.domain, 253);
     if (domain)
         event.domain = domain.toLowerCase();

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

@@ -27,7 +27,7 @@ import { RunnerInputError } from "../errors.js";
 import { BrowserBridge, domainWithin } from "./bridge.js";
 import { SCOUT_SHOT_CAP, ShotRecorder } from "./replay.js";
 import { BRIDGE_ENV } from "./bridge-stdio.js";
-import { LOCAL_BROWSER_AUTH_MODES, LOCAL_BROWSER_ENGINES, LOCAL_BROWSER_TASK_TYPE, redactDetail, redactFinding, redactSourceFailure, redactText, secretEnvValues, } from "./contract.js";
+import { LOCAL_BROWSER_AUTH_MODES, LOCAL_BROWSER_ENGINES, LOCAL_BROWSER_TASK_TYPE, redactDetail, redactFinding, redactSourceFailure, redactText, secretEnvValues, traceUrl, } from "./contract.js";
 import { bridgeUnused, buildEngineSpec, finalText, missingLogin, observedEngineAuth, researchPrompt, signInHelp } from "./engine.js";
 /**
  * Why the run could not be launched, in words the owner can act on (#944).
@@ -174,7 +174,9 @@ export class LocalBrowserRuntime {
             return { runId: same.envelope.runId, taskId: same.envelope.runId, status: same.state, existing: true };
         if (this.runs.has(envelope.runId))
             throw new RunnerInputError(`Run ${envelope.runId} already exists with another requestId`, 409);
-        const active = [...this.runs.values()].filter((r) => r.envelope.instanceId === envelope.instanceId && r.state !== "ended").length;
+        // A PAUSED run waits on a person and holds no slot (#1079) — the cloud counts the same way. Its own
+        // resume is the owner's act and is not refused, so the cap bounds STARTS; research is read-only.
+        const active = [...this.runs.values()].filter((r) => r.envelope.instanceId === envelope.instanceId && r.state === "running").length;
         if (active >= envelope.limits.maxConcurrent)
             throw new RunnerInputError(`This machine is already running ${active} research run(s) for this agent (limit ${envelope.limits.maxConcurrent}).`, 409);
         const selfUrl = this.deps.selfUrl();
@@ -301,9 +303,11 @@ export class LocalBrowserRuntime {
     emit(run, ev) {
         if (run.events.length >= MAX_EVENTS)
             return;
-        const { detail: raw, ...rest } = ev;
+        // Origin and path only, before anything leaves the machine (#1069) — the cloud reduces it again.
+        const { detail: raw, url: rawUrl, ...rest } = ev;
+        const url = rawUrl ? traceUrl(rawUrl) : "";
         const detail = redactDetail(raw, 0, run.secrets);
-        run.events.push({ ...rest, ...(detail && Object.keys(detail).length ? { detail } : {}), at: new Date(this.now()).toISOString(), seq: ++run.seq });
+        run.events.push({ ...rest, ...(url ? { url } : {}), ...(detail && Object.keys(detail).length ? { detail } : {}), at: new Date(this.now()).toISOString(), seq: ++run.seq });
     }
     pause(run, reason, detail) {
         if (run.state === "ended" || run.cancelled)

package/package.json

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