@mjasnikovs/pi-task 0.40.35 → 0.40.37

package/dist/shared/child-process.d.ts

@@ -9,6 +9,8 @@ export declare const CHILD_BASE_ARGS: readonly ["--print", "--no-skills", "--no-
 export interface WritableLike {
     write(chunk: string): boolean;
     end(): void;
+    /** Optional so a mock stdin stays two methods; a real pipe always has it. */
+    on?(event: 'error', listener: (err: unknown) => void): unknown;
 }
 export interface ProcLike extends EventEmitter {
     /** Present only when the child was spawned with stdin 'pipe' (prompt delivery). */

package/dist/shared/child-process.js

@@ -236,6 +236,10 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             ...(invocation.env ? { env: invocation.env } : {})
         });
         if (usesStdin) {
+            // A child killed before it read the prompt leaves the pipe broken, and an
+            // unhandled EPIPE on stdin takes the whole process down. The child's own
+            // exit is what reports that run; this write has nothing left to say.
+            proc.stdin?.on?.('error', () => { });
             // pi reads the prompt from stdin and waits for EOF, so write then end.
             proc.stdin?.write(invocation.stdin);
             proc.stdin?.end();

package/dist/task/deep-render-check.d.ts

@@ -113,9 +113,9 @@ export interface DeepSessionFacts {
  * The three request-shaped facts, computed from the log and from nothing else. The
  * driver records `sessionRequests` and calls this; the values are exactly what the
  * pre-log driver computed by filtering the same map (the sign-in request is the
- * first same-origin non-GET issued at or after the submit; the data requests are the
- * same-origin
- * XHR/fetch issued at or after the submit, the sign-in request itself excluded).
+ * first same-origin non-GET issued at or after the submit; the data requests are
+ * the same-origin XHR/fetch issued at or after the sign-in request, that request
+ * itself excluded).
  */
 export declare function deriveLegacyFacts(log: SessionRequest[]): Pick<DeepSessionFacts, 'authRequest' | 'postAuthDataAttempted' | 'postAuthData2xx'>;
 /**

package/dist/task/deep-render-check.js

@@ -202,9 +202,9 @@ export function pinnedLocalPort(vars) {
  * The three request-shaped facts, computed from the log and from nothing else. The
  * driver records `sessionRequests` and calls this; the values are exactly what the
  * pre-log driver computed by filtering the same map (the sign-in request is the
- * first same-origin non-GET issued at or after the submit; the data requests are the
- * same-origin
- * XHR/fetch issued at or after the submit, the sign-in request itself excluded).
+ * first same-origin non-GET issued at or after the submit; the data requests are
+ * the same-origin XHR/fetch issued at or after the sign-in request, that request
+ * itself excluded).
  */
 export function deriveLegacyFacts(log) {
     const auth = log.find(r => r.phase === 'auth') ?? null;
@@ -659,10 +659,15 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
         // judges it is the chain's last, so the first hop stays and the eventual
         // response lands on it. Overwriting reads a POST that 302s as a GET, and
         // then no sign-in request is ever found.
-        if (p.redirectResponse === undefined || !requests.has(id)) {
-            const req = p.request;
+        const req = p.request;
+        const existing = requests.get(id);
+        if (p.redirectResponse !== undefined && existing) {
+            existing.finalUrl = String(req?.url ?? existing.finalUrl);
+        }
+        else {
             requests.set(id, {
                 url: String(req?.url ?? ''),
+                finalUrl: String(req?.url ?? ''),
                 method: String(req?.method ?? 'GET'),
                 type: String(p.type ?? ''),
                 status: null,
@@ -706,15 +711,15 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
     const before = await evaluate(INSPECT_EXPR);
     if (!before)
         throw new Error('the page could not be inspected');
-    const sameOrigin = (r) => r.url.startsWith(`${origin}/`) || r.url === origin;
+    const sameOrigin = (r) => r.finalUrl.startsWith(`${origin}/`) || r.finalUrl === origin;
     const isData = (r) => r.type === 'XHR' || r.type === 'Fetch';
     const foreignOriginFailures = () => {
         const out = new Set();
         for (const r of requests.values()) {
-            if (sameOrigin(r) || !r.failed || !r.url.startsWith('http'))
+            if (sameOrigin(r) || !r.failed || !r.finalUrl.startsWith('http'))
                 continue;
             try {
-                out.add(new URL(r.url).origin);
+                out.add(new URL(r.finalUrl).origin);
             }
             catch {
                 // unparseable url — nothing to name
@@ -725,10 +730,11 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
     const initiatorOf = (r) => isData(r) ? 'xhr'
         : r.type === 'Document' ? 'document'
             : 'other';
-    /** The same-origin request log, phased against the submit. `postSeq` is the
-     *  first `seq` the submit could issue — Infinity while no submit has happened —
-     *  so before a submit every request so far is 'pre'; the sign-in request sits at
-     *  or after the boundary but is 'auth', not 'post'. */
+    /** The same-origin request log. `postSeq` is where the authenticated half
+     *  begins — Infinity while no submit has happened — so everything before it is
+     *  'pre'; the sign-in request itself is 'auth', not 'post'. The boundary is the
+     *  sign-in request, not the submit: a CSRF token or a beacon the submit fires
+     *  BEFORE the login is not evidence about the authenticated client. */
     const sessionLog = (authId, postSeq) => [...requests]
         .filter(([, r]) => sameOrigin(r))
         .map(([id, r]) => ({
@@ -759,6 +765,7 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
     const unsubmitted = (over) => facts(sessionLog(null, Number.POSITIVE_INFINITY), over);
     if (!before.hasPassword || credentials === null)
         return judge(unsubmitted({}));
+    const fillSeq = nextSeq;
     const filled = await evaluate(fillExpr(credentials.identifier, credentials.password));
     if (!filled?.ok)
         return judge(unsubmitted({ submitted: false }));
@@ -784,6 +791,18 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
             break;
         }
     }
+    // Nothing after the submit: a form that submits from the fill's own input
+    // events already sent it. Only a NAVIGATION qualifies here — a form submission
+    // is one, and the background traffic the fill races (beacons, telemetry) is
+    // XHR or fetch, never a document.
+    if (authId === null) {
+        for (const [id, r] of requests) {
+            if (r.seq >= fillSeq && sameOrigin(r) && r.method !== 'GET' && r.type === 'Document') {
+                authId = id;
+                break;
+            }
+        }
+    }
     const authReq = authId === null ? null : requests.get(authId);
     const now = await evaluate(INSPECT_EXPR);
     const domJudgment = judgeRenderedDom(now?.html ?? '');
@@ -805,7 +824,7 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
         lastActivity = Date.now();
         await settle(() => lastActivity, RE_NAV_CAP_MS, quietMs);
     }
-    return judge(facts(sessionLog(authId, submitSeq), {
+    return judge(facts(sessionLog(authId, authReq?.seq ?? submitSeq), {
         submitted: true,
         foreignOriginFailures: foreignOriginFailures(),
         leftAuthWall,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.40.35",
+    "version": "0.40.37",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",