pi-harness-runtime 0.10.7 → 0.10.12

package/packages/tencentdb-sync/src/config.ts

@@ -0,0 +1,139 @@
+/**
+ * TencentDB Sync Config (RFC-0105/0106)
+ *
+ * Loads configuration from env vars or .pi/settings.json
+ */
+
+export interface SyncConfig {
+	// Server connection
+	serverUrl: string; // e.g., "https://your-memory-server.example.com"
+	knowledgeUrl: string; // e.g., "https://your-memory-server.example.com:8424"
+	userKey: string; // sk-mem-xxx
+	serviceId: string; // default
+
+	// Skills source
+	skillsSource: string; // e.g., "~/frappe-bench/.claude-plugins/moocoding-skills/skills"
+
+	// Sync options
+	autoSync: boolean;
+	syncIntervalMs: number;
+	watchMode: boolean;
+}
+
+const DEFAULT_CONFIG: Partial<SyncConfig> = {
+	serviceId: "default",
+	autoSync: false,
+	syncIntervalMs: 3600000, // 1 hour
+	watchMode: false,
+};
+
+/**
+ * Load config from environment variables
+ */
+export function loadConfigFromEnv(): Partial<SyncConfig> {
+	return {
+		serverUrl: process.env.TENANTDB_URL || process.env.MEMORY_SERVER_URL,
+		knowledgeUrl: process.env.TENANTDB_KNOWLEDGE_URL,
+		userKey: process.env.TENANTDB_USER_KEY || process.env.TENANTDB_KEY,
+		serviceId: process.env.TENANTDB_SERVICE_ID || "default",
+		skillsSource: process.env.TENANTDB_SKILLS_SOURCE,
+		autoSync: process.env.TENANTDB_AUTO_SYNC === "true",
+		syncIntervalMs: process.env.TENANTDB_SYNC_INTERVAL
+			? parseInt(process.env.TENANTDB_SYNC_INTERVAL) * 1000
+			: undefined,
+	};
+}
+
+/**
+ * Load config from .pi/settings.json
+ */
+export async function loadConfigFromSettings(): Promise<Partial<SyncConfig>> {
+	const fs = await import("node:fs");
+	const path = await import("node:path");
+	const homedir = process.env.HOME || process.env.USERPROFILE || "~";
+
+	const settingsPath = path.join(homedir, ".pi", "settings.json");
+
+	if (!fs.existsSync(settingsPath)) {
+		return {};
+	}
+
+	try {
+		const content = fs.readFileSync(settingsPath, "utf-8");
+		const settings = JSON.parse(content);
+
+		if (settings.tencentdb) {
+			return {
+				serverUrl: settings.tencentdb.url || settings.tencentdb.serverUrl,
+				knowledgeUrl: settings.tencentdb.knowledgeUrl,
+				userKey: settings.tencentdb.userKey || settings.tencentdb.key,
+				serviceId: settings.tencentdb.serviceId || "default",
+				skillsSource: settings.tencentdb.skillsSource,
+				autoSync: settings.tencentdb.autoSync,
+				syncIntervalMs: settings.tencentdb.syncIntervalMs
+					? settings.tencentdb.syncIntervalMs * 1000
+					: undefined,
+			};
+		}
+	} catch {
+		// Ignore parse errors
+	}
+
+	return {};
+}
+
+/**
+ * Merge configs (env > settings > defaults)
+ */
+export async function loadConfig(): Promise<SyncConfig> {
+	const defaults = DEFAULT_CONFIG;
+	const fromSettings = await loadConfigFromSettings();
+	const fromEnv = loadConfigFromEnv();
+
+	// Knowledge URL defaults to serverUrl if not specified
+	const serverUrl = fromEnv.serverUrl || fromSettings.serverUrl || "";
+	const knowledgeUrl =
+		fromEnv.knowledgeUrl ||
+		fromSettings.knowledgeUrl ||
+		`${serverUrl.replace(/:\d+$/, "")}:8424`;
+
+	return {
+		serverUrl,
+		knowledgeUrl,
+		userKey: fromEnv.userKey || fromSettings.userKey || "",
+		serviceId: fromEnv.serviceId || fromSettings.serviceId || "default",
+		skillsSource: fromEnv.skillsSource || fromSettings.skillsSource || "",
+		autoSync: fromEnv.autoSync ?? fromSettings.autoSync ?? defaults.autoSync!,
+		syncIntervalMs:
+			fromEnv.syncIntervalMs ||
+			fromSettings.syncIntervalMs ||
+			defaults.syncIntervalMs!,
+		watchMode:
+			fromEnv.watchMode ?? fromSettings.watchMode ?? defaults.watchMode!,
+	};
+}
+
+/**
+ * Validate config
+ */
+export function validateConfig(config: SyncConfig): string[] {
+	const errors: string[] = [];
+
+	if (!config.serverUrl) {
+		errors.push("TENANTDB_URL is required (set env var or .pi/settings.json)");
+	}
+
+	if (!config.userKey) {
+		errors.push(
+			"TENANTDB_USER_KEY is required (set env var or .pi/settings.json)",
+		);
+	}
+
+	if (!config.skillsSource) {
+		errors.push(
+			"TENANTDB_SKILLS_SOURCE is required (set env var or .pi/settings.json)",
+		);
+	}
+
+	return errors;
+}

