pi-harness-runtime 1.1.349 → 1.1.351

package/packages/contracts/dist/work-partitioner.js

@@ -0,0 +1,165 @@
+/**
+ * Work Partitioner
+ *
+ * Partitions work into disjoint file ownership groups.
+ */
+/**
+ * Default partition config
+ */
+export const DEFAULT_PARTITION_CONFIG = {
+    maxFilesPerGroup: 15,
+    groupByDirectory: true,
+    sharedPaths: [
+        "index.ts",
+        "index.js",
+        "main.ts",
+        "main.js",
+        "package.json",
+        "tsconfig.json",
+    ],
+};
+/**
+ * Partition files into ownership groups
+ */
+export function partitionWork(files, facts, config = {}) {
+    const cfg = { ...DEFAULT_PARTITION_CONFIG, ...config };
+    // Filter out shared paths
+    const ownedFiles = files.filter((f) => !cfg.sharedPaths.some((s) => f.endsWith(s)));
+    // Group files by directory
+    const dirGroups = groupByDirectory(ownedFiles);
+    // Further partition large groups
+    const groups = [];
+    let groupId = 1;
+    for (const [dir, dirFiles] of Object.entries(dirGroups)) {
+        if (dirFiles.length <= cfg.maxFilesPerGroup) {
+            groups.push(createGroup(groupId++, dir, dirFiles, facts.isMechanical));
+        }
+        else {
+            // Split large directories
+            const subGroups = splitGroup(dirFiles, cfg.maxFilesPerGroup);
+            for (const subFiles of subGroups) {
+                groups.push(createGroup(groupId++, dir, subFiles, facts.isMechanical));
+            }
+        }
+    }
+    return groups;
+}
+/**
+ * Group files by directory
+ */
+function groupByDirectory(files) {
+    const groups = {};
+    for (const file of files) {
+        // Get directory part of path
+        const parts = file.split("/");
+        const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
+        if (!groups[dir]) {
+            groups[dir] = [];
+        }
+        groups[dir].push(file);
+    }
+    return groups;
+}
+/**
+ * Create a work group
+ */
+function createGroup(id, description, files, isMechanical) {
+    return {
+        groupId: `group-${id}`,
+        description: `${description} (${files.length} files)`,
+        ownedPaths: files,
+        isMechanical,
+        status: "pending",
+    };
+}
+/**
+ * Split a group into smaller subgroups
+ */
+function splitGroup(files, maxSize) {
+    const subgroups = [];
+    for (let i = 0; i < files.length; i += maxSize) {
+        subgroups.push(files.slice(i, i + maxSize));
+    }
+    return subgroups;
+}
+/**
+ * Detect ownership conflicts
+ */
+export function detectOwnershipConflicts(groups, newPaths) {
+    const conflicts = [];
+    for (const path of newPaths) {
+        for (const group of groups) {
+            if (group.status !== "cancelled" &&
+                group.status !== "failed" &&
+                group.ownedPaths.includes(path)) {
+                conflicts.push(`${path} already owned by ${group.groupId}`);
+            }
+        }
+    }
+    return conflicts;
+}
+/**
+ * Assign work to group
+ */
+export function assignWorkToGroup(groups, groupId, paths) {
+    const group = groups.find((g) => g.groupId === groupId);
+    if (!group) {
+        return null;
+    }
+    // Check for conflicts
+    const conflicts = detectOwnershipConflicts(groups.filter((g) => g.groupId !== groupId), paths);
+    if (conflicts.length > 0) {
+        // Return group with conflict info
+        return {
+            ...group,
+            status: "failed",
+        };
+    }
+    return {
+        ...group,
+        ownedPaths: [...new Set([...group.ownedPaths, ...paths])],
+    };
+}
+/**
+ * Get unowned files
+ */
+export function getUnownedFiles(allFiles, groups) {
+    const ownedFiles = new Set();
+    for (const group of groups) {
+        if (group.status !== "cancelled" && group.status !== "failed") {
+            for (const path of group.ownedPaths) {
+                ownedFiles.add(path);
+            }
+        }
+    }
+    return allFiles.filter((f) => !ownedFiles.has(f));
+}
+/**
+ * Update group status
+ */
+export function updateGroupStatus(groups, groupId, status, childId) {
+    return groups.map((g) => {
+        if (g.groupId !== groupId) {
+            return g;
+        }
+        return {
+            ...g,
+            status,
+            childId: childId || g.childId,
+        };
+    });
+}
+/**
+ * Check if all groups are complete
+ */
+export function areAllGroupsComplete(groups) {
+    return groups.every((g) => g.status === "completed" ||
+        g.status === "failed" ||
+        g.status === "cancelled");
+}
+/**
+ * Get pending groups
+ */
+export function getPendingGroups(groups) {
+    return groups.filter((g) => g.status === "pending");
+}

