@mjasnikovs/pi-task 0.13.19 → 0.13.21

package/dist/task/orchestrator.js

@@ -26,6 +26,7 @@ import { startWidget } from './widget.js';
 import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { parseVerifyBlock } from './spec-validation.js';
+import { titleForDisplay } from './parsers.js';
 import { formatTimings } from './timings.js';
 import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
 // ─── Module-level state ──────────────────────────────────────────────────────
@@ -132,11 +133,13 @@ export class TaskRunner {
         // Initialise or resume the TASK file.
         let id;
         let title;
+        let label;
         let resumePhase = 'refine';
         if (this._resumeId) {
             id = this._resumeId;
             const { frontMatter } = await readTaskFile(cwd, id);
             title = frontMatter.title;
+            label = frontMatter.label;
             resumePhase = frontMatter.phase;
             await updateTaskFrontMatter(cwd, id, { state: 'in_progress' });
         }
@@ -171,6 +174,7 @@ export class TaskRunner {
         // Register as active.
         this._widgetState.taskId = id;
         this._widgetState.title = title;
+        this._widgetState.label = label;
         this._widgetState.phase = resumePhase;
         this._widgetState.startedAt = this._startedAt;
         this._deps.taskId = id;
@@ -214,7 +218,7 @@ export class TaskRunner {
                 }
                 await setTaskSection(cwd, id, phase.section, out);
                 this._pc[phase.field] = out;
-                await postCommitPhase(phase, this._pc, out);
+                await postCommitPhase(phase, this._deps, this._pc, out);
             }
             // All phases done — hand off the spec.
             await advance('done');
@@ -445,7 +449,7 @@ async function handleTaskList(_args, ctx) {
         const idx = PHASE_INDEX[fm.phase];
         const phasePart = `phase ${Math.min(idx + 1, PHASE_ORDER.length)}/${PHASE_ORDER.length} ${fm.phase}`;
         const date = fm.updated_at.replace('T', ' ').slice(0, 16);
-        lines.push(`${fm.id}  ${fm.state.padEnd(12)}  ${phasePart.padEnd(24)}  ${date}  "${fm.title}"`);
+        lines.push(`${fm.id}  ${fm.state.padEnd(12)}  ${phasePart.padEnd(24)}  ${date}  "${titleForDisplay(fm)}"`);
     }
     if (lines.length === 0)
         lines.push('(no tasks in .pi-tasks/)');

package/dist/task/parsers.d.ts

@@ -35,3 +35,20 @@ export declare function parseVerifyToolingOutput(output: string): {
     }>;
 };
 export declare function deriveTitle(refined: string): string;
+/** Max characters shown for a task's display label. */
+export declare const LABEL_MAX = 72;
+/**
+ * Collapse whitespace and clamp `s` to `max` chars, cutting on a word boundary
+ * (when one falls reasonably late) and appending an ellipsis. Returns the
+ * collapsed string unchanged when it already fits.
+ */
+export declare function truncateLabel(s: string, max?: number): string;
+/**
+ * The string to show for a task: the stored short `label` when present,
+ * otherwise a truncation of the full `title`. Both paths are clamped to
+ * LABEL_MAX so a hand-edited or legacy over-long label can't blow up a line.
+ */
+export declare function titleForDisplay(task: {
+    title: string;
+    label?: string;
+}): string;

package/dist/task/parsers.js

@@ -221,3 +221,39 @@ export function deriveTitle(refined) {
     }
     return '(untitled)';
 }
