pi-harness-runtime 1.1.348 → 1.1.350

package/index.ts

@@ -134,6 +134,8 @@ const sharedState = {
 	todoContinuationController: null as unknown,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	updateAutoContinueStatus: null as any,
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	pqController: null as any,
 };
 
 async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
@@ -170,6 +172,7 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		const mod = await import("./packages/jev-judge/src/auto-continue.js");
 		const { createPendingQuestionController } = await import("./packages/notification/dist/index.js");
 		const pqController = createPendingQuestionController();
+		sharedState.pqController = pqController;
 
 		// Track waiting state
 		let waitingForUserSince: Date | null = null;
@@ -461,6 +464,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 					waitingForUserSince = null;
 					_lastNotifiedQuestion = "";
 					updateAutoContinueStatus("IDLE");
+					// Cancel pending question on user response
+					// (User answered via Pi instead of button)
+					sharedState.pqController?.cancel("User responded via Pi");
 				}
 			}
 		});
@@ -523,6 +529,8 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 
 				// Check session validity and user response before applying
 				if (checkSessionId !== _sessionId) {
+					// Session changed - cancel pending question
+					sharedState.pqController?.cancel("Session switched");
 					_inferenceInProgress = false;
 					updateAutoContinueStatus("IDLE");
 					return;
@@ -1199,12 +1207,16 @@ async function initTelegram(pi: ExtensionAPI): Promise<void> {
 					logToFile("[TelegramCallback] Approved - user clicked Continue, resuming work");
 					sharedState.waitingForUserSince = null;
 					sharedState.updateAutoContinueStatus?.("IDLE");
+					// Resolve pending question with yes
+					sharedState.pqController?.resolve({ resolution: "yes", by: "user" });
 					// Also resume continuation controller
 					(sharedState.todoContinuationController as any)?.resume?.();
 					break;
 				case CallbackActions.REJECT:
 					// User clicked Not yet - just dismiss, don't resume
 					logToFile("[TelegramCallback] Rejected - user clicked Not yet, pausing");
+					// Resolve pending question with no
+					sharedState.pqController?.resolve({ resolution: "no", by: "user" });
 					// Explicitly pause the continuation
 					(sharedState.todoContinuationController as any)?.explicitPause?.();
 					break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",

package/packages/agent-policy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/agent-policy",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Agent policy runtime for pi-harness - enforces mandatory rule delivery and mutation gating",
   "type": "module",
   "main": "./dist/index.js",

package/packages/architecture-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/architecture-generator",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Generate ADR and Mermaid diagrams from project analysis",
   "type": "module",
   "main": "./dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-refactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-refactor",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "description": "Autonomous refactoring engine",
   "main": "dist/index.js",

package/packages/autonomous-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-runtime",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cache-strategy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/cache-strategy",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "description": "Smart caching with TTL and invalidation strategies (RFC-0022)",
   "main": "dist/index.js",

package/packages/capability-registry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/capability-registry",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Capability Registry for pi-harness-runtime — tracks model capabilities and enables capability-based routing",
   "type": "module",
   "main": "./dist/index.js",

package/packages/checkpoint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/checkpoint",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Enhanced checkpoint system with incremental snapshots, diff-based storage, and recovery strategies",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cli-plugin-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/cli-plugin-sdk",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "description": "CLI Plugin SDK for pi-harness — install, list, remove, update, invoke plugins",
   "main": "dist/index.js",

package/packages/clipboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/clipboard-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard-plugin",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/code-generation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/code-generation",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Code generation pipeline for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/code-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/code-review",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Automated code review engine for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/codex-adapter",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "description": "OpenAI Codex provider adapter for pi-harness",
   "main": "dist/index.js",

package/packages/codex-watcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/codex-watcher",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Watches Codex CLI sessions and emits visible messages for PING-PONG monitoring",
   "type": "module",
   "main": "./dist/src/index.js",

package/packages/config-capture/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/config-capture",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Auto-capture API-fetched configuration values to AGENTS.md",
   "type": "module",
   "main": "src/index.ts",

package/packages/connection-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/connection-runtime",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "description": "Connection management with jittered exponential backoff for pi-harness",
   "main": "./dist/index.js",

package/packages/context-compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/context-compiler",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Bounded context selection engine for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/context-discovery/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/context-discovery",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/context-manager/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/context-manager",
-  "version": "1.1.348",
+  "version": "1.1.350",
   "description": "Context Window Manager — prevents model context overflow via compaction and resume prompts (RFC-0010)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/contracts/dist/delegation-assessor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Delegation Assessor
+ *
+ * Assesses whether work should be delegated to sub-agents based on scope.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ScopeFacts, DelegationDecision, DelegationTriggerConfig, ExtensionCapability } from "./delegation.js";
+/**
+ * Discover extension capabilities for delegation
+ */
+export declare function discoverDelegationCapability(pi: ExtensionAPI): Promise<ExtensionCapability | null>;
+/**
+ * Estimate scope from file analysis
+ */
+export declare function estimateScope(_pi: ExtensionAPI, patterns: string[]): Promise<ScopeFacts>;
+/**
+ * Make deterministic assessment without Jev
+ */
+export declare function makeDeterministicAssessment(facts: ScopeFacts, capability: ExtensionCapability | null): DelegationDecision;
+/**
+ * Assess delegation need
+ */
+export declare function assessDelegation(pi: ExtensionAPI, facts: ScopeFacts, config?: DelegationTriggerConfig): Promise<DelegationDecision | null>;
+/**
+ * Validate assessment is still valid
+ */
+export declare function isAssessmentStale(decision: DelegationDecision, currentFacts: ScopeFacts, originalFacts: ScopeFacts): boolean;

package/packages/contracts/dist/delegation-assessor.js

@@ -0,0 +1,210 @@
+/**
+ * Delegation Assessor
+ *
+ * Assesses whether work should be delegated to sub-agents based on scope.
+ */
+import { shouldTriggerAssessment } from "./delegation.js";
+/**
+ * Sub-agent extension names to check for
+ */
+const SUBAGENT_EXTENSIONS = [
+    "pi-subagents",
+    "@earendil-works/pi-subagents",
+    "subagent",
+    "spawn",
+    "delegate",
+];
+/**
+ * Tool names that indicate sub-agent capability
+ */
+const SUBAGENT_TOOLS = [
+    "subagent",
+    "spawn",
+    "delegate",
+    "run_subagent",
+    "run_agent",
+];
+/**
+ * Discover extension capabilities for delegation
+ */
+export async function discoverDelegationCapability(pi) {
+    // Get all available tools
+    const allTools = pi.getAllTools();
+    const toolNames = allTools.map((t) => t.name);
+    const activeTools = pi.getActiveTools();
+    // Check for sub-agent tools
+    const hasSubagentTool = SUBAGENT_TOOLS.some((tool) => toolNames.includes(tool) || activeTools.includes(tool));
+    // Check for subagent extension registration
+    // The extension might register tools under different names
+    const possibleCapabilities = [];
+    // Verify by attempting a capability check
+    // If subagent tools exist, assume capability
+    if (hasSubagentTool) {
+        return {
+            name: "subagent-extension",
+            supportsSubagents: true,
+            supportsWorkIsolation: true, // Assume based on tool presence
+            supportsCancellation: true,
+            availableTools: activeTools.filter((t) => SUBAGENT_TOOLS.some((st) => t.includes(st))),
+            verified: true,
+        };
+    }
+    // Check if pi-subagents skill is mentioned in available tools
+    const subagentMentioned = toolNames.some((t) => t.includes("subagent") || t.includes("spawn"));
+    if (subagentMentioned) {
+        return {
+            name: "pi-subagents",
+            supportsSubagents: true,
+            supportsWorkIsolation: true,
+            supportsCancellation: true,
+            availableTools: toolNames.filter((t) => t.includes("subagent")),
+            verified: false, // Not verified - just mentioned
+        };
+    }
+    return null;
+}
+/**
+ * Estimate scope from file analysis
+ */
+export async function estimateScope(_pi, patterns) {
+    // TODO: Implement actual file discovery
+    // For now, return placeholder
+    return {
+        estimatedFiles: patterns.length,
+        observedFiles: 0,
+        estimatedCallSites: 0,
+        observedCallSites: 0,
+        independentComponents: 1,
+        tightlyCoupled: false,
+        isMechanical: true,
+        isComplex: false,
+        fileTypes: {},
+        fingerprint: "",
+    };
+}
+/**
+ * Make deterministic assessment without Jev
+ */
+export function makeDeterministicAssessment(facts, capability) {
+    // No capability - must use single agent
+    if (!capability?.verified) {
+        return {
+            strategy: "unavailable",
+            reason: "No verified sub-agent capability available",
+            workGroups: [],
+            validationExpectations: "Parent handles all validation",
+            confidence: "high",
+            jevUsed: false,
+            reassessmentTriggers: ["Extension becomes available"],
+        };
+    }
+    // Small scope - single agent
+    if (facts.observedFiles < 5 && facts.observedCallSites < 20) {
+        return {
+            strategy: "single_agent",
+            reason: "Small scope - delegation overhead not justified",
+            workGroups: [],
+            validationExpectations: "Standard parent validation",
+            confidence: "high",
+            jevUsed: false,
+            reassessmentTriggers: [],
+        };
+    }
+    // Mechanical transformation with reliable script
+    if (facts.isMechanical && !facts.isComplex) {
+        return {
+            strategy: "script_only",
+            reason: "Mechanical transformation - script approach is reliable",
+            workGroups: [],
+            validationExpectations: "Script output validation + test run",
+            confidence: "high",
+            jevUsed: false,
+            reassessmentTriggers: ["Transformation proves unreliable"],
+        };
+    }
+    // Multiple independent components
+    if (facts.independentComponents >= 2 && !facts.tightlyCoupled) {
+        const groups = partitionIntoGroups(facts);
+        return {
+            strategy: "delegate",
+            reason: `${facts.independentComponents} independent components - delegation recommended`,
+            workGroups: groups,
+            validationExpectations: "Each group validated independently, then integrated",
+            confidence: "medium",
+            jevUsed: false,
+            reassessmentTriggers: ["Scope expands significantly", "Component coupling discovered"],
+        };
+    }
+    // Tightly coupled - sequential or single agent
+    if (facts.tightlyCoupled) {
+        return {
+            strategy: "script_then_delegate",
+            reason: "Coupled components - script shared parts, delegate isolated changes",
+            workGroups: [],
+            validationExpectations: "Script validates shared API, delegate validates components",
+            confidence: "medium",
+            jevUsed: false,
+            reassessmentTriggers: ["Coupling reduced after refactoring"],
+        };
+    }
+    // Default - single agent with monitoring
+    return {
+        strategy: "single_agent",
+        reason: "Default to single agent for bounded scope",
+        workGroups: [],
+        validationExpectations: "Parent validates all changes",
+        confidence: "low",
+        jevUsed: false,
+        reassessmentTriggers: ["Scope exceeds threshold"],
+    };
+}
+/**
+ * Partition work into groups
+ */
+function partitionIntoGroups(facts) {
+    const groups = [];
+    const filesPerGroup = Math.ceil(facts.observedFiles / facts.independentComponents);
+    for (let i = 0; i < facts.independentComponents; i++) {
+        groups.push({
+            groupId: `group-${i + 1}`,
+            description: `Component ${i + 1} of ${facts.independentComponents}`,
+            ownedPaths: [], // TODO: Populate with actual files
+            isMechanical: facts.isMechanical,
+            status: "pending",
+        });
+    }
+    return groups;
+}
+/**
+ * Assess delegation need
+ */
+export async function assessDelegation(pi, facts, config = { minFiles: 10, minCallSites: 50, minIndependentComponents: 2, assessOnDiscovery: true }) {
+    // Check if assessment should trigger
+    if (!shouldTriggerAssessment(facts, config)) {
+        return null; // No assessment needed
+    }
+    // Discover capability
+    const capability = await discoverDelegationCapability(pi);
+    // Make deterministic assessment
+    return makeDeterministicAssessment(facts, capability);
+}
+/**
+ * Validate assessment is still valid
+ */
+export function isAssessmentStale(decision, currentFacts, originalFacts) {
+    // Scope significantly expanded
+    if (currentFacts.observedFiles > originalFacts.observedFiles * 1.5) {
+        return true;
+    }
+    // New coupling discovered
+    if (currentFacts.tightlyCoupled && !originalFacts.tightlyCoupled) {
+        return true;
+    }
+    // Reassessment triggers
+    return decision.reassessmentTriggers.some((trigger) => {
+        if (trigger.includes("scope expands")) {
+            return currentFacts.observedFiles > originalFacts.observedFiles * 1.5;
+        }
+        return false;
+    });
+}

package/packages/contracts/dist/delegation.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Delegation Assessment Types
+ *
+ * Types for consistent delegation assessment for large refactors.
+ */
+/**
+ * Scope estimation for a refactoring task
+ */
+export interface ScopeFacts {
+    /** Estimated number of relevant files affected */
+    estimatedFiles: number;
+    /** Actual observed number of files (after scanning) */
+    observedFiles: number;
+    /** Estimated number of call sites/changes */
+    estimatedCallSites: number;
+    /** Actual observed call sites */
+    observedCallSites: number;
+    /** Number of independent components/groups */
+    independentComponents: number;
+    /** Whether changes are tightly coupled (shared APIs) */
+    tightlyCoupled: boolean;
+    /** Whether transformation is mechanical (safe for scripts) */
+    isMechanical: boolean;
+    /** Whether transformation is complex (needs reasoning) */
+    isComplex: boolean;
+    /** File type breakdown */
+    fileTypes: Record<string, number>;
+    /** Scope fingerprint for change detection */
+    fingerprint: string;
+}
+/**
+ * Delegation strategy decision
+ */
+export type DelegationStrategy = "delegate" | "script_then_delegate" | "script_only" | "single_agent" | "unavailable";
+/**
+ * Work group for delegation
+ */
+export interface WorkGroup {
+    /** Unique group ID */
+    groupId: string;
+    /** Human-readable description */
+    description: string;
+    /** Files owned by this group */
+    ownedPaths: string[];
+    /** Whether this group is mechanical (script-friendly) */
+    isMechanical: boolean;
+    /** Assigned child agent ID (if delegated) */
+    childId?: string;
+    /** Status of this group */
+    status: "pending" | "dispatched" | "running" | "completed" | "failed" | "cancelled";
+    /** Validation evidence */
+    validation?: {
+        passed: boolean;
+        details: string;
+    };
+}
+/**
+ * Delegation decision from Jev or fallback
+ */
+export interface DelegationDecision {
+    /** Strategy selected */
+    strategy: DelegationStrategy;
+    /** Reason for the decision */
+    reason: string;
+    /** Proposed work groups (for delegate strategies) */
+    workGroups: WorkGroup[];
+    /** Validation expectations */
+    validationExpectations: string;
+    /** Confidence level */
+    confidence: "high" | "medium" | "low";
+    /** Whether Jev was used */
+    jevUsed: boolean;
+    /** Reassessment triggers */
+    reassessmentTriggers: string[];
+}
+/**
+ * Delegation receipt for persistence
+ */
+export interface DelegationReceipt {
+    /** Version for schema compatibility */
+    version: number;
+    /** Workspace canonical path */
+    workspacePath: string;
+    /** Session ID */
+    sessionId: string;
+    /** Parent task ID */
+    parentTaskId: string;
+    /** Scope fingerprint */
+    scopeFingerprint: string;
+    /** Decision made */
+    decision: DelegationDecision;
+    /** Created timestamp */
+    createdAt: number;
+    /** Last updated timestamp */
+    updatedAt: number;
+    /** Status */
+    status: "assessing" | "in_progress" | "completed" | "failed" | "cancelled";
+    /** Active child IDs */
+    childIds: string[];
+    /** Outstanding validation items */
+    pendingValidation: string[];
+    /** User constraints (e.g., no delegation) */
+    userConstraints: string[];
+}
+/**
+ * Delegation assessment trigger config
+ */
+export interface DelegationTriggerConfig {
+    /** Minimum files to trigger assessment */
+    minFiles: number;
+    /** Minimum call sites to trigger assessment */
+    minCallSites: number;
+    /** Minimum independent components to suggest delegation */
+    minIndependentComponents: number;
+    /** Whether to assess on scope discovery vs mutation */
+    assessOnDiscovery: boolean;
+}
+/**
+ * Default trigger config
+ */
+export declare const DEFAULT_DELEGATION_TRIGGERS: DelegationTriggerConfig;
+/**
+ * Extension capability for delegation
+ */
+export interface ExtensionCapability {
+    /** Extension name */
+    name: string;
+    /** Whether it supports sub-agents */
+    supportsSubagents: boolean;
+    /** Whether it supports work isolation */
+    supportsWorkIsolation: boolean;
+    /** Whether it supports cancellation */
+    supportsCancellation: boolean;
+    /** Supported tool names */
+    availableTools: string[];
+    /** Verified working */
+    verified: boolean;
+}
+/**
+ * Check if delegation should be triggered
+ */
+export declare function shouldTriggerAssessment(facts: ScopeFacts, config?: DelegationTriggerConfig): boolean;

package/packages/contracts/dist/delegation.js

@@ -0,0 +1,33 @@
+/**
+ * Delegation Assessment Types
+ *
+ * Types for consistent delegation assessment for large refactors.
+ */
+/**
+ * Default trigger config
+ */
+export const DEFAULT_DELEGATION_TRIGGERS = {
+    minFiles: 10,
+    minCallSites: 50,
+    minIndependentComponents: 2,
+    assessOnDiscovery: true,
+};
+/**
+ * Check if delegation should be triggered
+ */
+export function shouldTriggerAssessment(facts, config = DEFAULT_DELEGATION_TRIGGERS) {
+    // Check file count
+    if (facts.observedFiles >= config.minFiles)
+        return true;
+    if (facts.estimatedFiles >= config.minFiles)
+        return true;
+    // Check call sites
+    if (facts.observedCallSites >= config.minCallSites)
+        return true;
+    if (facts.estimatedCallSites >= config.minCallSites)
+        return true;
+    // Check independent components
+    if (facts.independentComponents >= config.minIndependentComponents)
+        return true;
+    return false;
+}