package/packages/tencentdb-sync/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * TencentDB Sync (RFC-0105/0106)
+ *
+ * Syncs SKILL.md files to TencentDB-Agent-Memory server.
+ */
+
+export { createTencentDBClient, TencentDBClient } from "./client.js";
+export type {
+  Skill,
+  SkillSearchResult,
+  Knowledge,
+  HealthStatus,
+} from "./client.js";
+
+export { loadConfig, validateConfig, type SyncConfig } from "./config.js";

package/packages/todo-bd-sync/src/extension.ts

@@ -3,13 +3,15 @@
  *
  * This extension:
  * 1. Detects if bd is installed and initialized
- * 2. Auto-injects "add tasks to todo-list" when task is complex
+ * 2. Auto-injects todo tool call when task is complex
  * 3. Provides two-way sync between rpiv-todo and bd (via rpiv-todo)
- *
- * The magic phrase "add tasks to todo-list" triggers rpiv-todo to track the task.
  */
 
-import type { ExtensionAPI, InputEvent, InputEventResult } from "@earendil-works/pi-coding-agent";
+import type {
+	ExtensionAPI,
+	InputEvent,
+	InputEventResult,
+} from "@earendil-works/pi-coding-agent";
 import { getDependencyStatus } from "./detector.js";
 import { getOpenBdIssues } from "./sync.js";
 import { decideAutoTodo, getTaskComplexityScore } from "./task-analyzer.js";
@@ -60,8 +62,8 @@ Run the following command to initialize:
 	}
 
 	// ── Smart Auto-Todo Injection ──────────────────────────────────────────
