@mjasnikovs/pi-task 0.40.26 → 0.40.27

package/dist/workers/docs-chunk.js

@@ -99,6 +99,11 @@ export function splitAtMatches(text, re) {
  * possible hallucination. Only reachable on non-ASCII text past the chunk ceiling.
  */
 export function sliceBytes(s, maxBytes) {
+    // A non-positive cap never shrinks the buffer, so the loop below runs forever.
+    // Guarded here rather than at the callers: the cap is usually computed, and the
+    // next caller to compute one must not have to rediscover this.
+    if (maxBytes <= 0)
+        return s ? [s] : [];
     const out = [];
     let buf = Buffer.from(s, 'utf8');
     while (buf.length > maxBytes) {
@@ -134,13 +139,19 @@ export function headedSlices(header, body, maxBytes) {
     const prefixed = `${header}\n${body}`;
     if (Buffer.byteLength(prefixed, 'utf8') <= maxBytes)
         return [prefixed];
-    const room = maxBytes - Buffer.byteLength(`${header}\n`, 'utf8');
-    // A header that fills the cap on its own leaves no room, and `sliceBytes` with a
-    // non-positive cap never shrinks its buffer. Slice the prefixed string instead:
-    // the first piece still names the source, which is all the header buys.
+    // The header is a LABEL, and `chunkReadme` builds it from an unbounded heading line.
+    // Left whole it starves the body: a header two bytes short of the cap turned a 200 KB
+    // section into 100,000 two-byte chunks, each re-carrying the 8 KB header. Splitting the
+    // cap evenly is the one division that needs no tuning, and a cut label still names the
+    // source.
+    const head = sliceBytes(header, Math.floor(maxBytes / 2))[0] ?? '';
+    const room = maxBytes - Buffer.byteLength(`${head}\n`, 'utf8');
+    // Only a cap of a byte or two reaches this. Slice the prefixed string and accept the
+    // degenerate result: the body pieces carry no provenance — the very defect this
+    // function exists to fix, but the alternative here is emitting nothing.
     if (room <= 0)
         return sliceBytes(prefixed, maxBytes);
-    return sliceBytes(body, room).map(slice => `${header}\n${slice}`);
+    return sliceBytes(body, room).map(slice => `${head}\n${slice}`);
 }
 /**
  * Chunk a declaration file, one chunk per declaration, each labelled with the

package/dist/workers/pi-worker-docs.d.ts

@@ -76,15 +76,6 @@ export interface PiWorkerDocsInternals {
     npmVersionLookup?: typeof defaultNpmVersionLookup;
 }
 export declare function registerPiWorkerDocs(pi: ExtensionAPI, internals?: PiWorkerDocsInternals): void;
-/**
- * The cache rule for the docs channel, as a NAMED export rather than an anonymous
- * property of an adapter literal.
- *
- * As a property of the adapter literal it would be reachable only through
- * `registerTool → execute()`, so a test would have to retype the rule and would then
- * assert against its own copy — green even after the shipped rule changed. Exported,
- * the test imports the rule it is checking.
- */
 /**
  * Did the excerpt cite a word the source never wrote?
  *
@@ -95,6 +86,15 @@ export declare function registerPiWorkerDocs(pi: ExtensionAPI, internals?: PiWor
 export declare function excerptFabricated(check: {
     absent: readonly string[];
 } | undefined): boolean;
+/**
+ * The cache rule for the docs channel, as a NAMED export rather than an anonymous
+ * property of an adapter literal.
+ *
+ * As a property of the adapter literal it would be reachable only through
+ * `registerTool → execute()`, so a test would have to retype the rule and would then
+ * assert against its own copy — green even after the shipped rule changed. Exported,
+ * the test imports the rule it is checking.
+ */
 export declare function docsCacheable(d: Pick<DocsDetails, 'typeOnly' | 'excerptVerified' | 'excerptFabricated' | 'abstained'>): boolean;
 /** The docs cache key: a package's answer is per (module, question), with the question
  *  lowercased and its whitespace collapsed so phrasing variants share one entry. Returns

package/dist/workers/pi-worker-docs.js

@@ -389,15 +389,6 @@ export function registerPiWorkerDocs(pi, internals = {}) {
         cacheable: docsCacheable
     });
 }
-/**
- * The cache rule for the docs channel, as a NAMED export rather than an anonymous
- * property of an adapter literal.
- *
- * As a property of the adapter literal it would be reachable only through
- * `registerTool → execute()`, so a test would have to retype the rule and would then
- * assert against its own copy — green even after the shipped rule changed. Exported,
- * the test imports the rule it is checking.
- */
 /**
  * Did the excerpt cite a word the source never wrote?
  *
@@ -408,6 +399,15 @@ export function registerPiWorkerDocs(pi, internals = {}) {
 export function excerptFabricated(check) {
     return check !== undefined && check.absent.length > 0;
 }
+/**
+ * The cache rule for the docs channel, as a NAMED export rather than an anonymous
+ * property of an adapter literal.
+ *
+ * As a property of the adapter literal it would be reachable only through
+ * `registerTool → execute()`, so a test would have to retype the rule and would then
+ * assert against its own copy — green even after the shipped rule changed. Exported,
+ * the test imports the rule it is checking.
+ */
 export function docsCacheable(d) {
     // Answer QUALITY only. Whether there IS an answer is `WorkerOutcome.kind`, and
     // `makeWorkerTool` has already refused an `unavailable` before reaching here —

package/dist/workers/pi-worker-fetch.d.ts

@@ -6,6 +6,8 @@ interface FetchDetails {
     answer?: string;
     excerpt?: string;
     excerptVerified?: boolean;
+    coverageMiss?: boolean;
+    anchoredSection?: string;
 }
 interface ProcLike extends EventEmitter {
     stdout: EventEmitter | null;

package/dist/workers/pi-worker-fetch.js

@@ -61,6 +61,8 @@ export function registerPiWorkerFetch(pi, internals = {}) {
                 // in the TEXT, not only in details: details are for the harness, and the
                 // worker acts on what it reads.
                 const text = result.nextStep ? `${body}\n\n${result.nextStep}` : body;
+                // Named, not inferred: `workerAnswer<T>` reads T off the literal, so a
+                // field added here would never reach the declaration the cache rules Pick from.
                 return workerAnswer(text, {
                     childExitCode: 0,
                     answer: result.answer,

package/dist/workers/shared.d.ts

@@ -99,8 +99,8 @@ export interface WorkerToolSpec<TParams extends TSchema, TDetails> {
      * the network fetch + child summariser. Return `null` to opt a particular call
      * OUT of caching (e.g. a project-source `.` lookup, whose answer the working tree
      * mutates within a run). Omit entirely and the tool is never cached. The stored
-     * key is namespaced by tool name — joined with a literal NUL, which is why the
-     * separator is invisible to `grep` and to a plain editor.
+     * key is namespaced by tool name — joined with a NUL, a byte no tool name or key
+     * can contain, so no pair of them can collide by concatenation.
      */
     cacheKey?(params: Static<TParams>): string | null;
     /**

package/package.json

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