@mjasnikovs/pi-task 0.40.29 → 0.40.30

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

@@ -140,7 +140,7 @@ export interface EcosystemProfile {
      * retrieval budget for text the reader already has, and neither is
      * separable downstream — same identifiers, same package, same version.
      */
-    selectFiles?: (files: readonly string[]) => string[];
+    selectFiles?: (files: readonly string[], pkg: ResolvedPackage) => string[];
     /** What this ecosystem's packages ship, for a "there is nothing to read" answer. */
     surfaceLabel: string;
     /**

package/dist/workers/docs-ecosystems.js

@@ -24,7 +24,7 @@ import { dropParallelDeclarations } from './docs-index.js';
 import { npmVersionLookup } from './npm-version.js';
 import { resolveCrate, cratesLatest, crateTarballUrl, crateOf, isValidCrateName, isRustFile, lockedVersion, rustSurface, cargoProjectName, childDirs, lockedDeps, manifestCrates, cargoExportGap, cargoContentFingerprint, cargoSupplementCandidates, CARGO_DECL_SPLIT_RE, CARGO_MEMBER_SPLIT_RE } from './eco-cargo.js';
 import { resolveHackage, hackageLatest, hackageVersion, hackageTarballUrl, hackageExtractDir, hackageProjectName, supplementCandidates, hackageExportGap, hackageContentFingerprint, findCabalTarball, cachedVersions, resolvedVersions, manifestPackages, isValidHackageName, isHaskellFile, haskellSurface, HACKAGE_DECL_SPLIT_RE, HACKAGE_SKIP_DIRS, HACKAGE_MEMBER_SPLIT_RE } from './eco-hackage.js';
-import { detectGo, isValidImportPath, resolveGoPackage, acquireGoModule, goDeclaredVersion, goLatest, goProjectName, goDeclaredDeps, goManifestDeps, isGoFile, selectBuildVariants, defaultGoModCache, goContentFingerprintParts } from './eco-go.js';
+import { detectGo, isValidImportPath, resolveGoPackage, acquireGoModule, goDeclaredVersion, goLatest, goProjectName, goDeclaredDeps, goManifestDeps, isGoFile, selectBuildVariants, selectOwnPackage, defaultGoModCache, goContentFingerprintParts } from './eco-go.js';
 import { goSurface, goContentFingerprint, GO_DECL_SPLIT_RE, GO_MEMBER_SPLIT_RE } from './go-surface.js';
 import { runChild } from '../shared/child-process.js';
 /**
@@ -503,7 +503,7 @@ const goProfile = {
     typeKeywords: ['type', 'struct', 'interface', 'func'],
     commentPrefix: '//',
     skipDirs: ['testdata', 'examples', 'vendor', 'internal', '.git'],
-    selectFiles: selectBuildVariants,
+    selectFiles: (files, pkg) => selectBuildVariants(selectOwnPackage(files, pkg.root, pkg.name, pkg.version)),
     surfaceLabel: '.go source or README',
     packageSubject: 'a Go package',
     projectGlobs: ['*.go'],

package/dist/workers/docs-index.js

@@ -181,7 +181,7 @@ function collectFiles(pkg, profile) {
     const walked = walkSurface(pkg.root, profile);
     const surface = dropDeadMajors(walked, pkg.root, pkg.version);
     return {
-        surface: profile.selectFiles ? profile.selectFiles(surface) : surface,
+        surface: profile.selectFiles ? profile.selectFiles(surface, pkg) : surface,
         readme: pkg.readme
     };
 }

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

@@ -174,6 +174,38 @@ export declare function acquireGoModule(importPath: string, pinned: string | nul
  * with no tags: a bare negation holds, a bare tag does not.
  */
 export declare function selectBuildVariants(files: readonly string[]): string[];
+/**
+ * Keep the package the caller asked for, and only the subpackages it can reach.
+ *
+ * A Go subdirectory is a DIFFERENT importable package — `zapcore` is not reachable
+ * as `zap.X` and `ginS` is not `gin` — so walking a module's whole tree files every
+ * one of them under the parent's name and its version banner. Measured on re-run 9's
+ * cache: 71% of `encoding/json`'s chunks, 54% of zap's and 34% of gin's belonged to
+ * a package nobody asked about, and it reached retrieval — a question about
+ * registering a gin route came back with 10 `ginS` chunks of 51, in a corpus already
+ * spending 19,941 of its 24,000 bytes.
+ *
+ * The gate is the ROOT'S OWN IMPORTS, closed over: zap's `Field` is
+ * `= zapcore.Field`, so dropping `zapcore` would break the alias hop that defect 3
+ * exists to serve, and zapcore in turn reaches `buffer`. What that keeps is what a
+ * caller of this package can actually be handed; `zapgrpc`, `zaptest`, `ginS`,
+ * `httputil` and `net/http/pprof` are reachable only by importing them directly,
+ * which the tool already resolves on its own — `github.com/gin-gonic/gin/binding`
+ * asked for by path reads 0% foreign.
+ *
+ * A mismatching top-level `vN/` goes whatever the imports say. `encoding/json` is
+ * built ON `encoding/json/v2` and imports it, but v2 is a different major of the
+ * same API with the same identifiers — `Marshal`, `Unmarshal` — and half the
+ * retrieval for the commonest decode question came back from it under a
+ * `Per encoding/json@go1.25.14` header. That is `dropDeadMajors`' case, which
+ * cannot fire here because it reads the major with `/^(\d+)\./` and Go spells its
+ * versions `v1.12.0` and `go1.25.14`.
+ *
+ * A module whose root holds no Go files is not a package at all — the aws-sdk shape
+ * — and keeps everything, for the same reason `dropDeadMajors` keeps a package whose
+ * whole surface lives under one `vN/`.
+ */
+export declare function selectOwnPackage(files: readonly string[], root: string, name: string, version: string): string[];
 /**
  * Everything below `goSurface` and the file-selection rule that feeds it, by
  * source, so a fix to either re-indexes rather than being masked by a cache hit.

package/dist/workers/eco-go.js

@@ -650,10 +650,105 @@ function holdsByDefault(src) {
         return true;
     return expr.split(/\s*&&\s*/).every(term => term.startsWith('!'));
 }
