pi-harness-runtime 1.1.0 → 1.1.2

package/packages/todo-bd-sync/src/task-analyzer.ts

@@ -0,0 +1,314 @@
+/**
+ * Smart Auto-Todo Task Analyzer
+ *
+ * Decides when to automatically create bd issues based on:
+ * 1. Task complexity signals
+ * 2. Session state (pending task count)
+ *
+ * Philosophy:
+ * - Simple tasks (grep, quick edit) -> NO todo (avoid noise)
+ * - Complex tasks OR multiple pending tasks -> AUTO-CREATE todo
+ */
+
+import { getOpenBdIssues } from "./sync.js";
+
+// ─── Complexity Signals ─────────────────────────────────────────────────────────
+
+interface TaskSignals {
+	/** Estimated number of steps required */
+	stepCount: number;
+	/** Number of files likely involved */
+	fileCount: number;
+	/** Requires research (web search, docs lookup) */
+	needsResearch: boolean;
+	/** Creates new files */
+	createsFiles: boolean;
+	/** User explicitly says task is complex */
+	explicitlyComplex: boolean;
+	/** Likely to have subtasks discovered during work */
+	likelySubtasks: boolean;
+}
+
+const COMPLEX_KEYWORDS = [
+	"complicated",
+	"complex",
+	"tricky",
+	"difficult",
+	"refactor",
+	"architecture",
+	"design",
+	"implement from scratch",
+	"rewrite",
+	"investigate",
+	"debug",
+	"fix the bug",
+	"performance",
+];
+
+const RESEARCH_KEYWORDS = [
+	"search",
+	"look up",
+	"find",
+	"research",
+	"check",
+	"verify",
+	"how to",
+	"best practice",
+	"compare",
+	"evaluate",
+	"review",
+];
+
+const SUBTASK_KEYWORDS = [
+	"also",
+	"plus",
+	"and also",
+	"while you're at it",
+	"on top of that",
+	"additionally",
+	"another thing",
+	"don't forget",
+	"should also",
+];
+
+/**
+ * Analyze user request text for complexity signals
+ */
+export function analyzeTaskSignals(userMessage: string): TaskSignals {
+	const lower = userMessage.toLowerCase();
+
+	// Count implied steps from action verbs
+	const actionVerbs = [
+		"create",
+		"build",
+		"implement",
+		"design",
+		"setup",
+		"configure",
+		"migrate",
+		"convert",
+		"refactor",
+		"optimize",
+		"fix",
+		"update",
+		"add",
+		"remove",
+		"delete",
+		"modify",
+		"change",
+		"replace",
+	];
+	const stepCount = Math.max(
+		1,
+		actionVerbs.filter((v) => lower.includes(v)).length,
+	);
+
+	// Estimate file count from file paths and extensions
+	const filePatterns =
+		/[\w-]+\.(ts|js|py|json|md|yaml|yml|tsx|jsx|html|css|sql)/g;
+	const fileMatches = userMessage.match(filePatterns) || [];
+	const explicitFiles = fileMatches.length;
+
+	// Check for directory patterns
+	const dirPatterns =
+		/(?:src|lib|packages|apps|components|hooks|utils|api)\/[\w/-]+/g;
+	const dirMatches = userMessage.match(dirPatterns) || [];
+
+	// Count "and", "also", "+" for multi-task indicators
+	const multiTaskIndicator = (lower.match(/and also|also|\+/g) || []).length;
+	const estimatedFiles = Math.max(
+		1,
+		explicitFiles + dirMatches.length + multiTaskIndicator,
+	);
+
+	return {
+		stepCount,
+		fileCount: estimatedFiles,
+		needsResearch: RESEARCH_KEYWORDS.some((k) => lower.includes(k)),
+		createsFiles:
+			lower.includes("create") ||
+			lower.includes("add") ||
+			lower.includes("new"),
+		explicitlyComplex: COMPLEX_KEYWORDS.some((k) => lower.includes(k)),
+		likelySubtasks:
+			SUBTASK_KEYWORDS.some((k) => lower.includes(k)) ||
+			multiTaskIndicator >= 2,
+	};
+}
+
+// ─── Decision Logic ───────────────────────────────────────────────────────────
+
+export interface AutoTodoDecision {
+	shouldCreate: boolean;
+	reason: string;
+	confidence: "high" | "medium" | "low";
+	skipReason?: string;
+}
+
+/**
+ * Decide whether to auto-create a todo for the given task
+ */
+export function decideAutoTodo(
+	userMessage: string,
+	options: {
+		forceMode?: boolean;
+		skipMode?: boolean;
+	} = {},
+): AutoTodoDecision {
+	const signals = analyzeTaskSignals(userMessage);
+	const pendingTasks = getOpenBdIssues().filter((i) => i.status !== "closed");
+	const pendingCount = pendingTasks.length;
+
+	// ── Skip Conditions ────────────────────────────────────────────────────
+	// Never create todos for these
+
+	const simplePatterns = [
+		/^simply\s/i,
+		/^just\s/i,
+		/^quick\s/i,
+		/^can you\s+(grep|find|cat|ls|echo)/i,
+		/^(grep|find|cat|ls)\s+[\w.-]+/i,
+		/^what('s| is) the\s+\w+\s+\?$/i,
+		/^how do i\s+\w+\s*\?$/i,
+	];
+
+	if (simplePatterns.some((p) => p.test(userMessage.trim()))) {
+		return {
+			shouldCreate: false,
+			reason: "Simple request (lookup/one-liner)",
+			confidence: "high",
+			skipReason: "Task is too simple to warrant tracking",
+		};
+	}
+
+	// Check for trivial single actions with no complexity (lower threshold)
+	// Allow more tasks to be tracked - being conservative about NOT tracking
+	const isTrivial =
+		signals.stepCount === 1 &&
+		signals.fileCount <= 1 &&
+		!signals.needsResearch &&
+		!signals.createsFiles &&
+		!signals.explicitlyComplex &&
+		pendingCount === 0 &&
+		!signals.likelySubtasks;
+	if (isTrivial) {
+		return {
+			shouldCreate: false,
+			reason: "Trivial request (single action)",
+			confidence: "high",
+			skipReason: "Task is trivial",
+		};
+	}
+
+	// ── Force Modes ──────────────────────────────────────────────────────
+	if (options.forceMode) {
+		return {
+			shouldCreate: true,
+			reason: "Force mode enabled",
+			confidence: "high",
+		};
+	}
+
+	if (options.skipMode) {
+		return {
+			shouldCreate: false,
+			reason: "Skip mode enabled",
+			confidence: "high",
+			skipReason: "User requested skip",
+		};
+	}
+
+	// ── Auto-Create Conditions ──────────────────────────────────────────
+	// Be MORE aggressive about tracking tasks - default to tracking
+	const reasons: string[] = [];
+
+	// HIGH CONFIDENCE: Task explicitly complex
+	if (signals.explicitlyComplex) {
+		reasons.push("explicitly complex");
+	}
+
+	// HIGH CONFIDENCE: Multiple steps (lower from 3 to 2)
+	if (signals.stepCount >= 2) {
+		reasons.push(`${signals.stepCount} steps implied`);
+	}
+
+	// HIGH CONFIDENCE: Multiple files (lower from 3 to 2)
+	if (signals.fileCount >= 2) {
+		reasons.push(`${signals.fileCount} files involved`);
+	}
+
+	// MEDIUM CONFIDENCE: Research needed
+	if (signals.needsResearch) {
+		reasons.push("needs research");
+	}
+
+	// MEDIUM CONFIDENCE: Creates files
+	if (signals.createsFiles) {
+		reasons.push("creates files");
+	}
+
+	// MEDIUM CONFIDENCE: Likely subtasks
+	if (signals.likelySubtasks) {
+		reasons.push("likely has subtasks");
+	}
+
+	// MEDIUM CONFIDENCE: Has pending tasks already (session busy)
+	if (pendingCount >= 1) {
+		reasons.push(`${pendingCount} pending tasks`);
+	}
+
+	// Default to creating todo if any signal present
+	// Be conservative only for truly trivial requests (already filtered above)
+	if (reasons.length === 0) {
+		// No strong signals but not trivial either - track it anyway
+		reasons.push("multi-step task detected");
+	}
+
+	// Create todo if ANY reason OR any pending tasks
+	const shouldCreate = reasons.length >= 1 || pendingCount >= 1;
+
+	return {
+		shouldCreate,
+		reason: reasons.join(", "),
+		confidence: reasons.length >= 2 ? "high" : "medium",
+	};
+}
+
+// ─── Quick Score ─────────────────────────────────────────────────────────────
+
+/**
+ * Quick numeric score (0-100) for task complexity
+ * Higher = more likely to need a todo
+ */
+export function getTaskComplexityScore(userMessage: string): number {
+	const signals = analyzeTaskSignals(userMessage);
+	const pendingTasks = getOpenBdIssues().filter((i) => i.status !== "closed");
+
+	let score = 0;
+
+	// Step count (0-25)
+	score += Math.min(25, signals.stepCount * 8);
+
+	// File count (0-20)
+	score += Math.min(20, signals.fileCount * 5);
+
+	// Research needed (0-15)
+	if (signals.needsResearch) score += 15;
+
+	// Creates files (0-10)
+	if (signals.createsFiles) score += 10;
+
+	// Explicitly complex (0-20)
+	if (signals.explicitlyComplex) score += 20;
+
+	// Likely subtasks (0-10)
+	if (signals.likelySubtasks) score += 10;
+
+	// Pending task overload (0-25)
+	const pendingCount = pendingTasks.length;
+	if (pendingCount >= 3) score += 25;
+	else if (pendingCount >= 2) score += 15;
+	else if (pendingCount >= 1) score += 5;
+
+	return Math.min(100, score);
+}

package/packages/token-estimation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/token-estimation",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "description": "pi-harness-runtime — token-estimation",
   "type": "module",
   "main": "./dist/index.js",

package/packages/token-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/token-optimizer",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "description": "Token Budget Optimizer — maximize prompt value within token limits (RFC-0011)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/tui/package.json

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

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/types",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "description": "Shared TypeScript types for pi-harness-runtime packages",
   "type": "module",
   "main": "./src/index.js",

package/packages/types/src/agent-worker-types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Agent Worker Interface — RFC-0030
+ *
+ * Common interface for all agent workers (Codex, MiniMax, GLM, GPT, DeepAgents).
+ * Runtime remains the orchestrator; agents are pluggable workers.
+ */
+import type { RuntimeTask } from "./runtime-types.js";
+export type AgentStatus = "idle" | "initializing" | "running" | "paused" | "stopped" | "error";
+export type TaskResultStatus = "success" | "failure" | "partial" | "cancelled";
+export interface AgentWorkerConfig {
+    /** Unique identifier for this worker instance */
+    readonly id: string;
+    /** Provider name (e.g., "codex", "minimax", "glm", "gpt", "deepagents") */
+    readonly provider: string;
+    /** API endpoint or connection string */
+    readonly endpoint?: string;
+    /** Authentication token */
+    readonly apiKey?: string;
+    /** Default model to use */
+    readonly defaultModel?: string;
+    /** Supported models */
+    readonly supportedModels?: string[];
+    /** Request timeout in ms */
+    readonly timeoutMs?: number;
+    /** Maximum concurrent tasks */
+    readonly maxConcurrency?: number;
+}
+export interface TaskRequest {
+    /** Task to execute */
+    task: RuntimeTask;
+    /** Working directory for the task */
+    workingDir: string;
+    /** Context/memory from previous tasks */
+    context?: string;
+    /** Additional configuration */
+    config?: {
+        model?: string;
+        temperature?: number;
+        maxTokens?: number;
+    };
+}
+export interface TaskResult {
+    /** Task ID */
+    taskId: string;
+    /** Result status */
+    status: TaskResultStatus;
+    /** Summary of what was done */
+    summary: string;
+    /** Files that were changed */
+    filesChanged?: string[];
+    /** Output from the task */
+    output?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Tokens used */
+    usage?: {
+        input: number;
+        output: number;
+        cost?: number;
+    };
+    /** Time taken in ms */
+    durationMs: number;
+    /** Timestamp */
+    completedAt: string;
+}
+export interface HealthStatus {
+    /** Whether the agent is healthy */
+    healthy: boolean;
+    /** Current status */
+    status: AgentStatus;
+    /** Current load (0-1) */
+    load: number;
+    /** Active task count */
+    activeTasks: number;
+    /** Queue depth */
+    queueDepth: number;
+    /** Last health check */
+    checkedAt: string;
+    /** Error message if unhealthy */
+    error?: string;
+}
+export interface AgentWorkerEvents {
+    /** Fired when task progress is made */
+    onProgress: (taskId: string, progress: TaskProgress) => void;
+    /** Fired when a task completes */
+    onTaskComplete: (result: TaskResult) => void;
+    /** Fired when an error occurs */
+    onError: (taskId: string, error: Error) => void;
+    /** Fired when agent status changes */
+    onStatusChange: (status: AgentStatus) => void;
+    /** Fired on health check changes */
+    onHealthChange: (health: HealthStatus) => void;
+}
+export interface TaskProgress {
+    taskId: string;
+    phase: "planning" | "executing" | "reviewing" | "finalizing";
+    message: string;
+    percentComplete: number;
+    timestamp: string;
+}
+export interface AgentWorker {
+    /** Unique identifier */
+    readonly id: string;
+    /** Provider name */
+    readonly provider: string;
+    /**
+     * Initialize the agent worker
+     * @param config Worker configuration
+     */
+    initialize(config: AgentWorkerConfig): Promise<void>;
+    /**
+     * Execute a task
+     * @param request Task request
+     * @param events Event handlers
+     * @returns Task result
+     */
+    execute(request: TaskRequest, events?: Partial<AgentWorkerEvents>): Promise<TaskResult>;
+    /**
+     * Check agent health
+     * @returns Health status
+     */
+    health(): Promise<HealthStatus>;
+    /**
+     * Get current status
+     * @returns Agent status
+     */
+    status(): AgentStatus;
+    /**
+     * Pause the agent (stop accepting new tasks)
+     */
+    pause(): Promise<void>;
+    /**
+     * Resume the agent
+     */
+    resume(): Promise<void>;
+    /**
+     * Stop the agent and cleanup
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if a model is supported
+     * @param model Model identifier
+     * @returns Whether the model is supported
+     */
+    supportsModel(model: string): boolean;
+    /**
+     * Get supported models
+     * @returns List of supported model identifiers
+     */
+    getSupportedModels(): string[];
+}
+export interface DeepAgentsConfig extends AgentWorkerConfig {
+    provider: "deepagents";
+    /** DeepAgents server URL */
+    endpoint: string;
+    /** Project path to work in */
+    projectPath?: string;
+    /** Additional DeepAgents options */
+    options?: {
+        streaming?: boolean;
+        autoRetry?: boolean;
+        maxRetries?: number;
+    };
+}
+export interface DeepAgentsTaskRequest extends TaskRequest {
+    config?: TaskRequest["config"] & {
+        /** Task priority */
+        priority?: "low" | "normal" | "high";
+        /** Whether to use sandbox */
+        sandbox?: boolean;
+        /** Environment variables */
+        env?: Record<string, string>;
+    };
+}
+export interface DeepAgentsResult extends TaskResult {
+    /** DeepAgents-specific metadata */
+    metadata?: {
+        agentId?: string;
+        workerId?: string;
+        sandboxUrl?: string;
+    };
+}
+export type AgentWorkerFactory = (config: AgentWorkerConfig) => AgentWorker;
+/**
+ * Registry of agent worker factories
+ */
+export declare class AgentWorkerRegistry {
+    private factories;
+    /**
+     * Register a worker factory
+     */
+    register(provider: string, factory: AgentWorkerFactory): void;
+    /**
+     * Create a worker for a provider
+     */
+    create(config: AgentWorkerConfig): AgentWorker | undefined;
+    /**
+     * Check if a provider is supported
+     */
+    supports(provider: string): boolean;
+    /**
+     * List all supported providers
+     */
+    listProviders(): string[];
+}
+//# sourceMappingURL=agent-worker-types.d.ts.map

package/packages/types/src/ai-providers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AI Provider Registry
+ *
+ * Centralized, canonical list of known AI/LLM providers used as keys across
+ * mirror.json, quota tracking, TUI signal parsing, and footer display.
+ *
+ * Adding a new provider = add ONE entry here + update the places that
+ * need per-provider behaviour (scraper, TUI parser, footer, etc.).
+ *
+ * Provider ids are lowercase internal keys.
+ * Labels are human-readable display strings.
+ */
+export declare const KNOWN_AI_PROVIDERS: readonly ["minimax", "openai", "anthropic", "glm", "openrouter", "openai-codex", "deepseek", "gemini", "kimi"];
+export type KnownAiProvider = (typeof KNOWN_AI_PROVIDERS)[number];
+/** Human-readable display labels (used in footer, notifications). */
+export declare const PROVIDER_LABELS: Record<string, string>;
+/**
+ * Providers that support continuous quota scraping via cookie/browser automation.
+ * Only MiniMax is currently supported here.
+ */
+export declare const SCRAPEABLE_PROVIDERS: KnownAiProvider[];
+/**
+ * Providers that report quota via TUI signal capture (one-shot on limit hit).
+ * These do NOT have a continuous scraping path.
+ */
+export declare const TUI_SIGNAL_PROVIDERS: KnownAiProvider[];
+/**
+ * Check if a provider id is a known AI provider.
+ */
+export declare function isKnownAiProvider(id: string): id is KnownAiProvider;
+/**
+ * Get the display label for a provider id.
+ * Falls back to the id itself if unknown.
+ */
+export declare function getProviderLabel(id: string): string;
+//# sourceMappingURL=ai-providers.d.ts.map

package/packages/types/src/runtime-types.d.ts

@@ -27,6 +27,10 @@ export interface RuntimeCheckpoint {
     provider?: string;
     resumeAt?: string;
     lastError?: string;
+    /** Provider that caused a quota pause (e.g. "minimax"). */
+    quotaProvider?: string;
+    /** Limit type that triggered the pause ("tokens" | "context_window" | etc.). */
+    quotaLimitType?: string;
     createdAt: string;
     updatedAt: string;
     /** Loop iteration at checkpoint (used by LoopRuntime for resume) */
@@ -409,4 +413,6 @@ export interface CompactOrchestratorCallbacks {
         droppedCount: number;
     }>;
 }
+export { KNOWN_AI_PROVIDERS, PROVIDER_LABELS, SCRAPEABLE_PROVIDERS, TUI_SIGNAL_PROVIDERS, isKnownAiProvider, getProviderLabel, } from "./ai-providers.js";
+export type { KnownAiProvider } from "./ai-providers.js";
 //# sourceMappingURL=runtime-types.d.ts.map

package/packages/workflow-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workflow-events",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/workspace-scanner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workspace-scanner",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/worktree/package.json

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

package/packages/worktree/src/worktree.ts

@@ -10,12 +10,9 @@
  * - allow separate models to work on separate tasks
  */
 
-import type { WorktreeInfo } from "../../packages/types/src/runtime-types.ts";
-// @ts-expect-error - Bun has built-in Node.js types
+import type { WorktreeInfo } from "../../types/src/runtime-types.js";
 import { execSync } from "node:child_process";
-// @ts-expect-error - Bun has built-in Node.js types
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
-// @ts-expect-error - Bun has built-in Node.js types
 import { join, dirname } from "node:path";
 
 export interface WorktreeOptions {

package/packages/write-review/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@moocoding/write-review",
+  "version": "0.10.30",
+  "description": "Two-agent write-review loop with blackboard coordination",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "keywords": [
+    "pi-extension",
+    "write-review",
+    "blackboard",
+    "multi-agent"
+  ],
+  "author": "MooCoding",
+  "license": "MIT"
+}