package/packages/contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/contracts",
-  "version": "1.1.349",
+  "version": "1.1.351",
   "type": "module",
   "description": "RPC schema definitions for pi-harness runtime",
   "main": "./dist/index.js",

package/packages/contracts/src/delegation-assessor.ts

@@ -0,0 +1,268 @@
+/**
+ * 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,
+  DelegationStrategy,
+  WorkGroup,
+  DelegationTriggerConfig,
+  ExtensionCapability,
+  DEFAULT_DELEGATION_TRIGGERS,
+} from "./delegation.js";
+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: ExtensionAPI
+): Promise<ExtensionCapability | null> {
+  // 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: ExtensionCapability[] = [];
+
+  // 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: ExtensionAPI,
+  patterns: string[]
+): Promise<ScopeFacts> {
+  // 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: ScopeFacts,
+  capability: ExtensionCapability | null
+): DelegationDecision {
+  // 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: ScopeFacts): WorkGroup[] {
+  const groups: WorkGroup[] = [];
+  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: ExtensionAPI,
+  facts: ScopeFacts,
+  config: DelegationTriggerConfig = { minFiles: 10, minCallSites: 50, minIndependentComponents: 2, assessOnDiscovery: true }
+): Promise<DelegationDecision | null> {
+  // 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: DelegationDecision,
+  currentFacts: ScopeFacts,
+  originalFacts: ScopeFacts
+): boolean {
+  // 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/src/delegation-store.ts

@@ -0,0 +1,204 @@
+/**
+ * Delegation Store
+ * 
+ * Durable storage for delegation receipts.
+ * Stores in ignored harness state directory.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { DelegationReceipt } from "./delegation.js";
+
+/**
+ * Store directory path
+ */
+const STORE_DIR = join(process.env.HOME || "/home/frappe", ".pi-harness-runtime", "delegation-state");
+
+/**
+ * Ensure store directory exists
+ */
+function ensureStoreDir(): void {
+  if (!existsSync(STORE_DIR)) {
+    mkdirSync(STORE_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get receipt file path for workspace + task
+ */
+function getReceiptPath(workspacePath: string, taskId: string): string {
+  // Sanitize path for use as filename
+  const safePath = workspacePath.replace(/[^a-zA-Z0-9_-]/g, "_").slice(-100);
+  const safeTask = taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join(STORE_DIR, `${safePath}__${safeTask}.json`);
+}
+
+/**
+ * Save delegation receipt
+ */
+export function saveDelegationReceipt(receipt: DelegationReceipt): void {
+  ensureStoreDir();
+  const path = getReceiptPath(receipt.workspacePath, receipt.parentTaskId);
+  
+  // Atomic write: write to temp, then rename
+  const tempPath = path + ".tmp";
+  writeFileSync(tempPath, JSON.stringify(receipt, null, 2), "utf8");
+  
+  // Rename is atomic on POSIX
+  try {
+    const { renameSync } = require("fs");
+    renameSync(tempPath, path);
+  } catch {
+    // Fallback: just move the file
+    try {
+      writeFileSync(path, JSON.stringify(receipt, null, 2), "utf8");
+    } catch {
+      // Ignore write errors
+    }
+  }
+}
+
+/**
+ * Load delegation receipt
+ */
+export function loadDelegationReceipt(
+  workspacePath: string,
+  taskId: string
+): DelegationReceipt | null {
+  const path = getReceiptPath(workspacePath, taskId);
+  
+  if (!existsSync(path)) {
+    return null;
+  }
+  
+  try {
+    const content = readFileSync(path, "utf8");
+    const receipt = JSON.parse(content) as DelegationReceipt;
+    
+    // Validate version
+    if (receipt.version !== 1) {
+      // Future migration logic would go here
+      return null;
+    }
+    
+    return receipt;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Delete delegation receipt
+ */
+export function deleteDelegationReceipt(
+  workspacePath: string,
+  taskId: string
+): void {
+  const path = getReceiptPath(workspacePath, taskId);
+  
+  if (existsSync(path)) {
+    try {
+      const { unlinkSync } = require("fs");
+      unlinkSync(path);
+    } catch {
+      // Ignore delete errors
+    }
+  }
+}
+
+/**
+ * List all receipts for a workspace
+ */
+export function listDelegationReceipts(workspacePath: string): DelegationReceipt[] {
+  ensureStoreDir();
+  const receipts: DelegationReceipt[] = [];
+  
+  try {
+    const { readdirSync } = require("fs");
+    const files = readdirSync(STORE_DIR);
+    
+    const safePathPrefix = workspacePath.replace(/[^a-zA-Z0-9_-]/g, "_").slice(-100) + "__";
+    
+    for (const file of files) {
+      if (!file.startsWith(safePathPrefix) || !file.endsWith(".json")) {
+        continue;
+      }
+      
+      try {
+        const content = readFileSync(join(STORE_DIR, file), "utf8");
+        const receipt = JSON.parse(content) as DelegationReceipt;
+        if (receipt.workspacePath === workspacePath) {
+          receipts.push(receipt);
+        }
+      } catch {
+        // Skip invalid files
+      }
+    }
+  } catch {
+    // Directory doesn't exist or not readable
+  }
+  
+  return receipts;
+}
+
+/**
+ * Update receipt status
+ */
+export function updateReceiptStatus(
+  workspacePath: string,
+  taskId: string,
+  status: DelegationReceipt["status"],
+  updates?: Partial<DelegationReceipt>
+): DelegationReceipt | null {
+  const receipt = loadDelegationReceipt(workspacePath, taskId);
+  
+  if (!receipt) {
+    return null;
+  }
+  
+  const updated: DelegationReceipt = {
+    ...receipt,
+    ...updates,
+    status,
+    updatedAt: Date.now(),
+  };
+  
+  saveDelegationReceipt(updated);
+  return updated;
+}
+
+/**
+ * Check if receipt exists for task
+ */
+export function hasReceipt(workspacePath: string, taskId: string): boolean {
+  const path = getReceiptPath(workspacePath, taskId);
+  return existsSync(path);
+}
+
+/**
+ * Compact receipt for storage after compaction
+ */
+export function compactReceipt(receipt: DelegationReceipt): DelegationReceipt {
+  return {
+    version: receipt.version,
+    workspacePath: receipt.workspacePath,
+    sessionId: receipt.sessionId,
+    parentTaskId: receipt.parentTaskId,
+    scopeFingerprint: receipt.scopeFingerprint,
+    decision: {
+      strategy: receipt.decision.strategy,
+      reason: receipt.decision.reason,
+      workGroups: receipt.decision.workGroups.filter((g) => g.status === "pending" || g.status === "dispatched" || g.status === "running"),
+      validationExpectations: receipt.decision.validationExpectations,
+      confidence: receipt.decision.confidence,
+      jevUsed: receipt.decision.jevUsed,
+      reassessmentTriggers: receipt.decision.reassessmentTriggers,
+    },
+    createdAt: receipt.createdAt,
+    updatedAt: Date.now(),
+    status: receipt.status,
+    childIds: receipt.childIds,
+    pendingValidation: receipt.pendingValidation,
+    userConstraints: receipt.userConstraints,
+  };
+}