+/** The import paths a Go file's import block names. */
+function importsOf(src) {
+    const out = [];
+    for (const m of src.matchAll(/"([^"\n]+)"/g)) {
+        if (/^[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.~-]+)*$/.test(m[1]))
+            out.push(m[1]);
+    }
+    return out;
+}
+/**
+ * The package's own major, as Go spells it.
+ *
+ * v2 and up put the major in the module PATH, and the version agrees with it, so
+ * either reads the same answer. The standard library has neither and is 1: it is
+ * `go1.25.14`, and `encoding/json/v2` is a separate experimental package rather
+ * than a newer major of this one.
+ */
+function goMajor(name, version) {
+    const inPath = /\/v(\d+)$/.exec(name);
+    if (inPath)
+        return Number(inPath[1]);
+    const inVersion = /^(?:v|go)?(\d+)\./.exec(version);
+    return inVersion ? Number(inVersion[1]) : 1;
+}
+/**
+ * Keep the package the caller asked for, and only the subpackages it can reach.
+ *
+ * A Go subdirectory is a DIFFERENT importable package — `zapcore` is not reachable
+ * as `zap.X` and `ginS` is not `gin` — so walking a module's whole tree files every
+ * one of them under the parent's name and its version banner. Measured on re-run 9's
+ * cache: 71% of `encoding/json`'s chunks, 54% of zap's and 34% of gin's belonged to
+ * a package nobody asked about, and it reached retrieval — a question about
+ * registering a gin route came back with 10 `ginS` chunks of 51, in a corpus already
+ * spending 19,941 of its 24,000 bytes.
+ *
+ * The gate is the ROOT'S OWN IMPORTS, closed over: zap's `Field` is
+ * `= zapcore.Field`, so dropping `zapcore` would break the alias hop that defect 3
+ * exists to serve, and zapcore in turn reaches `buffer`. What that keeps is what a
+ * caller of this package can actually be handed; `zapgrpc`, `zaptest`, `ginS`,
+ * `httputil` and `net/http/pprof` are reachable only by importing them directly,
+ * which the tool already resolves on its own — `github.com/gin-gonic/gin/binding`
+ * asked for by path reads 0% foreign.
+ *
+ * A mismatching top-level `vN/` goes whatever the imports say. `encoding/json` is
+ * built ON `encoding/json/v2` and imports it, but v2 is a different major of the
+ * same API with the same identifiers — `Marshal`, `Unmarshal` — and half the
+ * retrieval for the commonest decode question came back from it under a
+ * `Per encoding/json@go1.25.14` header. That is `dropDeadMajors`' case, which
+ * cannot fire here because it reads the major with `/^(\d+)\./` and Go spells its
+ * versions `v1.12.0` and `go1.25.14`.
+ *
+ * A module whose root holds no Go files is not a package at all — the aws-sdk shape
+ * — and keeps everything, for the same reason `dropDeadMajors` keeps a package whose
+ * whole surface lives under one `vN/`.
+ */
+export function selectOwnPackage(files, root, name, version) {
+    const rel = (f) => path.relative(root, f).replace(/\\/g, '/');
+    const dirOf = (f) => {
+        const parts = rel(f).split('/');
+        return parts.slice(0, -1).join('/');
+    };
+    const byDir = new Map();
+    for (const f of files)
+        byDir.set(dirOf(f), [...(byDir.get(dirOf(f)) ?? []), f]);
+    if ((byDir.get('') ?? []).length === 0)
+        return [...files];
+    const major = goMajor(name, version);
+    const reachable = new Set(['']);
+    const queue = [''];
+    while (queue.length > 0) {
+        const dir = queue.shift();
+        for (const f of byDir.get(dir) ?? []) {
+            for (const imp of importsOf(safeRead(f) ?? '')) {
+                if (!imp.startsWith(`${name}/`))
+                    continue;
+                const sub = imp.slice(name.length + 1);
+                const top = /^v(\d+)$/.exec(sub.split('/')[0]);
+                if (top && Number(top[1]) !== major)
+                    continue;
+                if (reachable.has(sub) || !byDir.has(sub))
+                    continue;
+                reachable.add(sub);
+                queue.push(sub);
+            }
+        }
+    }
+    return files.filter(f => reachable.has(dirOf(f)));
+}
 /**
  * Everything below `goSurface` and the file-selection rule that feeds it, by
  * source, so a fix to either re-indexes rather than being masked by a cache hit.
  */
 export function goContentFingerprintParts() {
-    return [String(selectBuildVariants), String(holdsByDefault), String(isWantedEntry)];
+    return [
+        String(selectBuildVariants),
+        String(holdsByDefault),
+        String(isWantedEntry),
+        String(selectOwnPackage),
+        String(goMajor),
+        String(importsOf)
+    ];
 }

package/package.json

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