@signalridge/pi-workflows 1.11.0 → 1.11.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.11.1
+### Patch Changes
+
+- da9ed0f: - Reject rename hardlink aliases and retargeted queue identities before writes; support all LSP newline styles and identify possibly partially modified targets on write failure.
+  - Fence pending physical Plan model mutations at cancellable navigation/replacement gates, reconcile handoffs by native selection chronology, and scope thinking-only restoration to its originating model.
+  - Compose Goal guidance through an owned structured prompt section. Resolve overflow usage against physical response models and invalidate stale size evidence after persisted context edits in each independent continuation helper.
+  - Persist queued Rules reminders/offers only at authenticated native admission, match file URL paths, and provide usable rule-file references when read_rule is unavailable.
+  - Inherit nested workers' thinking from their immediate spawning session while preserving explicit policy precedence.
+  - Refresh skill discovery for custom Analytics runs without consuming pending user attribution, and finalize successful Codex diagnostics only after UI cleanup and the final owned result fence.
+- da9ed0f: Restore workflow keyword and standing `/effort high|ultra` authorization on Pi 1.2 and later. Those hosts report the session as busy while its own run starts, so the hidden guidance that authorizes the `workflow` tool was silently dropped for every idle prompt. The idle check now applies only on hosts that do not identify the starting run, and runs started by a custom message never consume an armed prompt.
+- da9ed0f: Stop settled workflow results from waking a session whose context overflowed the model window. While the latest response on the branch is a context overflow with no compaction after it, results are still delivered and acknowledged as context but no wake is sent, and one warning per overflow episode asks to run `/compact` (or `/codex-compact` when installed) or start a new session. A compaction or a later successful response restores normal wakes. Previously each wake resent the same over-window context and failed again. The package now declares `@earendil-works/pi-ai` as a host peer dependency.
+- Updated dependencies [da9ed0f]
+  - @signalridge/pi-ui@1.4.1
+
 ## 1.11.0
 ### Minor Changes
 

package/README.md

@@ -306,6 +306,14 @@ awaits while navigation or shutdown retires the owner, the obsolete
 extension-sourced wake is handled without starting a turn. Interactive/RPC
 input and other extensions' messages are not consumed by this guard.
 
+No wake is sent while the session's latest meaningful response overflowed the model's
+context window and no compaction followed it: that turn would resend the same
+over-window context and fail again. Results are still delivered and acknowledged
+as context, and one warning per overflow episode asks to run `/compact` (or
+`/codex-compact` when installed) or start a new session. A compaction or a later
+successful response restores normal wakes. Aborted responses and transient errors
+(including HTTP 503 and rate limits) do not prove context recovery.
+
 This is a handoff check, not a navigation lock: public hooks cannot fence an
 arbitrary later async input or preparation handler that navigates after our
 input hook has accepted the wake. Earlier transforms must preserve the private

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalridge/pi-workflows",
-  "version": "1.11.0",
+  "version": "1.11.1",
   "description": "Deterministic JavaScript orchestration workflows backed by pi-subagents managed spawning.",
   "type": "module",
   "license": "MIT",
