@mjasnikovs/pi-task 0.14.20 → 0.14.22

package/dist/remote/bridge.d.ts

@@ -65,6 +65,18 @@ export declare class SessionUI {
     private askLocal;
 }
 export declare function publishNotify(message: string, level: 'info' | 'warning' | 'error'): void;
+/**
+ * Mirror a task lifecycle notice (the kind pi-task shows on the terminal via
+ * ctx.ui.notify) to connected remote viewers. Task failures and other
+ * ctx.ui.notify calls bypass the host agent's event stream — the only thing
+ * events.ts mirrors — so without this the remote view shows nothing when a task
+ * fails completely even though the terminal flashes red.
+ *
+ * An 'error' becomes a PERSISTENT red bubble in the transcript (addError) so it
+ * survives a reconnect, matching the terminal's red text; 'warning'/'info' are a
+ * transient toast since they don't need to linger.
+ */
+export declare function publishLifecycleNotice(message: string, level: 'info' | 'warning' | 'error'): void;
 export declare function publishViewer(title: string, text: string): void;
 /**
  * Wraps an event-scoped ExtensionContext so it can be used as a command ctx

package/dist/remote/bridge.js

@@ -1,6 +1,6 @@
 import { broadcast as wsBroadcast } from './broadcast.js';
 import { pushNotify } from './push.js';
-import { setPrompt, clearPrompt } from './session-state.js';
+import { setPrompt, clearPrompt, addError } from './session-state.js';
 import { askQuestionBox } from '../task/question-box.js';
 const g = globalThis;
 export function getBridge() {
@@ -108,6 +108,23 @@ export class SessionUI {
 export function publishNotify(message, level) {
     getBridge().broadcast({ type: 'notify', message, level });
 }
+/**
+ * Mirror a task lifecycle notice (the kind pi-task shows on the terminal via
+ * ctx.ui.notify) to connected remote viewers. Task failures and other
+ * ctx.ui.notify calls bypass the host agent's event stream — the only thing
+ * events.ts mirrors — so without this the remote view shows nothing when a task
+ * fails completely even though the terminal flashes red.
+ *
+ * An 'error' becomes a PERSISTENT red bubble in the transcript (addError) so it
+ * survives a reconnect, matching the terminal's red text; 'warning'/'info' are a
+ * transient toast since they don't need to linger.
+ */
+export function publishLifecycleNotice(message, level) {
+    if (level === 'error')
+        addError(message);
+    else
+        publishNotify(message, level);
+}
 export function publishViewer(title, text) {
     getBridge().broadcast({ type: 'viewer', title, text });
 }

package/dist/task/auto-orchestrator.js

