@timurproko/a1 0.1.8-dev.459 → 0.1.8-dev.467

package/dist/contracts/owned-ui/model.d.ts

@@ -126,6 +126,8 @@ export interface OwnedUiFooterView {
 export interface OwnedUiStatusView {
     readonly title: string;
     readonly workingMessage: string | null;
+    /** Estimated progress of the shown work state as an integer percent below 100, when the engine can measure it. */
+    readonly workingProgress?: number | null;
     readonly diagnostics: readonly string[];
     readonly badges: readonly string[];
     readonly usage?: OwnedUiUsageView;

package/dist/contracts/owned-ui/validation.js

@@ -347,6 +347,9 @@ export function assertOwnedUiEditorState(editor) {
 export function assertOwnedUiStatusView(status) {
     assertBoundedText(status.title, "owned-UI status title", MAX_LABEL_LENGTH);
     assertOptionalText(status.workingMessage, "owned-UI working message", MAX_MESSAGE_LENGTH);
+    if (status.workingProgress !== undefined && status.workingProgress !== null) {
+        assertIntegerInRange(status.workingProgress, 0, 99, "owned-UI working progress");
+    }
     assertCollection(status.diagnostics, "owned-UI status diagnostics", MAX_STATUS_DIAGNOSTICS);
     for (const diagnostic of status.diagnostics) {
         assertBoundedText(diagnostic, "owned-UI status diagnostic", MAX_MESSAGE_LENGTH);

package/dist/integrations/pi/components/shell-footer-status.js

@@ -75,19 +75,29 @@ export function createPiShellStatus(view, formatProgressStatus, runtime) {
     const statusUi = createTuiFacade(runtime ?? { getColumns: () => 80, getRows: () => 24, requestRender() { } });
     let workingOverride;
     let outputPad = PINNED_PI_LAYOUT.outputPad;
+    let progressPresentation = "pinned";
     let placement = statusPlacement(view, workingOverride);
-    let component = statusComponent(view, statusUi, workingOverride, outputPad, formatProgressStatus, placement);
-    let signature = statusSignature(view, workingOverride, outputPad, placement);
+    const liveStatusText = () => formatProgressStatus(liveWorkingText(view, workingOverride, progressPresentation));
+    let component = statusComponent(view, statusUi, outputPad, liveStatusText, placement);
+    let signature = statusSignature(view, workingOverride, outputPad, placement, progressPresentation);
     const rebuild = () => {
         const nextPlacement = statusPlacement(view, workingOverride);
-        const nextSignature = statusSignature(view, workingOverride, outputPad, nextPlacement);
+        const nextSignature = statusSignature(view, workingOverride, outputPad, nextPlacement, progressPresentation);
         if (nextSignature === signature)
             return;
+        // Performance: progress ticks change only the live message; the spinner keeps its frame and timer.
+        if (placement === "live" && nextPlacement === "live" && component instanceof WorkingStatusIndicator
+            && statusSignature(view, workingOverride, outputPad, nextPlacement, progressPresentation, false)
+                === statusSignature(view, workingOverride, outputPad, placement, progressPresentation, false)) {
+            component.setMessage(liveStatusText());
+            signature = nextSignature;
+            return;
+        }
         if (component !== undefined && "dispose" in component && typeof component.dispose === "function")
             component.dispose();
         placement = nextPlacement;
         signature = nextSignature;
-        component = statusComponent(view, statusUi, workingOverride, outputPad, formatProgressStatus, placement);
+        component = statusComponent(view, statusUi, outputPad, liveStatusText, placement);
     };
     return {
         render: width => component?.render(width) ?? [],
@@ -107,6 +117,10 @@ export function createPiShellStatus(view, formatProgressStatus, runtime) {
             outputPad = padding;
             rebuild();
         },
+        setProgressPresentation(presentation) {
+            progressPresentation = presentation;
+            rebuild();
+        },
         dispose() {
             if (component !== undefined && "dispose" in component && typeof component.dispose === "function")
                 component.dispose();
@@ -145,9 +159,18 @@ function statusPlacement(view, workingOverride) {
         return "dock";
     return view.status.workingMessage === null ? "hidden" : "dock";
 }
-function statusComponent(view, ui, workingOverride, outputPad, formatProgressStatus, placement) {
+// Rationale: the engine publishes the semantic working word and a separate measured percent; bare A1
+// composes them here, while the pinned route keeps the bare word for comparison with Pi.
+function liveWorkingText(view, workingOverride, progressPresentation) {
+    const message = workingOverride ?? view.status.workingMessage ?? "Working";
+    const progress = view.status.workingProgress;
+    return workingOverride === undefined && progressPresentation === "custom-viewport" && typeof progress === "number"
+        ? `${message} (${progress}%)`
+        : message;
+}
+function statusComponent(view, ui, outputPad, liveStatusText, placement) {
     if (placement === "live") {
-        return new WorkingStatusIndicator(ui, formatProgressStatus(workingOverride ?? view.status.workingMessage ?? "Working"));
+        return new WorkingStatusIndicator(ui, liveStatusText());
     }
     if (placement === "dock") {
         if (view.lifecycle === "failed") {
@@ -157,8 +180,9 @@ function statusComponent(view, ui, workingOverride, outputPad, formatProgressSta
     }
     return undefined;
 }
-function statusSignature(view, workingOverride, outputPad, placement) {
-    return `${placement}\u0000${outputPad}\u0000${view.lifecycle}\u0000${workingOverride ?? ""}\u0000${view.status.workingMessage ?? ""}\u0000${view.status.diagnostics.at(-1) ?? ""}`;
+function statusSignature(view, workingOverride, outputPad, placement, progressPresentation, withMessage = true) {
+    const message = withMessage ? `${workingOverride ?? ""}\u0000${view.status.workingMessage ?? ""}\u0000${view.status.workingProgress ?? ""}` : "";
+    return `${placement}\u0000${outputPad}\u0000${view.lifecycle}\u0000${progressPresentation}\u0000${message}\u0000${view.status.diagnostics.at(-1) ?? ""}`;
 }
 function queuedInputText(submissions, presentation) {
     if (submissions.length === 0)

package/dist/integrations/pi/components/shell-shared-facade.d.ts

@@ -79,6 +79,8 @@ export type PiShellStatusPlacement = "live" | "dock" | "hidden";
 export interface PiShellStatusPort extends PiShellViewComponentPort {
     setWorkingOverride(message: string | undefined): void;
     setOutputPad(padding: 0 | 1): void;
+    /** Bare A1 shows engine-measured progress beside the working word; the pinned route keeps the bare word. */
+    setProgressPresentation(presentation: "pinned" | "custom-viewport"): void;
     /** Semantic row placement; callers must not inspect rendered text. */
     placement(): PiShellStatusPlacement;
     renderDock(width: number): readonly string[];

package/dist/integrations/pi/engine/adapter.js

@@ -14,6 +14,7 @@ import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACK
 import { PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "./workflows.js";
 import { createPiRuntimeIntegration } from "./runtime-integration.js";
 import { PiSessionCommandIntegration } from "./session-integration.js";
+import { observeCompactionProgress } from "./compaction-progress.js";
 import { PiSettingsIntegration } from "./settings-integration.js";
 import { PendingEngineDelivery } from "./pending-delivery.js";
 /** Explicit flush failure when required delivery was interrupted rather than completed. */
@@ -147,6 +148,7 @@ export class PiEngineAdapter {
     #assistantResponseSequence = 0;
     #statusKind = null;
     #sessionCommands;
+    #compactionProgress = null;
     #gitBranch = null;
     #extensionUi;
     #extensionShutdown;
@@ -1059,6 +1061,7 @@ export class PiEngineAdapter {
     clearQueuedWorkflows() {
         const session = this.#requireWorkflowSession();
         const result = session.clearQueue?.();
+        this.#sessionCommands?.forgetQueuedImages();
         if (!isRecord(result))
             return [];
         return [...readStringArray(result.steering), ...readStringArray(result.followUp)];
@@ -1257,6 +1260,8 @@ export class PiEngineAdapter {
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "stopping", reason: null });
         this.#unsubscribe?.();
         this.#unsubscribe = undefined;
+        this.#compactionProgress?.dispose();
+        this.#compactionProgress = null;
         await this.#runtime?.dispose();
         this.#lifecycle = "stopped";
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "stopped", reason: null });
@@ -2016,6 +2021,11 @@ export class PiEngineAdapter {
         this.#activeCommandIds = [];
         this.#completedCommands.clear();
         this.#sessionCommands = new PiSessionCommandIntegration(session);
+        this.#compactionProgress?.dispose();
+        this.#compactionProgress = observeCompactionProgress(session, percent => {
+            if (this.#session === session && !this.#disposed)
+                this.#publishCompactionProgress(percent);
+        });
         this.#editor = {
             text: "",
             queuedSubmissions: [],
@@ -2024,7 +2034,7 @@ export class PiEngineAdapter {
             historyRevision: this.#editor.historyRevision + 1,
             submitEnabled: true,
         };
-        this.#status = { ...this.#status, workingMessage: null, badges: [] };
+        this.#status = { ...this.#status, workingMessage: null, workingProgress: null, badges: [] };
         this.#statusKind = null;
         this.#agentRunActive = false;
         this.#agentRunSequence = 0;
@@ -2115,7 +2125,7 @@ export class PiEngineAdapter {
         const wasBusy = this.#lifecycle === "busy";
         this.#statusKind = kind;
         this.#lifecycle = "busy";
-        this.#status = { ...this.#status, workingMessage: message };
+        this.#status = { ...this.#status, workingMessage: message, workingProgress: null };
         if (!wasBusy)
             this.#emitEvent({ type: "session-lifecycle", lifecycle: "busy", reason: null });
         this.#emitEvent({ type: "status", status: this.#status });
@@ -2133,10 +2143,32 @@ export class PiEngineAdapter {
     #leaveWorkStates() {
         this.#statusKind = null;
         this.#lifecycle = "ready";
-        this.#status = { ...this.#status, workingMessage: null };
+        this.#status = { ...this.#status, workingMessage: null, workingProgress: null };
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
         this.#emitEvent({ type: "status", status: this.#status });
     }
+    // Invariant: progress belongs to the compaction state only and is published when the integer changes.
+    #publishCompactionProgress(percent) {
+        if (this.#statusKind !== "compaction" || this.#status.workingProgress === percent)
+            return;
+        this.#status = { ...this.#status, workingProgress: percent };
+        this.#emitEvent({ type: "status", status: this.#status });
+    }
+    // Rationale: a manual compaction ends with an idle session, so the engine would never consume
+    // the messages queued during it; automatic compaction returns to a run or a pending prompt.
+    #deliverQueuedAfterCompaction() {
+        const commands = this.#sessionCommands;
+        const generation = this.#sessionGeneration;
+        if (commands === undefined)
+            return;
+        const report = (error) => {
+            if (generation !== this.#sessionGeneration || this.#disposed)
+                return;
+            this.#addDiagnostic("error", "engine-command", `Queued input could not be sent after compaction: ${error instanceof Error ? error.message : String(error)}`, true);
+            this.#emitView();
+        };
+        commands.deliverQueuedAfterCompaction(report).catch(report);
+    }
     #handlePiEvent(event) {
         try {
             this.#applyPiEvent(event);
@@ -2286,9 +2318,13 @@ export class PiEngineAdapter {
                 return;
             case "compaction_start":
                 this.#enterWorkState("compaction", "Compacting");
+                this.#compactionProgress?.begin();
                 return;
             case "compaction_end":
+                this.#compactionProgress?.end();
                 this.#endWorkState("compaction");
+                if (event.reason === "manual")
+                    this.#deliverQueuedAfterCompaction();
                 return;
             case "thinking_level_changed":
                 this.#thinkingLevel = readThinkingLevel(event.level);
@@ -2797,10 +2833,12 @@ export class PiEngineAdapter {
         this.#admissionStopped = !canResume;
         this.#unsubscribe?.();
         this.#unsubscribe = undefined;
+        this.#compactionProgress?.dispose();
+        this.#compactionProgress = null;
         ++this.#sessionGeneration;
         this.#agentRunActive = false;
         this.#statusKind = null;
-        this.#status = { ...this.#status, workingMessage: null };
+        this.#status = { ...this.#status, workingMessage: null, workingProgress: null };
         this.#lifecycle = this.#disposed ? "stopped" : canResume ? "ready" : "failed";
         this.#editor = { ...this.#editor, submitEnabled: canResume && !this.#disposed };
         this.#viewRevision += 1;

package/dist/integrations/pi/engine/compaction-progress.d.ts

@@ -0,0 +1,28 @@
+/** Expected summary size for a first compaction, when no previous summary on the branch can serve as the estimate. */
+export declare const DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS = 4000;
+/** The public session surface compaction progress reads: the agent's stream function and the branch entries. */
+export interface CompactionProgressSession {
+    readonly agent?: {
+        streamFunction?: unknown;
+    } | undefined;
+    readonly sessionManager?: {
+        getBranch?(): readonly unknown[];
+    } | undefined;
+}
+export interface CompactionProgressObserver {
+    /** Marks `compaction_start`: resets the streamed count and captures the expected summary size. */
+    begin(): void;
+    /** Marks `compaction_end`: later stream chunks are ignored. */
+    end(): void;
+    /** Restores the original stream function; the observer reports nothing afterwards. */
+    dispose(): void;
+}
+/**
+ * Observes the summarization stream of a compaction through the session agent's public stream
+ * function and reports an estimated integer percent. Pi never iterates that stream itself (it
+ * reads only its final result), so the observer iterates it in the background between
+ * `begin()` and `end()` and returns the same stream object to Pi. Outside that window the
+ * wrapper is a pass-through. Returns null when the agent exposes no callable stream function,
+ * in which case compaction proceeds without progress.
+ */
+export declare function observeCompactionProgress(session: CompactionProgressSession, onProgress: (percent: number) => void): CompactionProgressObserver | null;

package/dist/integrations/pi/engine/compaction-progress.js

@@ -0,0 +1,96 @@
+/** Expected summary size for a first compaction, when no previous summary on the branch can serve as the estimate. */
+export const DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS = 4000;
+/** The percent shown while a compaction is still running never reaches this value. */
+const MAX_RUNNING_PERCENT = 99;
+/**
+ * Observes the summarization stream of a compaction through the session agent's public stream
+ * function and reports an estimated integer percent. Pi never iterates that stream itself (it
+ * reads only its final result), so the observer iterates it in the background between
+ * `begin()` and `end()` and returns the same stream object to Pi. Outside that window the
+ * wrapper is a pass-through. Returns null when the agent exposes no callable stream function,
+ * in which case compaction proceeds without progress.
+ */
+export function observeCompactionProgress(session, onProgress) {
+    const agent = session.agent;
+    if (agent === undefined || typeof agent.streamFunction !== "function")
+        return null;
+    const original = agent.streamFunction;
+    let active = false;
+    let disposed = false;
+    let generation = 0;
+    let streamed = 0;
+    let expected = DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS;
+    let reported = null;
+    const report = () => {
+        const percent = Math.min(MAX_RUNNING_PERCENT, Math.floor((100 * streamed) / expected));
+        if (percent === reported)
+            return;
+        reported = percent;
+        onProgress(percent);
+    };
+    const wrapped = async (model, context, options) => {
+        const stream = await original(model, context, options);
+        if (!active || disposed)
+            return stream;
+        const observed = generation;
+        void (async () => {
+            report();
+            // Invariant: observation never affects the request; a stream that cannot be iterated ends observation only.
+            try {
+                for await (const event of stream) {
+                    if (observed !== generation || !active)
+                        return;
+                    if (event.type === "text_delta") {
+                        streamed += event.delta.length;
+                        report();
+                    }
+                }
+            }
+            catch {
+                return;
+            }
+        })();
+        return stream;
+    };
+    agent.streamFunction = wrapped;
+    return {
+        begin() {
+            generation += 1;
+            streamed = 0;
+            reported = null;
+            expected = latestCompactionSummaryLength(session) ?? DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS;
+            active = true;
+        },
+        end() {
+            active = false;
+            generation += 1;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            active = false;
+            generation += 1;
+            if (agent.streamFunction === wrapped)
+                agent.streamFunction = original;
+        },
+    };
+}
+function latestCompactionSummaryLength(session) {
+    let entries;
+    try {
+        entries = session.sessionManager?.getBranch?.() ?? [];
+    }
+    catch {
+        return null;
+    }
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const { type, summary } = entry;
+        if (type === "compaction" && typeof summary === "string" && summary.length > 0)
+            return summary.length;
+    }
+    return null;
+}

package/dist/integrations/pi/engine/conformance.d.ts

@@ -6,7 +6,7 @@ export interface PiCapabilityConformanceResult {
 export declare const REQUIRED_PI_CAPABILITY_OPERATIONS: Readonly<{
     readonly "public-exports": readonly ["services.create", "session.create", "runtime.create"];
     readonly "session-lifecycle": readonly ["session.new", "session.resume", "session.rebind", "session.dispose"];
-    readonly "commands-events": readonly ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
+    readonly "commands-events": readonly ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
     readonly "models-authentication": readonly ["models.list", "models.refresh", "models.completeSimple", "auth.status", "auth.login", "auth.logout", "auth.cancel"];
     readonly settings: readonly ["settings.read", "settings.write", "settings.flush"];
     readonly "resources-extensions": readonly ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"];

package/dist/integrations/pi/engine/conformance.js

@@ -8,7 +8,7 @@ import { createWindowsNulCleanupExtension } from "./windows-filesystem-hygiene.j
 export const REQUIRED_PI_CAPABILITY_OPERATIONS = Object.freeze({
     "public-exports": ["services.create", "session.create", "runtime.create"],
     "session-lifecycle": ["session.new", "session.resume", "session.rebind", "session.dispose"],
-    "commands-events": ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
+    "commands-events": ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
     "models-authentication": ["models.list", "models.refresh", "models.completeSimple", "auth.status", "auth.login", "auth.logout", "auth.cancel"],
     settings: ["settings.read", "settings.write", "settings.flush"],
     "resources-extensions": ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"],
@@ -85,7 +85,7 @@ export async function runPiUpgradeConformance() {
             });
             const session = created.session;
             sessionId = session.sessionId;
-            requireMethods(session, "session commands", ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"]);
+            requireMethods(session, "session commands", ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"]);
             requireMethods(services.modelRuntime, "models/authentication", ["getModels", "getModel", "completeSimple", "checkAuth", "login", "logout", "refresh"]);
             requireMethods(services.settingsManager, "settings", ["getGlobalSettings", "getProjectSettings", "flush"]);
             requireMethods(services.resourceLoader, "resources/extensions", ["getExtensions", "getSkills", "getPrompts", "getThemes", "reload"]);
@@ -96,7 +96,7 @@ export async function runPiUpgradeConformance() {
         catch (error) {
             throw new PiUpgradeConformanceError("session", error);
         }
-        const commandSurface = ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
+        const commandSurface = ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
         const capabilities = Object.entries(REQUIRED_PI_CAPABILITY_OPERATIONS)
             .map(([capabilityName, operations]) => capability(capabilityName, operations));
         validatePiCapabilityResults(VERSION, capabilities);

package/dist/integrations/pi/engine/session-integration.d.ts

@@ -1,24 +1,33 @@
 import type { AgentSession, AgentSessionEvent, PromptOptions } from "../startup-public.js";
 import { type AgentCommandOutcome, type AgentEvent } from "../../../contracts/agent-engine/index.js";
+type PiPromptImages = NonNullable<PromptOptions["images"]>;
 export interface PiDocumentedSessionCommands {
     readonly isStreaming: AgentSession["isStreaming"];
     readonly isRetrying: AgentSession["isRetrying"];
     readonly isCompacting: AgentSession["isCompacting"];
     prompt(text: string, options?: Parameters<AgentSession["prompt"]>[1]): Promise<void>;
-    steer(text: string): Promise<void>;
-    followUp(text: string): Promise<void>;
+    steer(text: string, images?: PiPromptImages): Promise<void>;
+    followUp(text: string, images?: PiPromptImages): Promise<void>;
     abort(): Promise<void>;
     abortRetry(): void;
     abortCompaction(): void;
     compact(customInstructions?: Parameters<AgentSession["compact"]>[0]): Promise<unknown>;
+    clearQueue(): {
+        readonly steering: readonly string[];
+        readonly followUp: readonly string[];
+    };
     executeBash?(command: string, onChunk: unknown, options: {
         readonly excludeFromContext: boolean;
     }): Promise<unknown>;
+    /** Optional: extension commands cannot be queued, so they run immediately during compaction as in pinned Pi. */
+    readonly extensionRunner?: {
+        getCommand(name: string): unknown;
+    } | undefined;
 }
 export type PiSessionCommand = {
     readonly type: "prompt" | "steer" | "follow-up";
     readonly text: string;
-    readonly images?: NonNullable<PromptOptions["images"]>;
+    readonly images?: PiPromptImages;
 } | {
     readonly type: "abort" | "retry" | "compact";
 } | {
@@ -37,9 +46,22 @@ export declare class PiSessionCommandIntegration {
     private readonly session;
     constructor(session: PiDocumentedSessionCommands);
     execute(command: PiSessionCommand): Promise<PiSessionCommandResult>;
+    /**
+     * Delivers the messages queued during a manual compaction. The session is idle when a manual
+     * compaction ends, so nothing would consume the queue: the first message starts one run
+     * through the ordinary prompt path with its mode, and the rest are re-queued for that run,
+     * whose initial poll injects them in order. Automatic compaction needs no delivery: its
+     * continuing run or pending prompt consumes the queue itself. The run is not awaited; when
+     * the start is refused before the message is accepted, the queue is restored and the error
+     * reported through `onFailure`.
+     */
+    deliverQueuedAfterCompaction(onFailure: (error: unknown) => void): Promise<void>;
+    /** Forgets the attachments kept for queued messages; the queue itself was cleared by the caller. */
+    forgetQueuedImages(): void;
 }
 export interface PiOrderedEventIntegration {
     dispose(): void;
 }
 export declare function subscribeToPiSessionEvents(session: Pick<AgentSession, "subscribe">, sessionId: string, emit: (event: AgentEvent) => void, malformed: (diagnostic: string) => void): PiOrderedEventIntegration;
 export declare function convertPiSessionEvent(event: AgentSessionEvent, sessionId: string, sequence: number): AgentEvent | null;
+export {};

package/dist/integrations/pi/engine/session-integration.js

@@ -3,6 +3,9 @@ import { AGENT_ENGINE_CONTRACT_VERSION, } from "../../../contracts/agent-engine/
 export class PiSessionCommandIntegration {
     session;
     #lastPrompt = null;
+    // Rationale: Pi's queue restore returns text only, so the attachments of messages queued
+    // during compaction are kept here until the queue is delivered or cleared.
+    #queuedImages = [];
     constructor(session) {
         this.session = session;
     }
@@ -18,22 +21,24 @@ export class PiSessionCommandIntegration {
                     });
                 return { outcome: "completed" };
             case "steer":
+            case "follow-up": {
                 this.#lastPrompt = command.text;
+                const mode = command.type === "steer" ? "steer" : "followUp";
+                if (this.session.isCompacting && !this.#isExtensionCommand(command.text)) {
+                    // Compatibility: match interactive Pi: prompt() refuses input during manual compaction,
+                    // while the engine queue accepts it at any time and delivers it when compaction ends.
+                    await this.#queue(mode, command.text, command.images);
+                    return { outcome: "completed" };
+                }
                 // Compatibility: match interactive Pi: prompt() owns template/extension expansion and
                 // turns the accepted steering message into the visible user row while
                 // later messages remain in the pending queue.
                 await this.session.prompt(command.text, {
-                    streamingBehavior: "steer",
-                    ...(command.images === undefined ? {} : { images: [...command.images] }),
-                });
-                return { outcome: "completed" };
-            case "follow-up":
-                this.#lastPrompt = command.text;
-                await this.session.prompt(command.text, {
-                    streamingBehavior: "followUp",
+                    streamingBehavior: mode,
                     ...(command.images === undefined ? {} : { images: [...command.images] }),
                 });
                 return { outcome: "completed" };
+            }
             case "abort":
                 if (this.session.isRetrying)
                     this.session.abortRetry();
@@ -61,6 +66,86 @@ export class PiSessionCommandIntegration {
             }
         }
     }
+    /**
+     * Delivers the messages queued during a manual compaction. The session is idle when a manual
+     * compaction ends, so nothing would consume the queue: the first message starts one run
+     * through the ordinary prompt path with its mode, and the rest are re-queued for that run,
+     * whose initial poll injects them in order. Automatic compaction needs no delivery: its
+     * continuing run or pending prompt consumes the queue itself. The run is not awaited; when
+     * the start is refused before the message is accepted, the queue is restored and the error
+     * reported through `onFailure`.
+     */
+    async deliverQueuedAfterCompaction(onFailure) {
+        if (this.session.isStreaming || this.session.isCompacting)
+            return;
+        const { steering, followUp } = this.session.clearQueue();
+        const queued = [
+            ...steering.map(text => ({ mode: "steer", text, images: this.#takeImages(text) })),
+            ...followUp.map(text => ({ mode: "followUp", text, images: this.#takeImages(text) })),
+        ];
+        this.#queuedImages = [];
+        const [first, ...rest] = queued;
+        if (first === undefined)
+            return;
+        this.#lastPrompt = first.text;
+        let accepted = false;
+        const started = this.session.prompt(first.text, {
+            streamingBehavior: first.mode,
+            preflightResult: success => { accepted = success; },
+            ...(first.images === undefined ? {} : { images: [...first.images] }),
+        });
+        for (const item of rest)
+            await this.#queue(item.mode, item.text, item.images);
+        started.catch(async (error) => {
+            // Security: a run that reached the provider is never resent; only a refused start restores.
+            try {
+                if (!accepted)
+                    await this.#restoreQueue(queued);
+            }
+            finally {
+                onFailure(error);
+            }
+        }).catch(() => undefined);
+    }
+    /** Forgets the attachments kept for queued messages; the queue itself was cleared by the caller. */
+    forgetQueuedImages() {
+        this.#queuedImages = [];
+    }
+    // Rationale: the rest were re-queued before the refused start surfaced, so the queue is rebuilt
+    // in the original order; anything queued in between keeps its place after it.
+    async #restoreQueue(queued) {
+        const { steering, followUp } = this.session.clearQueue();
+        const restored = new Set(queued.map(item => item.text));
+        const extra = [
+            ...steering.filter(text => !restored.has(text)).map(text => ({ mode: "steer", text, images: this.#takeImages(text) })),
+            ...followUp.filter(text => !restored.has(text)).map(text => ({ mode: "followUp", text, images: this.#takeImages(text) })),
+        ];
+        this.#queuedImages = [];
+        for (const item of [...queued, ...extra])
+            await this.#queue(item.mode, item.text, item.images);
+    }
+    async #queue(mode, text, images) {
+        if (images !== undefined && images.length > 0)
+            this.#queuedImages.push({ text, images: [...images] });
+        if (mode === "steer")
+            await this.session.steer(text, images === undefined ? undefined : [...images]);
+        else
+            await this.session.followUp(text, images === undefined ? undefined : [...images]);
+    }
+    #takeImages(text) {
+        const index = this.#queuedImages.findIndex(item => item.text === text);
+        if (index === -1)
+            return undefined;
+        const [item] = this.#queuedImages.splice(index, 1);
+        return item?.images;
+    }
+    #isExtensionCommand(text) {
+        if (!text.startsWith("/"))
+            return false;
+        const spaceIndex = text.indexOf(" ");
+        const name = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+        return this.session.extensionRunner?.getCommand(name) !== undefined;
+    }
 }
 export function subscribeToPiSessionEvents(session, sessionId, emit, malformed) {
     let sequence = 0;

package/dist/integrations/pi/session-ui/session-shell-root.js

@@ -59,6 +59,8 @@ export class OwnedUiSessionShellRoot {
     #workflowStatusAnchors = new Map();
     #workflowStatusMessages = new Map();
     #lastWorkflowStatusId;
+    // Invariant: the notice is dock chrome, never transcript content; the custom viewport alone uses it.
+    #dockNotice;
     #inputSurface;
     #inputSurfaceCoordination = "editor";
     #dockInputReuseEnabled;
@@ -103,6 +105,7 @@ export class OwnedUiSessionShellRoot {
         });
         this.resources = createPiShellLoadedResources(startup.resources ?? [], startup.expanded ?? false);
         this.#status = createPiShellStatus(view, progressStatusText, handlers);
+        this.#status.setProgressPresentation(this.#customViewport ? "custom-viewport" : "pinned");
         this.#footer = createPiShellFooter(this.#viewWithExtensionStatuses(view), cwd, this.#customViewport ? "a1" : "pi");
         this.#queued = createPiQueuedInputStatus(view.editor.queuedSubmissions, this.#customViewport ? "custom-viewport" : "pinned");
         this.editor = createPiShellEditor({
@@ -340,6 +343,8 @@ export class OwnedUiSessionShellRoot {
         this.#documentLayouts.clear();
     }
     #mountTranscript(block) {
+        // Invariant: new content dismisses the notice; a revision of a mounted block keeps it.
+        this.#dismissDockNotice();
         const created = createPiShellTranscriptComponent(block, this.#cwd, this.#extensionRenderers, this.#submittedPromptComposer, this.#outputPad, !this.#thinkingVisible, this.#mermaidRenderingMode, this.#showImages, this.#imageWidthCells, this.#imageAssets, { ...this.#componentRuntime, changed: () => {
                 if (this.#transcript.get(block.id) !== created)
                     return;
@@ -521,7 +526,7 @@ export class OwnedUiSessionShellRoot {
     #renderDockLayout(width) {
         const queued = this.#customViewport ? [] : this.#renderQueued(width);
         const statusRows = this.#customViewport ? this.#status.renderDock(width) : this.#renderStatus(width);
-        const transientRows = [...queued, ...statusRows];
+        const transientRows = [...queued, ...statusRows, ...this.#renderDockNotice(width)];
         const aboveWidgets = this.#renderWidgets("aboveEditor", width);
         const input = this.#inputSurface.render(width);
         // Invariant: pointer rows describe the body, not the autocomplete block now preceding it.
@@ -535,6 +540,17 @@ export class OwnedUiSessionShellRoot {
             inputRows: body?.rowCount ?? input.length,
         };
     }
+    #renderDockNotice(width) {
+        if (this.#dockNotice === undefined)
+            return [];
+        return ["", ...renderPiShellStatusText(this.#dockNotice, width, this.#outputPad)];
+    }
+    #dismissDockNotice() {
+        if (this.#dockNotice === undefined)
+            return;
+        this.#dockNotice = undefined;
+        this.#invalidateChrome();
+    }
     #renderQueued(width) {
         return this.#view.editor.queuedSubmissions.length === 0 ? [] : this.#queued.render(width);
     }
@@ -733,6 +749,14 @@ export class OwnedUiSessionShellRoot {
         return rows.join("\n");
     }
     appendWorkflowStatus(message) {
+        // Rationale: bare A1 acknowledges commands in one dock notice above the editor, where the
+        // reader's eye already is, instead of a transcript row that opens an empty session at the
+        // top-left or sinks into a long feed. The pinned route keeps Pi's chat placement.
+        if (this.#customViewport) {
+            this.#dockNotice = message;
+            this.#invalidateChrome();
+            return;
+        }
         const previousId = this.#lastWorkflowStatusId;
         if (previousId !== undefined
             && this.#transcriptOrder.at(-1) === previousId
@@ -872,6 +896,7 @@ export class OwnedUiSessionShellRoot {
         this.invalidate();
     }
     resetWorkflowPresentation() {
+        this.#dockNotice = undefined;
         for (const id of this.#workflowStatusAnchors.keys()) {
             this.#transcript.get(id)?.dispose?.();
             this.#transcript.delete(id);
@@ -1056,6 +1081,8 @@ export class OwnedUiSessionShellRoot {
         this.#transcriptOrder = order;
     }
     #appendAnchoredWorkflowComponent(render, dispose) {
+        // Invariant: transcript-bound workflow output supersedes a pending acknowledgement.
+        this.#dismissDockNotice();
         this.#workflowTranscriptSequence += 1;
         const id = `workflow-status-${this.#workflowTranscriptSequence}`;
         const component = {

package/dist/integrations/pi/session-ui/session-shell.js

@@ -66,7 +66,6 @@ export class OwnedUiSessionShell {
     #showImages = true;
     #imageWidthCells = 80;
     #fullscreenExitOutput = "transcript";
-    #compactionQueue = [];
     #waitingImages = new Map();
     #lastClearTime = 0;
     #lastEscapeTime = 0;
@@ -494,8 +493,6 @@ export class OwnedUiSessionShell {
                     model: event.model,
                 });
             }
-            if (view.lifecycle === "ready" && this.#compactionQueue.length > 0)
-                void this.#flushCompactionQueue();
             if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
                 this.#settleStoppedLifecycle();
         });
@@ -642,18 +639,8 @@ export class OwnedUiSessionShell {
                 }
             }
         }
-        if (this.view().status.workingMessage?.startsWith("Compacting") === true) {
-            this.#rememberInput(displayInput, "steer");
-            this.#compactionQueue.push({
-                text: input,
-                draft: displayInput,
-                type: "steer",
-                ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-            });
-            this.root.appendWorkflowResult({ command: "compact", outcome: "completed", message: `Queued during compaction: ${input}` });
-            this.runtime.requestRender();
-            return { outcome: "completed", diagnostic: null };
-        }
+        // Compatibility: match interactive Pi: input during compaction is queued steering; the engine
+        // shows it in the pending rows and delivers it when compaction ends.
         const type = this.view().lifecycle === "busy" ? "steer" : "prompt";
         this.#rememberInput(displayInput, type);
         this.root.resumeViewportFollowing();
@@ -772,15 +759,6 @@ export class OwnedUiSessionShell {
         if (this.root.editor.getText() === draft)
             this.root.editor.setText("");
         this.root.resumeViewportFollowing();
-        if (this.view().status.workingMessage?.startsWith("Compacting") === true) {
-            this.#compactionQueue.push({
-                text,
-                draft: displayInput,
-                type: "follow-up",
-                ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-            });
-            return { outcome: "completed", diagnostic: null };
-        }
         return this.#execute({
             type: "follow-up",
             correlationId: this.#correlation("follow-up"),
@@ -790,9 +768,8 @@ export class OwnedUiSessionShell {
         }, displayInput);
     }
     restoreQueuedInput() {
-        const queued = [...this.#waitingImages.keys(), ...this.backend.clearQueuedWorkflows(), ...this.#compactionQueue.map(item => item.draft)];
+        const queued = [...this.#waitingImages.keys(), ...this.backend.clearQueuedWorkflows()];
         this.#cancelWaitingImages();
-        this.#compactionQueue = [];
         if (queued.length === 0)
             return;
         this.root.editor.setText(queued.join("\n"));
@@ -1773,19 +1750,6 @@ export class OwnedUiSessionShell {
         this.root.setInputSurface(null);
         this.runtime.requestRender();
     }
-    async #flushCompactionQueue() {
-        const queued = this.#compactionQueue;
-        this.#compactionQueue = [];
-        for (const item of queued) {
-            await this.#execute({
-                type: item.type,
-                correlationId: this.#correlation(`compaction-${item.type}`),
-                sessionId: this.backend.sessionId,
-                text: item.text,
-                ...(item.images === undefined ? {} : { images: item.images }),
-            }, item.draft);
-        }
-    }
     async #execute(command, draft) {
         if (draft === undefined)
             return this.backend.execute(command);

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-09-17T13:26:08.181Z",
+  "builtAt": "2026-09-17T18:17:47.242Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "9db1726bbe3fc2e8292f2ead1e7e9d0fd4d7d0dc9217b372582bf354b0f565dc",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-17T13:26:00.541Z",
+  "builtAt": "2026-09-17T18:17:37.589Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "d8cda6b0c7cb36c0cc41e90802aceebf6c02eaebbc08a83d7d963d2e918dbd7a",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-17T13:27:04.398Z",
+  "builtAt": "2026-09-17T18:18:40.058Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "f7e5072d6fddb8e0672d8274699e8e47f515d98776ba3bd79b00391fcd38e667",
+    "sha256": "bb9636bcbdcbd48220ad6beb4934afc7b07c369e0abe1906d9dacc45a67ec675",
     "size": 177664
   },
   "provenance": {

package/docs/local-worktree-cleanup.md

@@ -22,6 +22,20 @@ node scripts/governance/local-worktree-cleanup.mjs sweep --repo D:/Git/a1
 
 `sweep` evaluates every released registration in one pass under the queue limits (100 registrations, 500 remote requests, a durable round-robin cursor) with a 180-second elapsed budget, since each merged candidate costs three evidence loads, and completes each candidate whose PR is verified merged using exactly the `complete` safeguards. It needs no `enable` and starts no process: its authority is each candidate's release. A candidate whose PR is open, draft, or not yet finalized reports `pending`; a candidate whose PR closed without merge reports `awaiting-discard` and is never touched; blockers report their exact reason. An old stop sentinel does not prevent a sweep, but `disable` run while a sweep is executing stops it before its next destructive step. If another session holds the mutation lock the sweep reports `mutation-busy` and the agent relays it as deferred rather than waiting. The JSON report carries a `lines` array with one relayable line per candidate and pruned branch, for example `#458 close-absent-and-skewed-cleanup: removed [worktree-removed, local-ref-removed]`. Pending or blocked results never delay the new delivery.
 
+### Nothing left to remove
+
+A released entry whose evidence can never verify (for example `delivery-content-drift` after a stale-base merge, or `source-association` for a PR without an `openspec-implementation` fence) would otherwise be re-verified and reported `blocked` on every sweep. When such an entry's worktree path is gone, Git holds no live row for it (its own dangling row is retired), and its local topic ref is absent, the sweep and `complete` ask GitHub only whether the pull request merged into `develop` in this repository and then mark the journal `done` with `retired-nothing-left` and the original evidence reason. Nothing is deleted; a present path, row, or ref keeps the entry blocked, an unmerged PR keeps it `pending` or `awaiting-discard`, a deferred failure such as `remote-budget` is never treated as unverifiable, and preview retires nothing. For an all-absent entry whose PR is not merged, the maintainer runs the explicit form, which reads nothing from GitHub and deletes nothing:
+
+```bash
+node scripts/governance/local-worktree-cleanup.mjs forget --repo D:/Git/a1 --id REGISTRATION_ID --confirm-nothing-left
+```
+
+`forget` refuses without the flag, for an owned or deleting entry, and while the path, a live Git row, or the ref still exists (`something-remains`). `status` shows both notes under `completion`.
+
+### Keep the base current before merge
+
+The `develop` ruleset requires the pull request head to be up to date with `develop`. When another delivery merges first, the PR shows `BEHIND`: merge `origin/develop` into the branch (or use "Update branch"), push, let the `OpenSpec finalization` workflow re-finalize with digests of the merged bytes, wait for validation, and hand off again. Merging a stale finalized head is what produced `delivery-content-drift` for #461; with the strict policy GitHub refuses that merge.
+
 ### Accepted ancestry
 
 Since the `OpenSpec finalization` workflow pushes its commit onto the PR branch after the agent's last push, the registered head is normally one commit behind the merged head. Cleanup therefore accepts a registered head, live worktree HEAD, or local topic-ref tip that equals the merged PR head or is one of its ancestors on GitHub, verified with the compare API: every commit reachable from such a tip is reachable from a head the maintainer accepted, so nothing is lost. A tip that holds a commit outside the merged head, or a commit GitHub does not know, still blocks with `candidate-head-association`, `worktree-identity-changed`, or `local-ref-advanced`, and the branch attachment must still be the registered one. Ref deletion reads the tip immediately before deleting, requires it to be accepted, and uses it as the compare-and-delete expectation. Ancestry of `develop` is never used, because the repository squash-merges.
@@ -162,6 +176,8 @@ State, journals, stop controls, and execution reports live in `<git-common-dir>/
 - `unmanaged`: no local registration; no automatic adoption.
 - `removed`: worktree and eligible local-ref operations were verified.
 - `already-absent`: a completed journal's path/ref are still absent.
+- `retired`: evidence was unverifiable but nothing remained to delete and the PR is merged; the journal is complete with `retired-nothing-left`.
+- `forgotten`: the maintainer explicitly closed an all-absent entry with `forget`.
 - `partial`: a destructive step began but all cleanup could not be verified; the same command resumes it.
 - `deferred`: a bounded pass or concurrent mutation owner prevented evaluation.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.459",
+  "version": "0.1.8-dev.467",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",