-	// Listen to user input and inject "add tasks to todo-list" when needed
-	
+	// Listen to user input and inject todo tool call when task is complex
+
 	pi.on("input", (event: InputEvent): InputEventResult | undefined => {
 		// Only process user input (not from extensions or RPC)
 		if (event.source !== "interactive") {
@@ -69,23 +71,50 @@ Run the following command to initialize:
 		}
 
 		const text = event.text.trim();
-		if (!text || text.length < 10) {
+		if (!text || text.length < 5) {
 			return; // Skip very short inputs
 		}
 
-		const pendingCount = getOpenBdIssues().filter(i => i.status !== "closed").length;
+		const pendingCount = getOpenBdIssues().filter(
+			(i) => i.status !== "closed",
+		).length;
 		const decision = decideAutoTodo(text);
 
 		// If should create todo and phrase not already present
-		if (decision.shouldCreate && !text.toLowerCase().includes("add tasks to todo-list")) {
-			const score = getTaskComplexityScore(text);
-			console.log(`[auto-todo] Task detected: ${decision.reason} (score: ${score}/100, pending: ${pendingCount})`);
-			
-			// Transform the input to add the magic phrase
-			return {
-				action: "transform",
-				text: `${text}\n\nadd tasks to todo-list`,
-			};
+		if (decision.shouldCreate) {
+			// Check if already has explicit todo instruction
+			const hasExplicitTodo =
+				text.toLowerCase().includes("use the todo") ||
+				text.toLowerCase().includes("add to todo") ||
+				text.toLowerCase().includes("track as todo") ||
+				text.toLowerCase().includes("todo list") ||
+				text.toLowerCase().includes("create todo");
+
+			if (!hasExplicitTodo) {
+				const score = getTaskComplexityScore(text);
+				console.log(
+					`[auto-todo] Task detected: ${decision.reason} (score: ${score}/100, pending: ${pendingCount})`,
+				);
+
+				// Clearer instruction that explicitly tells LLM to use todo tool
+				// This is more direct than just adding text - it tells LLM to CALL the todo tool
+				const injection = `
+
+IMPORTANT: Use the \`todo\` tool to track this task:
+1. Create a todo item with subject: "${text.slice(0, 80)}${text.length > 80 ? "..." : ""}"
+2. Mark it as in_progress
+3. Track your progress as you work
+
+\`\`\`json
+{"action": "create", "subject": "${text.slice(0, 80)}${text.length > 80 ? "..." : ""}", "activeForm": "working on task"}
+\`\`\`
+`;
+
+				return {
+					action: "transform",
+					text: text + injection,
+				};
+			}
 		}
 
 		return;

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

@@ -30,19 +30,45 @@ interface TaskSignals {
 }
 
 const COMPLEX_KEYWORDS = [
-	"complicated", "complex", "tricky", "difficult", "refactor",
-	"architecture", "design", "implement from scratch", "rewrite",
-	"investigate", "debug", "fix the bug", "performance",
+	"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",
+	"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",
+	"also",
+	"plus",
+	"and also",
+	"while you're at it",
+	"on top of that",
+	"additionally",
+	"another thing",
+	"don't forget",
+	"should also",
 ];
 
 /**
@@ -53,32 +79,60 @@ export function analyzeTaskSignals(userMessage: string): TaskSignals {
 
 	// 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",
+		"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);
+	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 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 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);
+	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,
+		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,
 	};
 }
 
@@ -102,7 +156,7 @@ export function decideAutoTodo(
 	} = {},
 ): AutoTodoDecision {
 	const signals = analyzeTaskSignals(userMessage);
-	const pendingTasks = getOpenBdIssues().filter(i => i.status !== "closed");
+	const pendingTasks = getOpenBdIssues().filter((i) => i.status !== "closed");
 	const pendingCount = pendingTasks.length;
 
 	// ── Skip Conditions ────────────────────────────────────────────────────
@@ -118,7 +172,7 @@ export function decideAutoTodo(
 		/^how do i\s+\w+\s*\?$/i,
 	];
 
-	if (simplePatterns.some(p => p.test(userMessage.trim()))) {
+	if (simplePatterns.some((p) => p.test(userMessage.trim()))) {
 		return {
 			shouldCreate: false,
 			reason: "Simple request (lookup/one-liner)",
@@ -127,20 +181,22 @@ export function decideAutoTodo(
 		};
 	}
 
-	// Check for single file, single action with no complexity
-	if (
+	// 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
-	) {
+		pendingCount === 0 &&
+		!signals.likelySubtasks;
+	if (isTrivial) {
 		return {
 			shouldCreate: false,
-			reason: "Single action, single file, no research needed",
+			reason: "Trivial request (single action)",
 			confidence: "high",
-			skipReason: "Task is straightforward",
+			skipReason: "Task is trivial",
 		};
 	}
 
@@ -163,6 +219,7 @@ export function decideAutoTodo(
 	}
 
 	// ── Auto-Create Conditions ──────────────────────────────────────────
+	// Be MORE aggressive about tracking tasks - default to tracking
 	const reasons: string[] = [];
 
 	// HIGH CONFIDENCE: Task explicitly complex
@@ -170,24 +227,24 @@ export function decideAutoTodo(
 		reasons.push("explicitly complex");
 	}
 
-	// HIGH CONFIDENCE: Multiple steps
-	if (signals.stepCount >= 3) {
+	// HIGH CONFIDENCE: Multiple steps (lower from 3 to 2)
+	if (signals.stepCount >= 2) {
 		reasons.push(`${signals.stepCount} steps implied`);
 	}
 
-	// HIGH CONFIDENCE: Multiple files
-	if (signals.fileCount >= 3) {
+	// 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 && signals.stepCount >= 2) {
-		reasons.push("research + action");
+	if (signals.needsResearch) {
+		reasons.push("needs research");
 	}
 
-	// MEDIUM CONFIDENCE: Creates files + action
-	if (signals.createsFiles && signals.fileCount >= 2) {
-		reasons.push("creates multiple files");
+	// MEDIUM CONFIDENCE: Creates files
+	if (signals.createsFiles) {
+		reasons.push("creates files");
 	}
 
 	// MEDIUM CONFIDENCE: Likely subtasks
@@ -195,34 +252,25 @@ export function decideAutoTodo(
 		reasons.push("likely has subtasks");
 	}
 
-	// HIGH CONFIDENCE: Already 2+ pending tasks (session overload)
-	if (pendingCount >= 2) {
-		reasons.push(`${pendingCount} pending tasks in session`);
-	}
-
-	// HIGH CONFIDENCE: 3+ pending tasks
-	if (pendingCount >= 3) {
-		reasons.push("session overwhelmed (3+ pending)");
+	// 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) {
-		return {
-			shouldCreate: false,
-			reason: "No strong complexity signals",
-			confidence: "low",
-			skipReason: "Task doesn't meet auto-create threshold",
-		};
+		// No strong signals but not trivial either - track it anyway
+		reasons.push("multi-step task detected");
 	}
 
-	// Need at least 2 signals OR high-pending count
-	const highConfidenceReasons = ["explicitly complex", "pending tasks in session", "session overwhelmed"];
-	const hasHighConfidence = reasons.some(r => highConfidenceReasons.some(h => r.includes(h)));
-	const shouldCreate = reasons.length >= 2 || hasHighConfidence || pendingCount >= 2;
+	// Create todo if ANY reason OR any pending tasks
+	const shouldCreate = reasons.length >= 1 || pendingCount >= 1;
 
 	return {
 		shouldCreate,
 		reason: reasons.join(", "),
-		confidence: hasHighConfidence ? "high" : reasons.length >= 2 ? "medium" : "low",
+		confidence: reasons.length >= 2 ? "high" : "medium",
 	};
 }
 
@@ -234,7 +282,7 @@ export function decideAutoTodo(
  */
 export function getTaskComplexityScore(userMessage: string): number {
 	const signals = analyzeTaskSignals(userMessage);
-	const pendingTasks = getOpenBdIssues().filter(i => i.status !== "closed");
+	const pendingTasks = getOpenBdIssues().filter((i) => i.status !== "closed");
 
 	let score = 0;
 

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/ai-providers.js

@@ -0,0 +1,66 @@
+/**
+ * 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 const KNOWN_AI_PROVIDERS = [
+    "minimax",
+    "openai",
+    "anthropic",
+    "glm",
+    "openrouter",
+    "openai-codex",
+    "deepseek",
+    "gemini",
+    "kimi",
+];
+/** Human-readable display labels (used in footer, notifications). */
+export const PROVIDER_LABELS = {
+    minimax: "MiniMax",
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    glm: "GLM",
+    openrouter: "OpenRouter",
+    "openai-codex": "OpenAI Codex",
+    deepseek: "DeepSeek",
+    gemini: "Gemini",
+    kimi: "Kimi",
+    unknown: "Unknown",
+};
+/**
+ * Providers that support continuous quota scraping via cookie/browser automation.
+ * Only MiniMax is currently supported here.
+ */
+export const SCRAPEABLE_PROVIDERS = ["minimax"];
+/**
+ * Providers that report quota via TUI signal capture (one-shot on limit hit).
+ * These do NOT have a continuous scraping path.
+ */
+export const TUI_SIGNAL_PROVIDERS = [
+    "openai",
+    "openai-codex",
+    "anthropic",
+    "glm",
+    "openrouter",
+];
+/**
+ * Check if a provider id is a known AI provider.
+ */
+export function isKnownAiProvider(id) {
+    return KNOWN_AI_PROVIDERS.includes(id);
+}
+/**
+ * Get the display label for a provider id.
+ * Falls back to the id itself if unknown.
+ */
+export function getProviderLabel(id) {
+    return PROVIDER_LABELS[id] ?? id;
+}
+//# sourceMappingURL=ai-providers.js.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/types/src/runtime-types.js

@@ -1,2 +1,3 @@
-export {};
+// Re-export AI provider registry so consumers import from one package
+export { KNOWN_AI_PROVIDERS, PROVIDER_LABELS, SCRAPEABLE_PROVIDERS, TUI_SIGNAL_PROVIDERS, isKnownAiProvider, getProviderLabel, } from "./ai-providers.js";
 //# sourceMappingURL=runtime-types.js.map

package/packages/worktree/dist/{worktree.d.ts → src/worktree.d.ts}

@@ -9,7 +9,7 @@
  * - allow reviewer agent to inspect diffs
  * - allow separate models to work on separate tasks
  */
-import type { WorktreeInfo } from "../../packages/types/src/runtime-types.ts";
+import type { WorktreeInfo } from "../../types/src/runtime-types.js";
 export interface WorktreeOptions {
     rootDir: string;
     baseBranch?: string;

package/packages/worktree/dist/{worktree.js → src/worktree.js}

@@ -9,11 +9,8 @@
  * - allow reviewer agent to inspect diffs
  * - allow separate models to work on separate tasks
  */
-// @ts-expect-error - Bun has built-in Node.js types
 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 class WorktreeManager {
     rootDir;

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 {