@@ -21,7 +21,7 @@ import { researchResolution, resolutionOptions, classifyResolutionAnswer } from
 import { runWorker } from '../workers/pi-worker-core.js';
 import { findPhantomImports, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { runPhaseChild, prependHint, formatLoopHint, USER_CANCELLED } from './child-runner.js';
-import { SessionUI, registerBridgeCommand } from '../remote/bridge.js';
+import { SessionUI, registerBridgeCommand, publishLifecycleNotice } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { getConfig } from '../config/config.js';
 import { startAutoLoader } from './widget.js';
@@ -621,6 +621,10 @@ export function requestAutoCancel() {
  */
 function announceDone(ctx, msg, level) {
     ctx.ui.notify(msg, level);
+    // ctx.ui.notify is terminal-only and pushNotify is a backgrounded-device web
+    // push — neither shows up in a remote viewer that's watching live. Mirror it
+    // into the session view too (errors become a persistent red bubble).
+    publishLifecycleNotice(msg, level);
     void pushNotify('Task finished', msg, 'pi-end').catch(() => { });
 }
 export async function runAutoLoop(ctx, cwd, id, deps) {

package/dist/task/failure-classifier.js

@@ -4,6 +4,7 @@
  */
 import { updateTaskFrontMatter } from './task-io.js';
 import { flashTerminalWidget } from './widget.js';
+import { publishLifecycleNotice } from '../remote/bridge.js';
 import { LoopExhaustedError, LeakedToolCallError, ModelError, USER_CANCELLED } from './child-runner.js';
 // ─── Classifier ──────────────────────────────────────────────────────────────
 export function classifyFailure(err, aborted) {
@@ -78,4 +79,7 @@ export async function handleFailure(err, ctx, cwd, id, aborted) {
     await updateTaskFrontMatter(cwd, id, { state: c.state, reason: c.reason });
     flashTerminalWidget(ctx, c.state, id, c.flash);
     ctx.ui.notify(`${id} ${c.notify}`, c.level);
+    // Mirror to remote viewers — ctx.ui.notify is terminal-only, so without this
+    // the remote view shows nothing when a task fails.
+    publishLifecycleNotice(`${id} ${c.notify}`, c.level);
 }

package/dist/task/orchestrator.d.ts

@@ -113,6 +113,16 @@ export interface RunSingleTaskOptions {
      */
     fixInstruction?: string;
 }
+/**
+ * The slice of the replacement-session context the steer loop needs.
+ * `sendUserMessage` lives on ReplacedSessionContext (not the base command ctx,
+ * and not re-exported from the package), so we narrow to just what we call.
+ */
+export type SteerCtx = ExtensionCommandContext & {
+    sendUserMessage(content: string, options?: {
+        deliverAs?: 'steer' | 'followUp';
+    }): Promise<void>;
+};
 export interface RunSingleTaskResult {
     taskId: string;
     ok: boolean;
@@ -145,6 +155,55 @@ export interface RunSingleTaskResult {
      */
     reason?: string;
 }
+/**
+ * True when the implementation turn went idle right after a context compaction —
+ * the most recent entry in the branch is a `compaction` boundary sitting after the
+ * last assistant message.
+ *
+ * A *threshold* auto-compaction (the runtime's "context is getting large" path)
+ * compacts and then deliberately does NOT auto-continue: it returns to idle and
+ * expects a manual continue (`_runAutoCompaction("threshold", false)` →
+ * `hasQueuedMessages()` is false → the agent loop stops). Our implementation wait
+ * resolves at exactly that idle. Without this check it reads as "the model
+ * finished" (the last assistant message is a normal `stop`, not `aborted`/`error`),
+ * so the run jumps straight to the verify gate and abandons a half-done task at the
+ * compaction boundary — the failure this detector closes.
+ *
+ * Position-based, not timestamp-based: the runtime APPENDS the compaction entry to
+ * the tail of the branch after the assistant message that triggered it
+ * (`appendCompaction` → `_appendEntry` push), so a `compaction` after the last
+ * assistant message means we are parked on a compaction with no continuation. A
+ * genuinely finished turn ends on an assistant message with no trailing compaction;
+ * an *overflow* compaction self-retries, so it never leaves us idle here.
+ */
+export declare function endedAtCompactionBoundary(ctx: ExtensionCommandContext): boolean;
+/**
+ * Nudge that resumes an implementation turn the runtime parked at a compaction
+ * boundary. It must let a turn that was genuinely finished (then tipped over the
+ * threshold by its own final message) confirm completion without inventing busywork
+ * — we cannot tell "paused mid-task by compaction" from "finished, then compacted"
+ * from the boundary alone, so the wording lets a done turn end in one line.
+ */
+export declare const CONTINUE_AFTER_COMPACTION: string;
+/**
+ * Safety cap on compaction-driven resumes for a single implementation turn. Each
+ * resume follows a real compaction (which only fires after the model produced a
+ * turn large enough to cross the threshold), so a legitimately large task may
+ * resume a handful of times; the cap exists only to stop a pathological loop from
+ * auto-sending forever with no user in the loop. Hitting it stops resuming and lets
+ * the verify gate / `/task-auto-resume` catch any leftover incompleteness.
+ */
+export declare const MAX_COMPACTION_RESUMES = 20;
+/**
+ * Resume an implementation turn that went idle at a threshold-compaction boundary.
+ * The runtime compacts and parks at idle without auto-continuing; we send a
+ * continue and wait again, repeating across successive compactions until the turn
+ * ends on a real assistant message (genuine completion). A user ESC takes priority
+ * (it is not a compaction boundary, and `wasInterrupted` guards the loop so the
+ * steer loop handles it), and the safety cap bounds a runaway. Returns the number
+ * of resumes performed (0 when the turn did not end on a compaction).
+ */
+export declare function resumeAcrossCompactions(ctx: SteerCtx): Promise<number>;
 /**
  * Run one prompt through the full single-task pipeline in a fresh session and
  * deliver its spec. With waitForImplementation, block until the agent finishes

package/dist/task/orchestrator.js

@@ -353,6 +353,82 @@ function implementationError(ctx) {
     }
     return undefined;
 }
+/**
+ * True when the implementation turn went idle right after a context compaction —
+ * the most recent entry in the branch is a `compaction` boundary sitting after the
+ * last assistant message.
+ *
+ * A *threshold* auto-compaction (the runtime's "context is getting large" path)
+ * compacts and then deliberately does NOT auto-continue: it returns to idle and
+ * expects a manual continue (`_runAutoCompaction("threshold", false)` →
+ * `hasQueuedMessages()` is false → the agent loop stops). Our implementation wait
+ * resolves at exactly that idle. Without this check it reads as "the model
+ * finished" (the last assistant message is a normal `stop`, not `aborted`/`error`),
+ * so the run jumps straight to the verify gate and abandons a half-done task at the
+ * compaction boundary — the failure this detector closes.
+ *
+ * Position-based, not timestamp-based: the runtime APPENDS the compaction entry to
+ * the tail of the branch after the assistant message that triggered it
+ * (`appendCompaction` → `_appendEntry` push), so a `compaction` after the last
+ * assistant message means we are parked on a compaction with no continuation. A
+ * genuinely finished turn ends on an assistant message with no trailing compaction;
+ * an *overflow* compaction self-retries, so it never leaves us idle here.
+ */
+export function endedAtCompactionBoundary(ctx) {
+    const entries = ctx.sessionManager.getEntries();
+    let lastAssistant = -1;
+    let lastCompaction = -1;
+    for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        if ('message' in e && 'role' in e.message && e.message.role === 'assistant') {
+            lastAssistant = i;
+        }
+        else if (e.type === 'compaction') {
+            lastCompaction = i;
+        }
+    }
+    return lastCompaction > lastAssistant;
+}
+/**
+ * Nudge that resumes an implementation turn the runtime parked at a compaction
+ * boundary. It must let a turn that was genuinely finished (then tipped over the
+ * threshold by its own final message) confirm completion without inventing busywork
+ * — we cannot tell "paused mid-task by compaction" from "finished, then compacted"
+ * from the boundary alone, so the wording lets a done turn end in one line.
+ */
+export const CONTINUE_AFTER_COMPACTION = 'Your context was automatically compacted. Continue implementing this task from '
+    + 'exactly where you left off, and keep going until it is fully done. If the '
+    + 'implementation is already complete, say so in one line and stop — do not invent '
+    + 'extra work or restart the task.';
+/**
+ * Safety cap on compaction-driven resumes for a single implementation turn. Each
+ * resume follows a real compaction (which only fires after the model produced a
+ * turn large enough to cross the threshold), so a legitimately large task may
+ * resume a handful of times; the cap exists only to stop a pathological loop from
+ * auto-sending forever with no user in the loop. Hitting it stops resuming and lets
+ * the verify gate / `/task-auto-resume` catch any leftover incompleteness.
+ */
+export const MAX_COMPACTION_RESUMES = 20;
+/**
+ * Resume an implementation turn that went idle at a threshold-compaction boundary.
+ * The runtime compacts and parks at idle without auto-continuing; we send a
+ * continue and wait again, repeating across successive compactions until the turn
+ * ends on a real assistant message (genuine completion). A user ESC takes priority
+ * (it is not a compaction boundary, and `wasInterrupted` guards the loop so the
+ * steer loop handles it), and the safety cap bounds a runaway. Returns the number
+ * of resumes performed (0 when the turn did not end on a compaction).
+ */
+export async function resumeAcrossCompactions(ctx) {
+    let resumes = 0;
+    while (resumes < MAX_COMPACTION_RESUMES
+        && !wasInterrupted(ctx)
+        && endedAtCompactionBoundary(ctx)) {
+        await ctx.sendUserMessage(CONTINUE_AFTER_COMPACTION);
+        await ctx.waitForIdle();
+        resumes++;
+    }
+    return resumes;
+}
 /**
  * After the implementation turn settles, honour a user ESC by letting them steer.
  *
@@ -404,6 +480,14 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                 await newCtx.sendUserMessage(spec);
                 if (opts.waitForImplementation) {
                     await newCtx.waitForIdle();
+                    // A threshold auto-compaction parks the turn at idle WITHOUT
+                    // auto-continuing (the runtime expects a manual continue). Our
+                    // single waitForIdle resolves there, so without this the run
+                    // would treat a compaction mid-task as completion and jump
+                    // straight to the verify gate. Resume across any compaction
+                    // boundaries first, so steering/error inspection below see the
+                    // turn's REAL end, not a compaction pause.
+                    await resumeAcrossCompactions(newCtx);
                     interrupted = await steerUntilDone(newCtx, opts.promptSteer);
                     // A user-declined steer (interrupted) is its own paused
                     // path; otherwise inspect how the turn actually ended.

package/package.json

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