+// ─── Display label ───────────────────────────────────────────────────────────
+//
+// `title` is stored in full (a refine GOAL paragraph can be 1000+ chars — see
+// the "no truncation at storage" contract in deriveTitle). These helpers shrink
+// it for status surfaces (widget head, /task list) WITHOUT touching what's
+// stored: the pipeline always reads the full title. A model-compressed `label`
+// is preferred when present (see title-label.ts); otherwise we fall back to a
+// deterministic, word-boundary truncation so a label-less task still reads
+// cleanly.
+/** Max characters shown for a task's display label. */
+export const LABEL_MAX = 72;
+/**
+ * Collapse whitespace and clamp `s` to `max` chars, cutting on a word boundary
+ * (when one falls reasonably late) and appending an ellipsis. Returns the
+ * collapsed string unchanged when it already fits.
+ */
+export function truncateLabel(s, max = LABEL_MAX) {
+    const flat = s.replace(/\s+/g, ' ').trim();
+    if (flat.length <= max)
+        return flat;
+    const slice = flat.slice(0, max - 1);
+    const lastSpace = slice.lastIndexOf(' ');
+    const cut = lastSpace > max * 0.6 ? slice.slice(0, lastSpace) : slice;
+    return cut.trimEnd() + '…';
+}
+/**
+ * The string to show for a task: the stored short `label` when present,
+ * otherwise a truncation of the full `title`. Both paths are clamped to
+ * LABEL_MAX so a hand-edited or legacy over-long label can't blow up a line.
+ */
+export function titleForDisplay(task) {
+    const label = task.label?.trim();
+    if (label)
+        return truncateLabel(label);
+    return truncateLabel(task.title);
+}

package/dist/task/phases.d.ts

@@ -40,6 +40,22 @@ export declare function phaseVerifyTooling(deps: PhaseDeps, research: string): P
 export interface PhaseResearchDeps extends ExternalContextDeps {
     getFileInventory?: (cwd: string, signal?: AbortSignal) => Promise<string>;
 }
