pi-better-goal 0.11.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-goal",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Pi extension for goal tracking with background-aware continuation.",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -6,6 +6,7 @@ import { Type } from "typebox";
 import { commandAvailable, commandInvocation, resolveGoalCommand } from "./command-binding.js";
 import { goalPreferencesPath, readGoalPreferences, writeGoalPreference, type GoalPreferences } from "./preferences.js";
 import { createGoalSettingsPage } from "./settings-page.js";
+import { OPERATION_RESUME_ADMISSION, operationOwnerMatches, type OperationResumeRequest } from "./operation-admission.js";
 
 import {
   collectActivitySnapshot,
@@ -41,7 +42,7 @@ import { createRenderScheduler } from "./shared-render-scheduler.js";
 import { initializeNavigatorPanels, setNavigatorPanel } from "./shared-navigator-panels.js";
 import { collectSubagentActivity } from "./subagents.js";
 import { currentWorkflowOwner, skillCommandName, workflowEntry, workflowOwnerFromSkill, WORKFLOW_ENTRY_TYPE } from "./workflow.js";
-import { completionGate, pauseGate, schedulerWaitUntil } from "./workflow-gates.js";
+import { completionGate, pauseGate, schedulerWaitUntil, operationResumeSchedulerGate } from "./workflow-gates.js";
 import { workflowRehydrateMessage, WORKFLOW_REHYDRATE_MESSAGE_TYPE } from "./rehydrate.js";
 import { requestTaskContext } from "./task-context.js";
 import {
@@ -313,6 +314,7 @@ export default function (pi: ExtensionAPI): void {
 
   let currentCtx: ExtensionContext | undefined;
   let executionGeneration = 0;
+  let operationAdmissionRevision = 0;
   let agentGeneration = -1;
   let turnGeneration = 0;
   let escapeAbortSuppression: { session: number; turn: number; execution: number } | undefined;
@@ -862,6 +864,51 @@ export default function (pi: ExtensionAPI): void {
     );
   };
 
+  const unsubscribeOperationAdmission = pi.events.on(OPERATION_RESUME_ADMISSION, (value) => {
+    const request = value as Partial<OperationResumeRequest> | undefined;
+    if (request?.version !== 1 || !request.owner || typeof request.reply !== "function") return;
+    const ctx = currentCtx;
+    const revision = executionGeneration;
+    const preferencesRevision = operationAdmissionRevision;
+    const reply = request.reply;
+    const held = (reason: string) => reply({ allowed: false, reason, revision: executionGeneration });
+    if (!operationOwnerMatches(ctx, request.owner) || !ctx) { held("Owning parent session or branch is inactive"); return; }
+    const goal = getGoal(ctx);
+    if ((request.owner.goalId ?? null) !== (goal?.goalId ?? null)) { held("Owning Goal is no longer current"); return; }
+    if (goal && !preferences.autoContinue) { held("Goal automatic continuation is disabled"); return; }
+    if (goal && !isPokeable(goal)) { held("Goal is not active"); return; }
+    if (goal && currentPermissionHold(ctx, goal.goalId).blockers.length) { held("Goal has an active permission hold"); return; }
+    if (goal && currentContinuationState(ctx, goal.goalId)?.blocked) { held("Goal continuation requires human resume"); return; }
+    if (goal && !boundCommandReady(goal, ctx)) { held("Bound workflow is not ready"); return; }
+    const workflow = getWorkflow(ctx);
+    void (workflow ? operationResumeSchedulerGate(ctx.sessionManager.getBranch(), workflow) : Promise.resolve({ ok: true as const, waitUntil: undefined })).then((gate) => {
+      if (ctx !== currentCtx || revision !== executionGeneration || preferencesRevision !== operationAdmissionRevision || !operationOwnerMatches(currentCtx, request.owner!)) {
+        held("Parent execution changed during resume admission"); return;
+      }
+      const latest = getGoal(ctx);
+      if ((request.owner!.goalId ?? null) !== (latest?.goalId ?? null)) { held("Owning Goal changed during resume admission"); return; }
+      if (latest && !preferences.autoContinue) { held("Goal automatic continuation is disabled"); return; }
+      if (latest && (!isPokeable(latest) || currentPermissionHold(ctx, latest.goalId).blockers.length || currentContinuationState(ctx, latest.goalId)?.blocked)) {
+        held("Goal became held during resume admission"); return;
+      }
+      if (!gate.ok) { held(gate.reason); return; }
+      if (gate.waitUntil && gate.waitUntil > Date.now()) { held("Workflow scheduler is waiting"); return; }
+      // An in-process capability lets the dispatcher validate this admission
+      // after its last await and immediately before releasing execution.
+      const isCurrent = (): boolean => {
+        if (ctx !== currentCtx || revision !== executionGeneration || preferencesRevision !== operationAdmissionRevision
+          || !operationOwnerMatches(currentCtx, request.owner!)) return false;
+        const active = getGoal(ctx);
+        if ((request.owner!.goalId ?? null) !== (active?.goalId ?? null)) return false;
+        if (JSON.stringify(getWorkflow(ctx)) !== JSON.stringify(workflow)) return false;
+        return !active || (preferences.autoContinue && isPokeable(active)
+          && !currentPermissionHold(ctx, active.goalId).blockers.length
+          && !currentContinuationState(ctx, active.goalId)?.blocked && boundCommandReady(active, ctx));
+      };
+      reply({ allowed: true, revision, isCurrent });
+    }, () => held("Workflow admission evidence is unavailable"));
+  });
+
   pi.events.on(EVENT_REGISTER_PROVIDER, (provider) => {
     const candidate = provider as Partial<BackgroundActivityProvider> | undefined;
     if (!candidate || typeof candidate.id !== "string" || typeof candidate.getActivity !== "function") {
@@ -880,6 +927,7 @@ export default function (pi: ExtensionAPI): void {
   const changePreference = async (ctx: ExtensionCommandContext, key: keyof GoalPreferences, enabled: boolean): Promise<void> => {
     const previous = preferences;
     preferences = writeGoalPreference(key, enabled);
+    operationAdmissionRevision += 1;
     if (previous.autoContinue !== preferences.autoContinue) clearIdleContinuation();
     syncResumeTool(getGoal(ctx));
     if (!previous.autoContinue && preferences.autoContinue) {
@@ -1576,6 +1624,7 @@ export default function (pi: ExtensionAPI): void {
 
   pi.on("session_shutdown", async (_event, ctx) => {
     if (typeof unsubscribeSettingsRequest === "function") unsubscribeSettingsRequest();
+    if (typeof unsubscribeOperationAdmission === "function") unsubscribeOperationAdmission();
 
     executionGeneration += 1;
     sessionGeneration += 1;

package/src/operation-admission.ts

@@ -0,0 +1,16 @@
+import type {ExtensionContext} from '@earendil-works/pi-coding-agent';
+
+export const OPERATION_RESUME_ADMISSION='pi-better-goal:operation-resume-admission';
+export interface OperationResumeOwner {sessionId:string;workspace:string;branchId?:string|null;goalId?:string|null}
+export interface OperationResumeGate {allowed:boolean;reason?:string;revision:number;isCurrent?:()=>boolean}
+export interface OperationResumeRequest {version:1;owner:OperationResumeOwner;reply:(gate:OperationResumeGate)=>void}
+
+/** A recorded branch anchor remains valid on descendants, not on an abandoned fork. */
+export function operationOwnerMatches(ctx:ExtensionContext|undefined,owner:OperationResumeOwner):boolean {
+ if(!ctx||ctx.cwd!==owner.workspace)return false;
+ try{
+  if(ctx.sessionManager.getSessionId()!==owner.sessionId)return false;
+  if(owner.branchId&&!ctx.sessionManager.getBranch().some(entry=>entry.id===owner.branchId))return false;
+  return true;
+ }catch{return false;}
+}

package/src/workflow-gates.ts

@@ -262,6 +262,21 @@ export function waitUntil(due: readonly SchedulerAction[]): number | undefined {
   return times.length > 0 ? Math.min(...times) : undefined;
 }
 
+export type OperationResumeSchedulerGate = { ok: true; waitUntil: number | undefined } | { ok: false; reason: string };
+
+/** Automatic worker admission cannot treat unavailable workflow evidence as permission. */
+export async function operationResumeSchedulerGate(
+  entries: Iterable<EntryLike>,
+  owner: WorkflowOwner,
+  options: { timeoutMs?: number } = {},
+): Promise<OperationResumeSchedulerGate> {
+  const located = locateRun(entries, owner);
+  if ("warning" in located) return { ok: false, reason: located.warning };
+  const run = await runScheduler(located.script, located.runDir, options.timeoutMs);
+  if (!run.ok) return { ok: false, reason: `Workflow admission evidence unavailable: ${run.reason}` };
+  return { ok: true, waitUntil: waitUntil(run.due) };
+}
+
 /** When the bound run next wants a continuation, or undefined when it is not only waiting. */
 export async function schedulerWaitUntil(
   entries: Iterable<EntryLike>,