@mjasnikovs/pi-task 0.29.3 → 0.31.0

package/dist/task/widget.js

@@ -143,7 +143,7 @@ export function startWidget(ctx, getState) {
 }
 export function buildAutoLoaderLines(s, theme) {
     const elapsed = formatDuration(Date.now() - s.startedAt);
-    const head = `/task-auto · ${s.title}`;
+    const head = `${s.command ?? '/task-auto'} · ${s.title}`;
     let detail = s.kind === 'enforce' ? `enforcing guidelines · ${elapsed}`
         : s.kind === 'verify' ? `verifying work · ${elapsed}`
             : s.kind === 'recommend' ? `assessing the failure · ${elapsed}`
@@ -171,7 +171,7 @@ export function buildAutoLoaderData(s) {
                     : s.kind === 'final-fix' ? 'fixing the final gate'
                         : s.step;
     const d = {
-        title: `/task-auto · ${s.title}`,
+        title: `${s.command ?? '/task-auto'} · ${s.title}`,
         phase,
         elapsed: formatDuration(Date.now() - s.startedAt)
     };

package/dist/task/write-guard.d.ts

@@ -54,6 +54,48 @@ export declare function parseNameStatusChanges(nameStatus: string): TreeChangeSu
  * destroyed a sibling task's verified deliverable.
  */
 export declare function findForbiddenDeletions(changes: TreeChangeSummary): string[];
+/** Why an ignored path is (or is not) something the gate may rule on. */
+export type IgnoredClass = 'build-output' | 'dep-dir' | 'task-dir' | 'vcs-meta' | 'actionable';
+/**
+ * Classify one repo-relative ignored path. `outdirs` are build output directories
+ * parsed from the project's own build commands. Only `actionable` may produce a
+ * finding — everything else is reproducible from the repository by running the
+ * project's own tooling, which is exactly what makes it not a gate concern.
+ */
+export declare function classifyIgnoredPath(rel: string, outdirs: string[]): IgnoredClass;
+/** The ignored paths a gate may rule on: everything not exempt by mechanism. */
+export declare function findActionableIgnoredWrites(paths: string[], outdirs: string[]): string[];
+/**
+ * A fingerprint per ignored path (`mtimeMs:size`, or a marker for a directory),
+ * taken before and after a write-capable child so a write is ATTRIBUTED to that
+ * child rather than to the tree's pre-existing state. Ignored files are untracked,
+ * so git cannot tell "changed" from "was always there" — only the snapshot can.
+ */
+export type IgnoredSnapshot = Record<string, string>;
+/**
+ * Paths whose fingerprint appeared or changed across the child's window. Pure, so
+ * the attribution rule is unit-testable without a repo.
+ */
+export declare function diffIgnoredSnapshots(before: IgnoredSnapshot, after: IgnoredSnapshot): string[];
+/**
+ * The gate-trail line. PATH NAMES ONLY: the contents of an ignored file are never
+ * read into a log, a debt reason or a child prompt (`.env` is the canonical case —
+ * this channel exists because of a file full of credentials).
+ */
+export declare function ignoredWriteTrailLine(paths: string[]): string;
+/**
+ * The durable debt reason for the same event. Path names only, same rule.
+ *
+ * The wording tracks what was actually PROVEN. `dependent === true` is the probe's
+ * answer that the gate does not pass without these files; `undefined` is an
+ * unanswered probe (the attempt never converged, or the probe could not run), which
+ * is still worth carrying because the file is on disk and can green a LATER attempt.
+ * A debt that overstates its evidence is the same defect this whole channel exists
+ * to fix, one level up.
+ */
+export declare function ignoredWriteDebtReason(paths: string[], dependent?: boolean): string;
+/** The UNOBSERVED note that replaces such a PASS. Path names only, same rule. */
+export declare function ignoredWriteUnobservedNote(paths: string[]): string;
 /**
  * One-line summary for the gate debug log — the diff capture every write-capable
  * child gets so "what did this pass change" is answerable from artifacts (the

package/dist/task/write-guard.js

@@ -132,6 +132,114 @@ export function findForbiddenDeletions(changes) {
     const addedNames = new Set(changes.added.map(basename));
     return changes.deleted.filter(p => !addedNames.has(basename(p)));
 }
+/**
+ * Directory names that are build output or a dependency tree by convention. The
+ * parsed outdirs (see classifyIgnoredPath's `outdirs`) come from the project's
+ * own tooling and are the primary mechanism; this list is the fallback for
+ * projects whose build is not declared in a package.json (CMake, cargo, gradle).
+ */
+const BUILD_DIR_NAMES = new Set([
+    'node_modules',
+    'dist',
+    'build',
+    'target',
+    'out',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.turbo',
+    '.cache',
+    '.parcel-cache',
+    '.vite',
+    '.gradle',
+    '__pycache__',
+    '.pytest_cache',
+    '.venv',
+    'venv'
+]);
+/**
+ * Classify one repo-relative ignored path. `outdirs` are build output directories
+ * parsed from the project's own build commands. Only `actionable` may produce a
+ * finding — everything else is reproducible from the repository by running the
+ * project's own tooling, which is exactly what makes it not a gate concern.
+ */
+export function classifyIgnoredPath(rel, outdirs) {
+    const segs = rel
+        .replace(/^\.\//, '')
+        .split('/')
+        .filter(s => s.length > 0);
+    if (segs.length === 0)
+        return 'actionable';
+    if (segs.includes('.pi-tasks'))
+        return 'task-dir';
+    if (segs.includes('.git'))
+        return 'vcs-meta';
+    if (segs.includes('node_modules'))
+        return 'dep-dir';
+    for (const o of outdirs) {
+        const oSegs = o
+            .replace(/^\.\//, '')
+            .split('/')
+            .filter(s => s.length > 0);
+        if (oSegs.length > 0 && oSegs.every((s, i) => segs[i] === s))
+            return 'build-output';
+    }
+    if (segs.some(s => BUILD_DIR_NAMES.has(s)))
+        return 'build-output';
+    return 'actionable';
+}
+/** The ignored paths a gate may rule on: everything not exempt by mechanism. */
+export function findActionableIgnoredWrites(paths, outdirs) {
+    return paths.filter(p => classifyIgnoredPath(p, outdirs) === 'actionable');
+}
+/**
+ * Paths whose fingerprint appeared or changed across the child's window. Pure, so
+ * the attribution rule is unit-testable without a repo.
+ */
+export function diffIgnoredSnapshots(before, after) {
+    const out = [];
+    for (const [p, fp] of Object.entries(after)) {
+        if (before[p] !== fp)
+            out.push(p);
+    }
+    return out.sort();
+}
+/**
+ * The gate-trail line. PATH NAMES ONLY: the contents of an ignored file are never
+ * read into a log, a debt reason or a child prompt (`.env` is the canonical case —
+ * this channel exists because of a file full of credentials).
+ */
+export function ignoredWriteTrailLine(paths) {
+    return (`final-gate: fix pass modified IGNORED path(s) — ${paths.join(', ')}; `
+        + 'these are NOT committed and NOT reproducible from the repository');
+}
+/**
+ * The durable debt reason for the same event. Path names only, same rule.
+ *
+ * The wording tracks what was actually PROVEN. `dependent === true` is the probe's
+ * answer that the gate does not pass without these files; `undefined` is an
+ * unanswered probe (the attempt never converged, or the probe could not run), which
+ * is still worth carrying because the file is on disk and can green a LATER attempt.
+ * A debt that overstates its evidence is the same defect this whole channel exists
+ * to fix, one level up.
+ */
+export function ignoredWriteDebtReason(paths, dependent) {
+    const head = dependent === true ?
+        `final-gate PASS depended on gitignored file(s) the run wrote and cannot ship: ${paths.join(', ')}. `
+            + 'A fresh clone does NOT have them, so the checks that passed here cannot be reproduced. '
+        : `the final-gate fix pass wrote gitignored file(s) that are NOT in the commit: ${paths.join(', ')}. `
+            + 'Whether the gate needs them was not established, so a fresh clone may not reproduce this run. ';
+    return (head
+        + 'The durable fix is a TRACKED counterpart (e.g. .env.example) or a check that '
+        + 'does not need the file — never committing the ignored file itself.');
+}
+/** The UNOBSERVED note that replaces such a PASS. Path names only, same rule. */
+export function ignoredWriteUnobservedNote(paths) {
+    return (`UNOBSERVED — NOT a pass: the gate's checks passed only with gitignored file(s) `
+        + `this run wrote (${paths.join(', ')}), which are not in the commit; re-running `
+        + 'them without those files FAILS, so no reproducible evidence was produced.');
+}
 /**
  * One-line summary for the gate debug log — the diff capture every write-capable
  * child gets so "what did this pass change" is answerable from artifacts (the

package/package.json

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