+/**
+ * The TOOLING worker only needs to know which verification commands the task
+ * cares about — never the per-file edit list. Big refined prompts embed a long
+ * bulleted "fix these files" checklist *inside* the GOAL block; handing that to
+ * a weak local model drags it into reading/grepping source it doesn't need and
+ * it loops (TASK_0017: read(sql-adapter.ts) ×5 → loop-kill → fails the phase).
+ * So scope TOOLING's view to the GOAL prose, truncated at the first bullet.
+ *
+ * Fallbacks, in order: no bare `GOAL` header (free-form refined) → the whole
+ * refined unchanged; a GOAL block with no bullets → the full GOAL block. The
+ * GOAL boundary is the next bare ALL-CAPS header (CONSTRAINTS, KNOWN-UNKNOWNS,
+ * …) or end of text. Verified against every recorded refined prompt: the
+ * bullet-heavy failure case drops 3319→329 chars with zero source-file
+ * mentions; the rest are unchanged or only lightly trimmed.
+ */
+export declare function scopedToolingGoal(refined: string): string;
 export declare function phaseResearch(deps: PhaseDeps, refined: string, researchDeps?: PhaseResearchDeps): Promise<string>;
 export interface PhaseAutoAnswerDeps {
     docsFocused?: typeof docsFocused;
@@ -52,4 +68,4 @@ export declare function phaseCompose(deps: PhaseDeps, refined: string, research:
 export declare function phaseCritique(deps: PhaseDeps, spec: string, refined: string, qa: string): Promise<string>;
 export declare function critiqueWithFallback(d: PhaseDeps, p: PhaseContext): Promise<string>;
 export declare const PHASES: PhaseConfig[];
-export declare function postCommitPhase(phase: PhaseConfig, pc: PhaseContext, out: string): Promise<void>;
+export declare function postCommitPhase(phase: PhaseConfig, deps: PhaseDeps, pc: PhaseContext, out: string): Promise<void>;

package/dist/task/phases.js

@@ -12,10 +12,11 @@ import { getFileInventory } from './file-inventory.js';
 import { formatServiceBlock, formatFreshnessSkippedBlock } from './service-blocks.js';
 import { gatherExternalContext } from './external-context.js';
 import { REFINE_PROMPT, RESEARCH_FILES_PROMPT, RESEARCH_APIS_PROMPT, RESEARCH_CONTEXT_PROMPT, RESEARCH_TOOLING_PROMPT, GRILL_GEN_PROMPT, GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT, COMPOSE_PROMPT, CRITIQUE_PROMPT, CRITIQUE_TRIAGE_PROMPT, VERIFY_TOOLING_PROMPT, MAX_GRILL_QUESTIONS, appendNoThink } from './prompts.js';
-import { setTaskSection, updateTaskFrontMatter } from './task-io.js';
+import { readSection, removeTaskSection, setTaskSection, updateTaskFrontMatter } from './task-io.js';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
 import { parseGrillQuestions, parseAutoAnswer, autoAnswerHasTag, parseVerifyToolingOutput, deriveTitle } from './parsers.js';
+import { compressTitle } from './title-label.js';
 import { parseVerifyBlock, validateSpecShape, stripSpecPreamble, isCritiqueClean } from './spec-validation.js';
 import { runPhaseChild, runPhaseWithLoopGuard, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
 import { SessionUI } from '../remote/bridge.js';
@@ -78,6 +79,68 @@ export async function phaseVerifyTooling(deps, research) {
     return replaceToolingWithVerified(research, parsed.verified);
 }
 const DOCS_EXTENSION_PATH = new URL('../workers/docs-extension.js', import.meta.url).pathname;
+/**
+ * Task-file heading under which a research worker's validated output is cached.
+ * A resumed research phase reads these to skip workers that already succeeded,
+ * instead of re-running all four from scratch when one of them fails — the
+ * expensive case (e.g. 3 healthy workers thrown away because the 4th looped).
+ */
+function researchWorkerCacheHeading(section) {
+    return `research worker ${section}`;
+}
+/**
+ * The TOOLING worker only needs to know which verification commands the task
+ * cares about — never the per-file edit list. Big refined prompts embed a long
+ * bulleted "fix these files" checklist *inside* the GOAL block; handing that to
+ * a weak local model drags it into reading/grepping source it doesn't need and
+ * it loops (TASK_0017: read(sql-adapter.ts) ×5 → loop-kill → fails the phase).
+ * So scope TOOLING's view to the GOAL prose, truncated at the first bullet.
+ *
+ * Fallbacks, in order: no bare `GOAL` header (free-form refined) → the whole
+ * refined unchanged; a GOAL block with no bullets → the full GOAL block. The
+ * GOAL boundary is the next bare ALL-CAPS header (CONSTRAINTS, KNOWN-UNKNOWNS,
+ * …) or end of text. Verified against every recorded refined prompt: the
+ * bullet-heavy failure case drops 3319→329 chars with zero source-file
+ * mentions; the rest are unchanged or only lightly trimmed.
+ */
+export function scopedToolingGoal(refined) {
+    const m = /^GOAL[ \t]*\n([\s\S]*?)(?=\n[A-Z][A-Z][A-Z -]*[ \t]*\n|$(?![\s\S]))/m.exec(refined);
+    if (!m)
+        return refined;
+    const goal = m[1].trim();
+    const firstBullet = goal.search(/\n[ \t]*[-*]\s/);
+    return firstBullet === -1 ? goal : goal.slice(0, firstBullet).trim();
+}
+/**
+ * Throw a descriptive error if a research worker's result is not trustworthy
+ * output, so only good output is ever cached and assembled. Precedence mirrors
+ * the original inline checks: loop/timeout exhaustion first (a loop-kill is a
+ * SIGTERM/exit 143 OR a clean exit 0 with partial text, so exitCode alone is
+ * ambiguous — the worker already burned its MAX_LOOP_RESTARTS restarts before
+ * setting these), then exit code, empty output, and finally a leaked
+ * (never-executed) tool call.
+ */
+function assertResearchWorkerOk(name, result) {
+    if (result.loopHit) {
+        const argsStr = JSON.stringify(result.loopHit.call.args);
+        throw new Error(`Research ${name} worker stuck in a loop — called `
+            + `${result.loopHit.call.name}(${argsStr}) ×${result.loopHit.count} in the last `
+            + `${result.loopHit.windowSize} calls and still looped after restarts`);
+    }
+    if (result.timedOut) {
+        throw new Error(`Research ${name} worker timed out after restarts`);
+    }
+    if (result.exitCode !== 0) {
+        throw new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`);
+    }
+    if (result.text.trim().length === 0) {
+        throw new Error(`Research ${name} worker produced no output`);
+    }
+    if (result.leakedToolCall) {
+        throw new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
+            + `(${result.leakedToolCall.trim()}) — it never ran`);
+    }
+}
 export async function phaseResearch(deps, refined, researchDeps = {}) {
     const fileInventoryFn = researchDeps.getFileInventory ?? getFileInventory;
     const externalContext = await gatherExternalContext(refined, deps, researchDeps);
@@ -151,11 +214,27 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
         {
             section: 'TOOLING',
             label: 'worker:tooling',
-            prompt: appendNoThink(promptHeader + RESEARCH_TOOLING_PROMPT(refined))
+            // Scope to the goal prose only — not the per-file edit checklist that
+            // makes a weak model spelunk source and loop. See scopedToolingGoal.
+            prompt: appendNoThink(promptHeader + RESEARCH_TOOLING_PROMPT(scopedToolingGoal(refined)))
         }
     ];
-    const workerResults = [];
+    // Run workers one at a time, persisting each worker's validated output the
+    // moment it succeeds. On a resume, a worker whose cached output is already on
+    // disk is skipped — so when one worker fails and the phase is re-run, the
+    // others don't burn minutes regenerating work that was already good. Each
+    // worker is validated inline (not in a second pass) so a failure throws
+    // before later workers run, and only trustworthy text is ever cached.
+    const sections = [];
     for (const spec of workerSpecs) {
+        const cacheHeading = researchWorkerCacheHeading(spec.section);
+        const cached = (await readSection(deps.cwd, deps.taskId, cacheHeading)) ?? '';
+        if (cached.trim().length > 0) {
+            deps.logDebug?.(`${spec.label}: cached — skipping re-run`);
+            updateProgress();
+            sections.push({ name: spec.section, text: cached.trim() });
+            continue;
+        }
         deps.logDebug?.(`${spec.label}: start`);
         const r = await recordWorker(spec.label, runWorker({
             prompt: spec.prompt,
@@ -173,39 +252,20 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             + (r.stderr ? ` stderr=${r.stderr.slice(0, 300)}` : '')
             + (r.leakedToolCall ? ` leaked=${r.leakedToolCall.trim().slice(0, 80)}` : ''));
         updateProgress();
-        workerResults.push(r);
+        // Throws (failing the phase) on a loop/timeout/exit/empty/leak — so the
+        // workers that already succeeded above stay cached for the resume.
+        assertResearchWorkerOk(spec.section, r);
+        await setTaskSection(deps.cwd, deps.taskId, cacheHeading, r.text);
+        sections.push({ name: spec.section, text: r.text.trim() });
     }
-    // Validate + assemble by mapping spec.section over the results, so adding or
-    // reordering a worker is a single edit to workerSpecs (the result order
-    // mirrors workerSpecs order — the loop above pushes in sequence).
-    const sections = workerSpecs.map((spec, i) => ({ name: spec.section, result: workerResults[i] }));
-    for (const { name, result } of sections) {
-        // Loop/timeout exhaustion is checked before the generic exit-code branch:
-        // a loop-kill arrives as a SIGTERM (exit 143) AND sometimes as a clean
-        // exit 0 with partial text, so keying off exitCode alone would either give
-        // a useless "exit 143" message or silently accept truncated output. The
-        // worker already burned its MAX_LOOP_RESTARTS restarts before setting these.
-        if (result.loopHit) {
-            const argsStr = JSON.stringify(result.loopHit.call.args);
-            throw new Error(`Research ${name} worker stuck in a loop — called `
-                + `${result.loopHit.call.name}(${argsStr}) ×${result.loopHit.count} in the last `
-                + `${result.loopHit.windowSize} calls and still looped after restarts`);
-        }
-        if (result.timedOut) {
-            throw new Error(`Research ${name} worker timed out after restarts`);
-        }
-        if (result.exitCode !== 0) {
-            throw new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`);
-        }
-        if (result.text.trim().length === 0) {
-            throw new Error(`Research ${name} worker produced no output`);
-        }
-        if (result.leakedToolCall) {
-            throw new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
-                + `(${result.leakedToolCall.trim()}) — it never ran`);
-        }
+    // All workers succeeded — the assembled output below becomes the canonical
+    // 'research' section (written by the orchestrator). The per-worker caches
+    // exist only to survive a mid-phase failure, so drop them now to avoid
+    // carrying every section twice in the task file.
+    for (const spec of workerSpecs) {
+        await removeTaskSection(deps.cwd, deps.taskId, researchWorkerCacheHeading(spec.section));
     }
-    return sections.map(({ name, result }) => `${name}\n${result.text}`).join('\n\n');
+    return sections.map(({ name, text }) => `${name}\n${text}`).join('\n\n');
 }
 export async function phaseAutoAnswer(deps, refined, research, question, autoDeps = {}) {
     const docsFocusedFn = autoDeps.docsFocused ?? docsFocused;
@@ -527,10 +587,16 @@ export const PHASES = [
     },
     { name: 'critique', section: 'spec', field: 'spec', run: critiqueWithFallback }
 ];
-export async function postCommitPhase(phase, pc, out) {
+export async function postCommitPhase(phase, deps, pc, out) {
     if (phase.name !== 'refine')
         return;
     const title = deriveTitle(out);
     pc.widgetState.title = title;
+    // Compress the (often paragraph-long) title into a short display label. This
+    // is best-effort and self-falls-back to a truncation, so it never blocks the
+    // pipeline — but persist title first so a label failure can't lose the title.
     await updateTaskFrontMatter(pc.cwd, pc.id, { title });
+    const label = await compressTitle(deps, title);
+    pc.widgetState.label = label;
+    await updateTaskFrontMatter(pc.cwd, pc.id, { label });
 }

package/dist/task/prompts.d.ts

@@ -28,6 +28,13 @@ export declare const MAX_GRILL_QUESTIONS = 20;
 export declare const NO_THINK = "/no_think";
 /** Append the Qwen3 `/no_think` soft switch to a prompt. See {@link NO_THINK}. */
 export declare function appendNoThink(prompt: string): string;
+/**
+ * Compress a verbose task title into a short status-bar label. Pure judgment, no
+ * tools — the child reads only the title we hand it. The output is sanitised and
+ * length-clamped by the caller (title-label.ts), so the prompt optimises for the
+ * right *content* (identifying nouns) rather than trusting the model on length.
+ */
+export declare const COMPRESS_LABEL_PROMPT: (title: string, maxChars: number) => string;
 declare const REFINE_PROMPT: (raw: string) => string;
 declare const RESEARCH_READ_ONLY_CONSTRAINT = "IMPORTANT: You are ONLY allowed to READ. Do NOT create, modify, or delete any files. Use the read, grep, find, and ls tools to inspect the repo.";
 declare const RESEARCH_FILES_PROMPT: (refined: string) => string;

package/dist/task/prompts.js

@@ -33,6 +33,22 @@ export const NO_THINK = '/no_think';
 export function appendNoThink(prompt) {
     return `${prompt}\n\n${NO_THINK}`;
 }
+/**
+ * Compress a verbose task title into a short status-bar label. Pure judgment, no
+ * tools — the child reads only the title we hand it. The output is sanitised and
+ * length-clamped by the caller (title-label.ts), so the prompt optimises for the
+ * right *content* (identifying nouns) rather than trusting the model on length.
+ */
+export const COMPRESS_LABEL_PROMPT = (title, maxChars) => `Shorten the following task title into a brief label for a one-line status display.
+
+Rules:
+- Output ONLY the label text. No preamble, no quotes, no markdown, no trailing period.
+- One line, at most ${maxChars} characters.
+- Keep the most identifying nouns: the component, file, feature, or domain names.
+- Drop filler, constraints, verbatim file lists, and any "spec: @..." reference.
+
+TITLE:
+${title}`;
 const REFINE_PROMPT = (raw) => `You receive a user's task description for an AI coding agent. Rewrite it to be unambiguous and actionable.
 
 Output structure (four sections, exact headings, in this order):

package/dist/task/task-io.d.ts

@@ -17,3 +17,5 @@ export declare function writeTaskFile(cwd: string, fm: TaskFrontMatter, body: st
 export declare function updateTaskFrontMatter(cwd: string, id: string, patch: Partial<TaskFrontMatter>): Promise<void>;
 export declare function readSection(cwd: string, id: string, heading: string): Promise<string | null>;
 export declare function setTaskSection(cwd: string, id: string, heading: string, content: string): Promise<void>;
+/** Remove a section (heading + body) if present; a no-op when it's absent. */
+export declare function removeTaskSection(cwd: string, id: string, heading: string): Promise<void>;

package/dist/task/task-io.js

@@ -76,3 +76,12 @@ export async function setTaskSection(cwd, id, heading, content) {
     }
     await writeTaskFile(cwd, { ...frontMatter, updated_at: new Date().toISOString() }, next);
 }
+/** Remove a section (heading + body) if present; a no-op when it's absent. */
+export async function removeTaskSection(cwd, id, heading) {
+    const { frontMatter, body } = await readTaskFile(cwd, id);
+    const re = sectionRegex(heading);
+    if (!re.test(body))
+        return;
+    const next = body.replace(re, '');
+    await writeTaskFile(cwd, { ...frontMatter, updated_at: new Date().toISOString() }, next);
+}

package/dist/task/task-parsers.js

@@ -12,6 +12,7 @@ const FRONT_MATTER_KEYS = [
     'created_at',
     'updated_at',
     'title',
+    'label',
     'reason'
 ];
 // ─── Front matter ────────────────────────────────────────────────────────────
@@ -20,7 +21,9 @@ export function emitFrontMatter(fm) {
     for (const k of FRONT_MATTER_KEYS) {
         const v = fm[k];
         if (v === undefined || v === '') {
-            if (k === 'reason')
+            // Optional fields are omitted entirely when empty rather than emitted
+            // as a blank `key:` line.
+            if (k === 'reason' || k === 'label')
                 continue;
         }
         lines.push(`${k}: ${typeof v === 'string' ? v : String(v)}`);
@@ -50,6 +53,7 @@ export function parseFrontMatter(content) {
         created_at: obj.created_at,
         updated_at: obj.updated_at ?? obj.created_at,
         title: obj.title ?? '',
+        label: obj.label || undefined,
         reason: obj.reason || undefined
     };
 }

package/dist/task/task-types.d.ts

@@ -13,6 +13,13 @@ export interface TaskFrontMatter {
     created_at: string;
     updated_at: string;
     title: string;
+    /**
+     * Short, human-readable display label compressed from `title`. Visual only —
+     * `title` always holds the full text the pipeline reads. Absent on pre-label
+     * tasks and on small tasks whose title is already short; display falls back to
+     * a deterministic truncation of `title` when missing. See title-label.ts.
+     */
+    label?: string;
     reason?: string;
 }
 export declare const PHASE_ORDER: PhaseName[];

package/dist/task/title-label.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Display-label compression.
+ *
+ * A refined GOAL paragraph becomes the stored `title`, which the pipeline reads
+ * in full — but it can run to 1000+ characters, which makes the widget head and
+ * `/task list` unreadable. `compressTitle` spawns a tool-less local-model child
+ * to distill that title into a short, identifying label that we store ALONGSIDE
+ * (never replacing) the full title, purely for display. Every failure mode —
+ * model error, empty output, leaked tool call, abort, an over-long answer —
+ * degrades to the deterministic `truncateLabel`, so a label always comes back
+ * and the pipeline never blocks on this best-effort step.
+ */
+import type { PhaseDeps } from './child-runner.js';
+/**
+ * Reduce a raw model completion to a single clean label line: first non-empty
+ * line, stripped of surrounding quotes/backticks and a leading "label:" echo,
+ * whitespace collapsed. Returns '' when nothing usable remains.
+ */
+export declare function sanitizeLabel(raw: string): string;
+/**
+ * Compress `title` into a short display label via a local-model child. Always
+ * resolves (never throws): on any failure it returns `truncateLabel(title)`.
+ * The returned label is guaranteed to be at most LABEL_MAX characters.
+ */
+export declare function compressTitle(deps: PhaseDeps, title: string): Promise<string>;

package/dist/task/title-label.js

@@ -0,0 +1,51 @@
+/**
+ * Display-label compression.
+ *
+ * A refined GOAL paragraph becomes the stored `title`, which the pipeline reads
+ * in full — but it can run to 1000+ characters, which makes the widget head and
+ * `/task list` unreadable. `compressTitle` spawns a tool-less local-model child
+ * to distill that title into a short, identifying label that we store ALONGSIDE
+ * (never replacing) the full title, purely for display. Every failure mode —
+ * model error, empty output, leaked tool call, abort, an over-long answer —
+ * degrades to the deterministic `truncateLabel`, so a label always comes back
+ * and the pipeline never blocks on this best-effort step.
+ */
+import { runPhaseChild } from './child-runner.js';
+import { LABEL_MAX, truncateLabel } from './parsers.js';
+import { COMPRESS_LABEL_PROMPT, appendNoThink } from './prompts.js';
+/**
+ * Reduce a raw model completion to a single clean label line: first non-empty
+ * line, stripped of surrounding quotes/backticks and a leading "label:" echo,
+ * whitespace collapsed. Returns '' when nothing usable remains.
+ */
+export function sanitizeLabel(raw) {
+    const firstLine = raw.split('\n').find(l => l.trim().length > 0) ?? '';
+    return firstLine
+        .replace(/^\s*label\s*:\s*/i, '')
+        .replace(/^["'`]+|["'`]+$/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Compress `title` into a short display label via a local-model child. Always
+ * resolves (never throws): on any failure it returns `truncateLabel(title)`.
+ * The returned label is guaranteed to be at most LABEL_MAX characters.
+ */
+export async function compressTitle(deps, title) {
+    const fallback = truncateLabel(title);
+    // Already short enough — no point paying for a model call.
+    if (title.replace(/\s+/g, ' ').trim().length <= LABEL_MAX)
+        return fallback;
+    try {
+        const raw = await runPhaseChild(deps, 'compress-label', '', appendNoThink(COMPRESS_LABEL_PROMPT(title, LABEL_MAX)));
+        const cleaned = sanitizeLabel(raw);
+        if (cleaned.length === 0)
+            return fallback;
+        // Clamp regardless of what the model returned; truncateLabel is a no-op
+        // when it already fits.
+        return truncateLabel(cleaned);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/task/widget.d.ts

@@ -9,6 +9,8 @@ import { type PhaseName, type TaskState } from './task-types.js';
 export interface WidgetState {
     taskId: string;
     title: string;
+    /** Short display label compressed from `title`; falls back to a truncation when absent. */
+    label?: string;
     phase: PhaseName;
     startedAt: number;
     lastLine?: string;

package/dist/task/widget.js

@@ -5,6 +5,7 @@
  * context usage, and the latest child-process line.
  */
 import { PHASE_INDEX, PHASE_ORDER } from './task-types.js';
+import { titleForDisplay } from './parsers.js';
 import { setTaskWidget } from '../remote/session-state.js';
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const WIDGET_KEY = 'pi-tasks';
@@ -71,7 +72,7 @@ function lastLineTrailer(lastLine, theme) {
 }
 export function buildWidgetLines(s, theme) {
     const elapsed = formatDuration(Date.now() - s.startedAt);
-    const head = `${s.taskId} · ${s.title}`;
+    const head = `${s.taskId} · ${titleForDisplay(s)}`;
     const idx = PHASE_INDEX[s.phase];
     const total = PHASE_ORDER.length;
     const stepNum = Math.min(idx + 1, total);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.13.19",
+    "version": "0.13.21",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",