@mjasnikovs/pi-task 0.40.33 → 0.40.35

package/README.md

@@ -268,7 +268,7 @@ bun run lint       # prettier + eslint + tsc --noEmit
 bun run build      # tsc → dist/
 ```
 
-Built with [Bun](https://bun.sh), TypeScript (strict), and [TypeBox](https://github.com/sinclairzx81/typebox) for tool schemas. Design plans live in [`plans/`](./plans).
+Built with [Bun](https://bun.sh), TypeScript (strict), and [TypeBox](https://github.com/sinclairzx81/typebox) for tool schemas.
 
 ## License
 

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

@@ -65,7 +65,7 @@ export declare function verifyExcerpt(excerpt: string, content: string): Excerpt
  * fabrication. An excerpt assembled from several real spans is a stitched quote,
  * which is what the extraction prompt produces — and calling that a possible
  * hallucination was wrong on 21 of 21 measured cases, on a fifth of every run's
- * answers. See "Defect 18" in DOC_REGRESSINONS.md.
+ * answers.
  */
 export declare function formatResultText(header: string, parsed: {
     answer: string;

package/dist/shared/child-output.js

@@ -112,7 +112,7 @@ export function verifyExcerpt(excerpt, content) {
  * fabrication. An excerpt assembled from several real spans is a stitched quote,
  * which is what the extraction prompt produces — and calling that a possible
  * hallucination was wrong on 21 of 21 measured cases, on a fifth of every run's
- * answers. See "Defect 18" in DOC_REGRESSINONS.md.
+ * answers.
  */
 export function formatResultText(header, parsed, check) {
     if (!parsed.excerpt) {

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

@@ -70,7 +70,8 @@ export interface SessionRequest {
     failed: boolean;
     /** CDP resource type, collapsed: what ISSUED this request. */
     initiator: 'xhr' | 'document' | 'other';
-    /** Relative to the sign-in request: before it, it, or after it. */
+    /** Before the submit, the sign-in request itself, or issued at or after the
+     *  submit. */
     phase: 'pre' | 'auth' | 'post';
 }
 export interface DeepSessionFacts {
@@ -93,8 +94,8 @@ export interface DeepSessionFacts {
         status: number | null;
         failed: boolean;
     } | null;
-    /** Same-origin XHR/fetch requests issued AFTER the sign-in response, excluding
-     *  the sign-in request itself. Derived: `sessionRequests` in phase 'post'. */
+    /** Same-origin XHR/fetch requests issued at or after the submit, excluding the
+     *  sign-in request itself. Derived: `sessionRequests` in phase 'post'. */
     postAuthDataAttempted: number;
     postAuthData2xx: number;
     /** Origins the client called that are not the app's own, whose requests failed
@@ -112,8 +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 after submit; the data requests are the same-origin
- * XHR/fetch issued at or after it, 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 submit, the sign-in request itself excluded).
  */
 export declare function deriveLegacyFacts(log: SessionRequest[]): Pick<DeepSessionFacts, 'authRequest' | 'postAuthDataAttempted' | 'postAuthData2xx'>;
 /**
@@ -225,7 +227,7 @@ export interface DriveSessionOptions {
 /**
  * The session over an already-connected browser: navigate, inspect, sign in if the
  * landing is a wall and credentials exist, settle, phase the same-origin request
- * log against the sign-in request, re-enter once the sign-in was accepted, and
+ * log against the submit, re-enter once the sign-in was accepted, and
  * hand the facts to `judge`. Pure protocol logic — no process, no filesystem, no
  * socket — so every branch is testable against a fake `CdpLike`.
  *

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

@@ -202,8 +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 after submit; the data requests are the same-origin
- * XHR/fetch issued at or after it, 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 submit, the sign-in request itself excluded).
  */
 export function deriveLegacyFacts(log) {
     const auth = log.find(r => r.phase === 'auth') ?? null;
@@ -290,8 +291,12 @@ export function judgeDeepSession(f) {
     // `GET /*` → index.html fallback returns 200 for a route it does not have, so
     // the status is healthy and the body is the app shell. A document navigation
     // answered with HTML is normal; an XHR asking for data and getting HTML is a
-    // call that reached nothing.
-    const swallowed = (f.sessionRequests ?? []).find(r => r.initiator === 'xhr' && (r.mimeType ?? '').startsWith('text/html'));
+    // call that reached nothing. The sign-in request is exempt: it keeps the first
+    // hop but carries the LAST hop's mime, so a fetch login that 302s to a page
+    // reads as HTML here while being a sign-in that worked.
+    const swallowed = (f.sessionRequests ?? []).find(r => r.initiator === 'xhr'
+        && r.phase !== 'auth'
+        && (r.mimeType ?? '').startsWith('text/html'));
     if (swallowed) {
         return {
             outcome: 'fail',
@@ -636,7 +641,7 @@ export async function launchBrowser(bin, userDataDir, { signal } = {}) {
 /**
  * The session over an already-connected browser: navigate, inspect, sign in if the
  * landing is a wall and credentials exist, settle, phase the same-origin request
- * log against the sign-in request, re-enter once the sign-in was accepted, and
+ * log against the submit, re-enter once the sign-in was accepted, and
  * hand the facts to `judge`. Pure protocol logic — no process, no filesystem, no
  * socket — so every branch is testable against a fake `CdpLike`.
  *
@@ -645,18 +650,27 @@ export async function launchBrowser(bin, userDataDir, { signal } = {}) {
 export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
     const origin = new URL(url).origin;
     const requests = new Map();
+    let nextSeq = 0;
     let lastActivity = Date.now();
     cdp.on('Network.requestWillBeSent', p => {
-        const req = p.request;
-        requests.set(String(p.requestId), {
-            url: String(req?.url ?? ''),
-            method: String(req?.method ?? 'GET'),
-            type: String(p.type ?? ''),
-            status: null,
-            mimeType: null,
-            failed: false,
-            at: Date.now()
-        });
+        const id = String(p.requestId);
+        // A redirect hop reuses the requestId, carrying the NEXT hop's method and
+        // url. The request the client made is the first hop and the status that
+        // 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;
+            requests.set(id, {
+                url: String(req?.url ?? ''),
+                method: String(req?.method ?? 'GET'),
+                type: String(p.type ?? ''),
+                status: null,
+                mimeType: null,
+                failed: false,
+                seq: nextSeq++
+            });
+        }
         lastActivity = Date.now();
     });
     cdp.on('Network.responseReceived', p => {
@@ -711,27 +725,23 @@ 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 sign-in request. `authAt` is
-     *  Infinity before the submit, so every request so far is 'pre'. */
-    const sessionLog = (authId, authAt) => {
-        const out = [];
-        for (const [id, r] of requests) {
-            if (!sameOrigin(r))
-                continue;
-            out.push({
-                method: r.method,
-                path: pathOf(r.url),
-                status: r.status,
-                mimeType: r.mimeType,
-                failed: r.failed,
-                initiator: initiatorOf(r),
-                phase: id === authId ? 'auth'
-                    : r.at >= authAt ? 'post'
-                        : 'pre'
-            });
-        }
-        return out;
-    };
+    /** 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'. */
+    const sessionLog = (authId, postSeq) => [...requests]
+        .filter(([, r]) => sameOrigin(r))
+        .map(([id, r]) => ({
+        method: r.method,
+        path: pathOf(r.url),
+        status: r.status,
+        mimeType: r.mimeType,
+        failed: r.failed,
+        initiator: initiatorOf(r),
+        phase: id === authId ? 'auth'
+            : r.seq >= postSeq ? 'post'
+                : 'pre'
+    }));
     const facts = (log, over) => ({
         sessionRequests: log,
         ...deriveLegacyFacts(log),
@@ -749,13 +759,15 @@ 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 submitMark = Date.now();
     const filled = await evaluate(fillExpr(credentials.identifier, credentials.password));
     if (!filled?.ok)
         return judge(unsubmitted({ submitted: false }));
     // Separate turn: the fill's input events schedule framework state updates that
     // the submit handler must already see.
     await sleep(300);
+    // Captured after the fill: background traffic before the submit must not be
+    // eligible as the sign-in request.
+    const submitSeq = nextSeq;
     const submitted = await evaluate(SUBMIT_EXPR);
     if (!submitted?.ok)
         return judge(unsubmitted({ submitted: false }));
@@ -765,16 +777,14 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
     // own 2xx is the precondition for judging anything, and it is EXCLUDED from the
     // data evidence — a broken build satisfies "at least one same-origin 2xx" with
     // exactly this request and nothing else.
-    const after = new Map([...requests].filter(([, r]) => r.at >= submitMark));
     let authId = null;
-    for (const [id, r] of after) {
-        if (sameOrigin(r) && r.method !== 'GET') {
+    for (const [id, r] of requests) {
+        if (r.seq >= submitSeq && sameOrigin(r) && r.method !== 'GET') {
             authId = id;
             break;
         }
     }
-    const authReq = authId !== null ? after.get(authId) : null;
-    const authAt = authReq?.at ?? submitMark;
+    const authReq = authId === null ? null : requests.get(authId);
     const now = await evaluate(INSPECT_EXPR);
     const domJudgment = judgeRenderedDom(now?.html ?? '');
     const leftAuthWall = !(now?.hasPassword ?? false) || (now?.pathname ?? '') !== before.pathname;
@@ -795,7 +805,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, authAt), {
+    return judge(facts(sessionLog(authId, submitSeq), {
         submitted: true,
         foreignOriginFailures: foreignOriginFailures(),
         leftAuthWall,

package/dist/workers/docs-ecosystems.d.ts

@@ -87,7 +87,7 @@ export interface EcosystemProfile {
     /**
      * Packages whose declarations belong in THIS package's index, because this
      * package exports names it does not declare — `hspec`/`hspec-core`,
-     * `axum`/`axum-core`; see DEFECT-12-STOPPING-RULE.md.
+     * `axum`/`axum-core`.
      */
     supplements?: (pkg: ResolvedPackage, cwd: string, io: EcosystemIo) => Promise<ResolvedPackage[]>;
     /**

package/dist/workers/docs-index.js

@@ -312,8 +312,9 @@ function ingestBody(cache, pkg, profile, contentHash, supplements = []) {
         }
     }
     // A facade package indexes to a table of contents: `hspec` is 14 chunks of
-    // export lists and every signature is in `hspec-core`. Fill only the holes —
-    // see DEFECT-12-STOPPING-RULE.md for the boundary and why it stops here.
+    // export lists and every signature is in `hspec-core`. Fill only the holes,
+    // and only one hop out: after one hop hspec has zero unresolved names left,
+    // and no package measured had anything for a second hop to fetch.
     const found = supplements.length > 0 ? (profile.exportGap?.(pkg.root) ?? null) : null;
     const gap = found !== null && !found.empty ? found : null;
     for (const sup of gap === null ? [] : supplements) {

package/dist/workers/eco-cargo.d.ts

@@ -122,7 +122,7 @@ export declare function manifestCrates(cwd: string): Set<string> | undefined;
  * The trigger is the hole, with no threshold — measured, and for the same reason
  * as hackage: across twenty-two crates the unresolved fraction reads 100% on a
  * crate with one re-export and 0% on a crate with none, so a ratio separates
- * nothing. See "Defect 16" in DOC_REGRESSINONS.md for the sweep.
+ * nothing.
  */
 export declare function cargoExportGap(root: string): ExportGap;
 /**

package/dist/workers/eco-cargo.js

@@ -869,7 +869,7 @@ export function manifestCrates(cwd) {
     }
     return out;
 }
-// ── the facade gap (DEFECT-12-STOPPING-RULE.md, cargo half) ─────────────────
+// ── the facade gap, cargo half ──────────────────────────────────────────────
 /** A `pub use …;` statement, attributes and line breaks included. */
 const PUB_USE_RE = /\bpub\s+use\s+([^;]+);/g;
 /** Every item head that introduces a name, visibility ignored — a facade may
@@ -995,7 +995,7 @@ function moduleOfPath(relPath) {
  * The trigger is the hole, with no threshold — measured, and for the same reason
  * as hackage: across twenty-two crates the unresolved fraction reads 100% on a
  * crate with one re-export and 0% on a crate with none, so a ratio separates
- * nothing. See "Defect 16" in DOC_REGRESSINONS.md for the sweep.
+ * nothing.
  */
 export function cargoExportGap(root) {
     const deps = runtimeDeps(root);

package/dist/workers/eco-hackage.js

@@ -600,8 +600,9 @@ export function manifestPackages(cwd) {
  * re-export puts the name in the export list; a `module X` re-export puts
  * nothing there at all, which is why `shouldBe` is invisible to the first.
  *
- * See DEFECT-12-STOPPING-RULE.md for why this triggers on the hole itself
- * rather than on a fraction of the export list.
+ * The trigger is the hole, with no threshold. Swept over the 299 modules with
+ * 5+ exports, the trigger count reads 33 at 50% and 18 at 95%, so the fraction
+ * is not carrying the decision and any value picked would just sound right.
  */
 const EXPORT_NAME_RE = /^[A-Za-z_][\w']*$/;
 /** `module X` inside an export list is a re-export; `Prelude` is base, and base is not fetched. */

package/dist/workers/export-gap.d.ts

@@ -4,8 +4,8 @@
  * `hspec` indexes to a table of contents and every signature is in `hspec-core`;
  * `axum` re-exports `IntoResponse` and the trait lives in `axum-core`. Both are
  * the same failure — a query retrieves the package's own chunks and not one of
- * them defines the thing asked about — and DEFECT-12-STOPPING-RULE.md fixes the
- * boundary for following the re-export.
+ * them defines the thing asked about — so the re-export is followed exactly one
+ * hop, to a dependency the package's own name prefixes.
  *
  * The boundary is shared; the parsing is not. Haskell states the gap in an export
  * list, Rust in `pub use`, so each ecosystem answers the same three questions in

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.40.33",
+    "version": "0.40.35",
     "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",