pi-crew 0.6.1 → 0.6.4

package/src/errors.ts

@@ -0,0 +1,107 @@
+/**
+ * Error code taxonomy for pi-crew.
+ * Maps to semantic categories matching fallow's E001-E004 pattern.
+ */
+// Implemented as const object + type alias (not `enum`) so that Node's
+// `--experimental-strip-types` can load this module. TypeScript `enum`
+// syntax is not supported in strip-only mode.
+export const ErrorCode = {
+  FileReadError: "E001",            // Cannot read a file
+  FileWriteError: "E002",           // Cannot write a file
+  TaskNotFound: "E003",             // Referenced task ID does not exist
+  InvalidStatusTransition: "E004",  // Run/task status cannot legally transition
+  ConfigError: "E005",              // Malformed config or missing required field
+  ResourceNotFound: "E006",         // Agent/team/workflow not found in discovery paths
+} as const;
+
+export type ErrorCode = typeof ErrorCode[keyof typeof ErrorCode];
+
+const DEFAULT_HELP: Record<ErrorCode, string | undefined> = {
+  [ErrorCode.FileReadError]: "Check that the file exists and that the process has read permission.",
+  [ErrorCode.FileWriteError]: "Check that the disk is not full and that the process has write permission.",
+  [ErrorCode.TaskNotFound]: "The task may have been removed or the run may be in an inconsistent state. Use `team status` to verify.",
+  [ErrorCode.InvalidStatusTransition]: "Verify the run status using `team status` before retrying.",
+  [ErrorCode.ConfigError]: "Check the configuration file for syntax errors or missing required fields.",
+  [ErrorCode.ResourceNotFound]: "Use `team list` to see available agents, teams, and workflows.",
+};
+
+/**
+ * Structured error type for pi-crew.
+ * Display format:
+ *   error[E001]: Failed to read manifest.json: not found
+ *     context: while loading run state
+ *     help: Check that the file exists and that the process has read permission.
+ */
+export class CrewError extends Error {
+  readonly code: ErrorCode;
+  help?: string;
+  private _context?: string;
+
+  constructor(code: ErrorCode, message: string, help?: string) {
+    super(message);
+    this.name = "CrewError";
+    this.code = code;
+    this.help = help ?? DEFAULT_HELP[code];
+    Object.defineProperty(this, "message", { enumerable: true });
+    Object.defineProperty(this, "code", { enumerable: true });
+  }
+
+  withContext(context: string): this {
+    this._context = context;
+    return this;
+  }
+
+  withHelp(help: string): this {
+    this.help = help;
+    return this;
+  }
+
+  toString(): string {
+    let out = `error[${this.code}]: ${this.message}`;
+    if (this._context) out += `\n  context: ${this._context}`;
+    if (this.help) out += `\n  help: ${this.help}`;
+    return out;
+  }
+}
+
+export const errors = {
+  fileRead(path: string, source: NodeJS.ErrnoException): CrewError {
+    return new CrewError(
+      ErrorCode.FileReadError,
+      `Failed to read ${path}: ${source.code?.toLowerCase() ?? "unknown"}`,
+    ).withContext("file system read operation");
+  },
+
+  fileWrite(path: string, source: NodeJS.ErrnoException): CrewError {
+    return new CrewError(
+      ErrorCode.FileWriteError,
+      `Failed to write ${path}: ${source.code?.toLowerCase() ?? "unknown"}`,
+    ).withContext("file system write operation");
+  },
+
+  taskNotFound(taskId: string, runId?: string): CrewError {
+    const msg = runId
+      ? `Task '${taskId}' not found in run '${runId}'`
+      : `Task '${taskId}' not found`;
+    return new CrewError(ErrorCode.TaskNotFound, msg);
+  },
+
+  invalidStatusTransition(from: string, to: string): CrewError {
+    return new CrewError(
+      ErrorCode.InvalidStatusTransition,
+      `Invalid run status transition: ${from} -> ${to}`,
+    );
+  },
+
+  config(message: string): CrewError {
+    return new CrewError(ErrorCode.ConfigError, message)
+      .withContext("configuration loading");
+  },
+
+  resourceNotFound(type: string, name: string): CrewError {
+    return new CrewError(
+      ErrorCode.ResourceNotFound,
+      `${type} '${name}' not found in any discovery path`,
+    );
+  },
+} as const;

package/src/extension/async-notifier.ts

@@ -47,7 +47,7 @@ function isTaskActive(task: TeamTaskState): boolean {
 }
 
 function markActiveTasksAndAgentsFailed(run: TeamRunManifest, message: string): void {
-	const loaded = loadRunManifestById(run.cwd, run.runId);
+	const loaded = loadRunManifestById(run.cwd, run.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 	const tasks = loaded?.tasks ?? [];
 	const failedAt = new Date().toISOString();
 	if (tasks.some(isTaskActive)) {
@@ -73,7 +73,7 @@ export function markDeadAsyncRunIfNeeded(run: TeamRunManifest, now = Date.now(),
 	const asyncPid = run.async.pid;
 	const message = `Background runner died unexpectedly; check background.log (${liveness.detail}).`;
 	return withRunLockSync(run, () => {
-		const fresh = loadRunManifestById(run.cwd, run.runId);
+		const fresh = loadRunManifestById(run.cwd, run.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 		if (!fresh || !isActiveRunStatus(fresh.manifest.status)) return undefined;
 		const failed = updateRunStatus(fresh.manifest, "failed", message);
 		markActiveTasksAndAgentsFailed(failed, message);
@@ -125,6 +125,10 @@ export function startAsyncRunNotifier(ctx: ExtensionContext, state: AsyncNotifie
 			logInternalError("async-notifier", error, `interval=${intervalMs}`);
 		}
 	}, intervalMs);
+	// Defense-in-depth: never let the notifier timer keep the event loop alive.
+	// If stopAsyncRunNotifier is missed (session switch race), the next run of
+	// this interval is harmless, but the timer must not block process exit.
+	if (typeof state.interval.unref === "function") state.interval.unref();
 }
 
 export function stopAsyncRunNotifier(state: AsyncNotifierState): void {

package/src/extension/crew-cleanup.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { logInternalError } from "../utils/internal-error.ts";
+import { cleanupAllTrackedTempDirs } from "../runtime/pi-args.ts";
 // NOTE: globalProgressTracker import kept for documentation but not directly used
 // since we don't have agent IDs to untrack. Actual progress clearing should be
 // handled by the progress tracker itself on shutdown.
@@ -112,12 +113,14 @@ async function cleanupChildProcesses(): Promise<void> {
 }
 
 async function cleanupTempDirectories(): Promise<void> {
-	// NOTE: getTempDir is not available in paths.ts.
-	// For now, just log that cleanup is pending.
-	// Actual temp directory cleanup should be implemented by the run-graph
-	// or the specific code that creates temporary workspaces.
+	// Clean up every temp dir created in this process. Previously this was
+	// a stub that just logged; it caused /tmp/pi-crew-* dirs to accumulate
+	// from killed test runs and child-pi invocations. See issue #<n>.
 	try {
-		console.log(`[pi-crew] Temp directory cleanup deferred to run-graph`);
+		const result = cleanupAllTrackedTempDirs();
+		if (result.cleaned > 0) {
+			console.log(`[pi-crew] Cleaned ${result.cleaned} tracked temp dirs (${result.failed} failed)`);
+		}
 	} catch (error) {
 		logInternalError("crew-cleanup.temp", error);
 	}