@@ -15,6 +15,7 @@
     "lifecycle": "stable"
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "@signalridge/pi-subagents": ">=1.9.0",
@@ -22,7 +23,7 @@
   },
   "dependencies": {
     "@signalridge/pi-subagents-protocol": "^1.6.0",
-    "@signalridge/pi-ui": "^1.4.0",
+    "@signalridge/pi-ui": "^1.4.1",
     "acorn": "^8.16.0"
   },
   "pi": {

package/skills/workflow-authoring/SKILL.md

@@ -2,7 +2,7 @@
 name: workflow-authoring
 description: Design, write, review, and debug Pi JavaScript workflows that coordinate multiple subagents. Use when a request needs named dependencies, bounded fan-out, per-item pipelines, quality gates, saved or nested workflows, pause/resume, or workflow progress; do not use it merely to run an existing named workflow.
 metadata:
-  version: "1.11.0"
+  version: "1.11.1"
 ---
 
 # Workflow authoring

package/skills/workflow-authoring/references/capabilities.md

@@ -2,7 +2,7 @@
 # Workflow capability index
 
 Contract format: `2.0.0`<br>
-Contract content / skill / extension: `1.11.0`
+Contract content / skill / extension: `1.11.1`
 
 This compact generated index covers supported runtime globals and workflow-tool inputs. For constraints, compatibility behavior, internal boundaries, and dynamic-reference ownership, follow the [exhaustive generated facts](capability-details.md).
 

package/skills/workflow-authoring/references/capability-details.md

@@ -2,7 +2,7 @@
 # Exhaustive workflow capability facts
 
 Contract format: `2.0.0`<br>
-Contract content / skill / extension: `1.11.0`
+Contract content / skill / extension: `1.11.1`
 
 Every exact fact below is projected from the installed extension's capability contract. Explanatory judgment belongs in the hand-written references next to this file.
 

package/skills/workflow-patterns/SKILL.md

@@ -2,7 +2,7 @@
 name: workflow-patterns
 description: Choose and run one of Pi's built-in multi-agent workflows for research, adversarial review, code review, multi-perspective analysis, or codebase auditing. Use when the request matches a named pattern; use workflow-authoring instead for a new script or custom topology.
 metadata:
-  version: "1.11.0"
+  version: "1.11.1"
 ---
 
 # Built-in workflow patterns

package/skills/workflow-review/SKILL.md

@@ -2,7 +2,7 @@
 name: workflow-review
 description: Audit an existing Pi JavaScript workflow for topology, prompt/data flow, limits, failure handling, cancellation, resume safety, and publication compatibility. Use when reviewing or debugging a workflow script or saved run; do not use to run a standard named workflow.
 metadata:
-  version: "1.11.0"
+  version: "1.11.1"
 ---
 
 # Workflow review

package/src/arming.ts

@@ -235,15 +235,21 @@ export class WorkflowTurnArming {
   }
 
   consume(event: BeforeAgentStartEvent, ctx: ExtensionContext): void {
+    // Pi 1.2+ also announces idle custom-message runs; only a user prompt can
+    // carry the armed input, and earlier hosts never reached here for them.
+    if (event.messageType === "custom") return;
     const pending = this.pending;
     const ambiguous = this.ambiguous;
     this.pending = undefined; // one-use, also for mismatched/consumed prompts
     this.current = undefined;
     try {
+      // Pi 1.2+ (which reports messageType) counts the session busy while its
+      // own run prepares and queues concurrent sends into it. Earlier hosts were
+      // still idle here, so a busy session meant another run had started.
       if (
         ambiguous ||
         !pending?.content ||
-        !ctx.isIdle() ||
+        (event.messageType === undefined && !ctx.isIdle()) ||
         event.prompt !== pending.text ||
         inputKey("", event.images) !== pending.images ||
         ctx.sessionManager.getSessionId() !== pending.sessionId ||

package/src/context-overflow.ts

@@ -0,0 +1,98 @@
+/**
+ * Overflow-aware waking. After a response overflowed the model's context window and no
+ * compaction followed, a turn this extension starts resends the same over-window context and
+ * fails again, and each failure is still a billed request. Wakes are held until a compaction
+ * or a later successful response ends the episode.
+ */
+import { isContextOverflow } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+type EpisodeContext = Pick<ExtensionContext, "sessionManager"> & {
+  modelRegistry?: { find(provider: string, model: string): { contextWindow?: number } | undefined };
+};
+export type OverflowContext = EpisodeContext & Pick<ExtensionContext, "hasUI" | "ui">;
+
+/**
+ * The first overflowed response of the current episode: the latest meaningful response on the
+ * branch overflowed and neither compaction nor a successful response followed. Aborted and
+ * transient error responses say nothing about the context size and are skipped.
+ */
+export function overflowEpisode(ctx: EpisodeContext): string | undefined {
+  try {
+    const branch = ctx.sessionManager.getBranch();
+    const projection = ctx.sessionManager.buildSessionProjection?.();
+    const projected = projection
+      ? new Set(
+          projection.entries
+            .filter((entry) => entry.messages.some((message) => message.role === "assistant"))
+            .map((entry) => entry.sourceEntry.id),
+        )
+      : undefined;
+    let contextEdited = false;
+    let episode: string | undefined;
+    for (let index = branch.length - 1; index >= 0; index--) {
+      const entry = branch[index];
+      if (entry.type === "compaction") break;
+      if (entry.type === "context_edit") {
+        contextEdited = true;
+        continue;
+      }
+      if (entry.type !== "message" || entry.message.role !== "assistant" || entry.message.stopReason === "aborted")
+        continue;
+      const explicit = entry.message.stopReason === "error" && isContextOverflow(entry.message);
+      if (entry.message.stopReason === "error" && !explicit) continue;
+      // Pi can omit a failed recovery attempt before a cancelled compaction.
+      // That alone does not repair its oversized input; invalidate usage only.
+      if (!explicit && projected && !projected.has(entry.id)) break;
+      const contextWindow = ctx.modelRegistry?.find(entry.message.provider, entry.message.model)?.contextWindow;
+      if (!explicit && (contextEdited || !isContextOverflow(entry.message, contextWindow))) {
+        if (entry.message.stopReason === "error") continue;
+        break;
+      }
+      episode = entry.id;
+    }
+    return episode;
+  } catch {
+    // A replaced session's context is stale; never hold a wake on a guess.
+    return undefined;
+  }
+}
+
+export function overflowNotice(held: string, codexCompact: boolean): string {
+  return (
+    `Context exceeds the model's window; ${held} without starting a turn. ` +
+    `Run ${codexCompact ? "/compact or /codex-compact" : "/compact"}, or start a new session.`
+  );
+}
+
+/** One guard per extension instance, so the user sees one notice per overflow episode. */
+export class OverflowWakeGuard {
+  private noticed: string | undefined;
+  constructor(
+    private readonly pi: Pick<ExtensionAPI, "getCommands">,
+    private readonly held: string,
+  ) {}
+
+  /** True while a turn must not start; the first hold of an episode tells the user why. */
+  holds(ctx: OverflowContext | undefined): boolean {
+    const episode = ctx ? overflowEpisode(ctx) : undefined;
+    if (!ctx || episode === undefined) return false;
+    if (episode !== this.noticed) {
+      this.noticed = episode;
+      try {
+        if (ctx.hasUI) ctx.ui.notify(overflowNotice(this.held, this.hasCommand("codex-compact")), "warning");
+      } catch {
+        // A disposed UI must not block the delivery that follows.
+      }
+    }
+    return true;
+  }
+
+  private hasCommand(name: string): boolean {
+    try {
+      return this.pi.getCommands().some((command) => command.name === name);
+    } catch {
+      return false;
+    }
+  }
+}

package/src/index.ts

@@ -8,6 +8,7 @@ import { Type } from "@sinclair/typebox";
 import { DEFAULT_TRIGGER_WORD, hasTriggerWord, WORKFLOW_ARMING_MESSAGE_TYPE, WorkflowTurnArming } from "./arming.js";
 import { BUILTIN_WORKFLOWS, validateBuiltinArgs } from "./builtins.js";
 import { type CommandResult, resolveCodeReviewScope } from "./code-review-scope.js";
+import { OverflowWakeGuard } from "./context-overflow.js";
 import { type ScriptStartOptions, type ScriptStartResult, WorkflowEngine, WorkflowWaitAbortedError } from "./engine.js";
 import { JOURNAL_ENTRY_TYPE, type SessionEntryLike } from "./journal.js";
 import {
@@ -361,6 +362,7 @@ export default function piWorkflows(pi: ExtensionAPI): void {
   let keywordTriggerEnabled = workflowSettings.keywordTriggerEnabled;
   /** Public sends are void: acceptance is checked against the owning branch. */
   let deliveryContext: ExtensionContext | undefined;
+  const overflowWakes = new OverflowWakeGuard(pi, "workflow results are added to the conversation");
   let deliveryTimer: ReturnType<typeof setTimeout> | undefined;
   let inputPreparing = false;
   const turnArming = new WorkflowTurnArming();
@@ -1808,7 +1810,8 @@ export default function piWorkflows(pi: ExtensionAPI): void {
     try {
       if (!isCurrent()) return;
       // Never use a custom-message triggerTurn: that skips input preparation
-      // and before_agent_start. The void API is NOT an acceptance promise.
+      // (and, before Pi 1.2, before_agent_start). The void API is NOT an
+      // acceptance promise.
       const missing = batch.filter(([runId]) => !persisted(runId));
       if (missing.length > 0)
         pi.sendMessage(
@@ -1842,7 +1845,9 @@ export default function piWorkflows(pi: ExtensionAPI): void {
       }
       // An earlier input hook can await while the same manager navigates. Keep
       // exact owner evidence until our input hook consumes this private wake.
-      if (isCurrent() && engine) {
+      // An overflowed parent would resend the same over-window context: the
+      // acknowledged results above wait for the next run instead.
+      if (isCurrent() && engine && !overflowWakes.holds(ctx)) {
         const wake = `${DELIVERY_WAKE_PREFIX}${randomUUID()}] ${DELIVERY_WAKE_TEXT}`;
         wakeAdmissions.set(wake, { generation, context: ctx, engine, anchor: deliveryBranchAnchor });
         while (wakeAdmissions.size > MAX_WAKE_ADMISSIONS) {