pi-harness-runtime 1.1.428 → 1.1.430

package/packages/two-phase-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/two-phase-review",
-  "version": "1.1.428",
+  "version": "1.1.430",
   "description": "pi-harness-runtime — two-phase implementation and review workflow (queue review signals, gate the phase, scope the diff)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/types/package.json

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

package/packages/voice-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/voice-api",
-  "version": "1.1.428",
+  "version": "1.1.430",
   "type": "module",
   "description": "Voice-to-text API using Whisper for Telegram and LINE integration",
   "main": "./dist/index.js",

package/packages/webmcp-tester/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/webmcp-tester",
-  "version": "1.1.428",
+  "version": "1.1.430",
   "description": "WebMCP-powered E2E testing for pi-harness - natural language test scenarios",
   "type": "module",
   "main": "./dist/index.js",

package/packages/wiki/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/wiki",
-  "version": "1.1.428",
+  "version": "1.1.430",
   "description": "LLM Wiki integration for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/workflow-events/package.json

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

package/packages/workspace-scanner/package.json

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

package/packages/worktree/package.json

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

package/packages/write-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/write-review",
-  "version": "1.1.428",
+  "version": "1.1.430",
   "description": "Two-agent write-review loop with blackboard coordination",
   "type": "module",
   "main": "src/index.ts",

package/scripts/lib/runtime-imports.ts

@@ -16,7 +16,9 @@
  *   1. A TYPE-only import is erased at runtime, so it does not need a
  *      runtime target. It is skipped.
  *   2. Comments are removed before the scan, so a commented-out import is
- *      not a broken import.
+ *      not a broken import. The same holds for text inside a string or a
+ *      template literal: documentation that shows an import is not an
+ *      import.
  *   3. A relative import resolves when the target file exists:
  *        - the specifier as written (`./x.js` -> `x.js`),
  *        - the TypeScript source of a `.js` specifier (`./x.js` -> `x.ts`),
@@ -25,35 +27,59 @@
  *   4. A compiled file (`.js`) must reach a file that is PUBLISHED. A
  *      TypeScript source (`.ts`) is resolved at compile time, so it may
  *      reach a source file in the repository.
+ *   5. A bare import that names a WORKSPACE package cannot resolve: the
+ *      workspace packages ship inside this one tarball and are never
+ *      installed as separate packages, so the name does not exist at
+ *      runtime. Such an import must point at the built artifact instead.
  */
 
 import { existsSync, statSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 
-/** The quoting state of the comment scanner. */
+/** The quoting state of the scanner. */
 type Quote = "" | '"' | "'" | "`";
 
+/** A source with its comments removed and its string content marked. */
+export interface ScannedSource {
+	/** The source without its comments. */
+	code: string;
+	/**
+	 * Whether the character at the given index of {@link code} is code.
+	 *
+	 * The content of a string or a template literal is not code, so an
+	 * import that only appears inside one is documentation, not an import.
+	 */
+	isCodeAt: (index: number) => boolean;
+}
+
 /**
- * Remove the comments from a source file.
+ * Remove the comments from a source file and mark its string content.
  *
  * A string or a template literal may contain something that looks like a
  * comment, so the scanner tracks the quoting state instead of using a
  * regular expression.
  */
-export function stripComments(source: string): string {
-	let out = "";
+export function scanSource(source: string): ScannedSource {
+	let code = "";
+	const isCode: boolean[] = [];
 	let i = 0;
 	let quote: Quote = "";
 
+	const emit = (char: string, isCodeChar: boolean) => {
+		code += char;
+		isCode.push(isCodeChar);
+	};
+
 	while (i < source.length) {
 		const char = source[i];
 		const next = source[i + 1];
 
 		if (quote) {
-			out += char;
+			// The content of a literal is not code. The quotes are.
+			emit(char, char === quote && source[i - 1] !== "\\");
 			if (char === "\\") {
 				// An escaped character cannot end the literal.
-				out += next ?? "";
+				emit(next ?? "", false);
 				i += 2;
 				continue;
 			}
@@ -64,7 +90,7 @@ export function stripComments(source: string): string {
 
 		if (char === '"' || char === "'" || char === "`") {
 			quote = char;
-			out += char;
+			emit(char, true);
 			i += 1;
 			continue;
 		}
@@ -84,45 +110,56 @@ export function stripComments(source: string): string {
 			}
 			// Keep the newlines, so a line number stays meaningful.
 			for (let k = i; k < end; k += 1) {
-				if (source[k] === "\n") out += "\n";
+				if (source[k] === "\n") emit("\n", false);
 			}
 			i = end + 2;
 			continue;
 		}
 
-		out += char;
+		emit(char, true);
 		i += 1;
 	}
 
-	return out;
+	return { code, isCodeAt: (index: number) => isCode[index] === true };
 }
 
 /**
- * Every RELATIVE value import of a source file.
+ * Remove the comments from a source file.
+ */
+export function stripComments(source: string): string {
+	return scanSource(source).code;
+}
+
+/** The import forms that carry a specifier. */
+const IMPORT_PATTERNS: RegExp[] = [
+	// import ... from "..." / export ... from "..."
+	/(?:^|[\n;])[ \t]*(import|export)\s+(type\s+)?[^;\n]*?from\s*["']([^"']+)["']/g,
+	// import "..." (side effect)
+	/(?:^|[\n;])[ \t]*import\s*["']([^"']+)["']/g,
+	// import("...") (dynamic)
+	/import\s*\(\s*["']([^"']+)["']\s*\)/g,
+];
+
+/**
+ * Every VALUE import of a source file.
  *
  * A type-only import is skipped: `import type { X } from "..."` is erased
- * by the compiler and never reaches the runtime.
+ * by the compiler and never reaches the runtime. An import that only
+ * appears inside a string or a template literal is skipped as well: that
+ * is documentation, not an import.
  */
-export function extractRelativeValueImports(source: string): string[] {
-	const code = stripComments(source);
+export function extractValueImports(source: string): string[] {
+	const { code, isCodeAt } = scanSource(source);
 	const specifiers: string[] = [];
 
-	const patterns: RegExp[] = [
-		// import ... from "..." / export ... from "..."
-		/(?:^|[\n;])[ \t]*(import|export)\s+(type\s+)?[^;\n]*?from\s*["']([^"']+)["']/g,
-		// import "..." (side effect)
-		/(?:^|[\n;])[ \t]*import\s*["']([^"']+)["']/g,
-		// import("...") (dynamic)
-		/import\s*\(\s*["']([^"']+)["']\s*\)/g,
-	];
-
-	for (const pattern of patterns) {
+	for (const pattern of IMPORT_PATTERNS) {
 		for (const match of code.matchAll(pattern)) {
+			// The match must start in code, not inside a literal.
+			if (match.index === undefined || !isCodeAt(match.index)) continue;
 			// `type` marks an import that the compiler erases.
 			if (match[2] && match[2].trim() === "type") continue;
 			const specifier = match[3] ?? match[1];
 			if (!specifier) continue;
-			if (!specifier.startsWith(".")) continue;
 			specifiers.push(specifier);
 		}
 	}
@@ -130,6 +167,33 @@ export function extractRelativeValueImports(source: string): string[] {
 	return [...new Set(specifiers)];
 }
 
+/**
+ * Every RELATIVE value import of a source file.
+ */
+export function extractRelativeValueImports(source: string): string[] {
+	return extractValueImports(source).filter((specifier) => specifier.startsWith("."));
+}
+
+/**
+ * Every BARE value import of a source file.
+ *
+ * A bare import names a package, not a file in this repository.
+ */
+export function extractBareImports(source: string): string[] {
+	return extractValueImports(source).filter((specifier) => !specifier.startsWith("."));
+}
+
+/**
+ * The package a specifier names.
+ *
+ * `@scope/name/sub/path` and `name/sub/path` both name `@scope/name` and
+ * `name`.
+ */
+export function packageNameOf(specifier: string): string {
+	if (specifier.startsWith("@")) return specifier.split("/").slice(0, 2).join("/");
+	return specifier.split("/")[0];
+}
+
 /**
  * The files a relative specifier may point at.
  *

package/scripts/typecheck-packages.mjs

@@ -32,7 +32,7 @@ const BASELINES = new Map([
 	["provider-router", 0],
 	["providers", 0],
 	["quota-manager", 0],
-	["runtime", 5],
+	["runtime", 0],
 	["voice-api", 16],
 	["worktree", 0],
 	["harness", 20],

package/scripts/verify-package-contents.ts

@@ -31,7 +31,9 @@ import { execFile, spawnSync } from "node:child_process";
 import { join, resolve, dirname, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
+	extractBareImports,
 	extractRelativeValueImports,
+	packageNameOf,
 	resolveRelativeImport,
 } from "./lib/runtime-imports.js";
 
@@ -445,6 +447,34 @@ async function packFileList(): Promise<string[]> {
 	}
 }
 
+/**
+ * The names of the workspace packages.
+ *
+ * The workspace packages ship inside this one tarball and are never
+ * installed as separate packages, so a bare import that names one of them
+ * cannot resolve at runtime - not in a consumer's installation, and not in
+ * the repository either, because the workspace is never linked into
+ * `node_modules` under its own name.
+ */
+function workspacePackageNames(): Set<string> {
+	const names = new Set<string>();
+	const packagesDir = join(ROOT, "packages");
+	if (!existsSync(packagesDir)) return names;
+	for (const name of readdirSync(packagesDir)) {
+		const manifestPath = join(packagesDir, name, "package.json");
+		if (!existsSync(manifestPath)) continue;
+		try {
+			const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as {
+				name?: string;
+			};
+			if (manifest.name) names.add(manifest.name);
+		} catch {
+			// A manifest that cannot be read names no package.
+		}
+	}
+	return names;
+}
+
 /**
  * Every relative import of a published file must resolve.
  *
@@ -461,6 +491,7 @@ async function packFileList(): Promise<string[]> {
  */
 function checkRelativeImports(files: string[]): void {
 	const published = new Set(files);
+	const workspaceNames = workspacePackageNames();
 	for (const path of files) {
 		if (!/\.(ts|mts|cts|mjs|js|cjs)$/.test(path)) continue;
 		if (path.endsWith(".d.ts") || path.endsWith(".d.mts")) continue;
@@ -481,6 +512,17 @@ function checkRelativeImports(files: string[]): void {
 				detail: `${path} imports ${specifier} but ${result.reason}`,
 			});
 		}
+		// A bare import that names a workspace package names something that
+		// is never installed: the workspace packages are inside this one
+		// tarball. Such an import has to point at the built artifact.
+		for (const specifier of extractBareImports(content)) {
+			const name = packageNameOf(specifier);
+			if (!workspaceNames.has(name)) continue;
+			problems.push({
+				kind: "broken-import",
+				detail: `${path} imports ${specifier} but ${name} is a workspace package: it ships inside this tarball and is never installed, so the name cannot resolve`,
+			});
+		}
 	}
 }
 

package/harness/task-graph.d.ts

@@ -1,51 +0,0 @@
-/**
- * Task Graph Manager — RFC-0028 Phase 3
- *
- * Manages task dependency graph for compact-aware scheduling.
- * Currently a stub — integrates with CompactOrchestrator for
- * dependency-aware compaction prioritization.
- *
- * Future work:
- * - Track task dependencies (blocking/ready tasks)
- * - Prioritize compaction to keep blocking path messages
- * - Track which tasks depend on which checkpoint artifacts
- */
-import type { RuntimeTask } from "../packages/types/src/runtime-types.js";
-export interface TaskNode {
-    task: RuntimeTask;
-    dependencies: Set<string>;
-    dependents: Set<string>;
-    status: "pending" | "ready" | "running" | "done" | "blocked";
-}
-export interface TaskGraphManager {
-    /** Add a task to the graph */
-    addTask(task: RuntimeTask): void;
-    /** Mark a task as done and update dependents */
-    completeTask(taskId: string): void;
-    /** Get tasks ready for execution */
-    getReadyTasks(): RuntimeTask[];
-    /** Get tasks blocked by a given task */
-    getBlockedTasks(taskId: string): RuntimeTask[];
-    /** Get all pending tasks */
-    getPendingTasks(): RuntimeTask[];
-    /** Get all tasks */
-    getAllTasks(): RuntimeTask[];
-    /** Get current progress summary */
-    getProgressSummary(): {
-        total: number;
-        done: number;
-        running: number;
-        failed: number;
-    };
-    /** Get compact priority: tasks to keep in context vs prune */
-    getCompactPriority(): {
-        keep: string[];
-        prune: string[];
-    };
-}
-/**
- * Creates a new TaskGraphManager instance.
- * Stub implementation — returns minimal working graph.
- */
-export declare function createTaskGraphManager(): TaskGraphManager;
-//# sourceMappingURL=task-graph.d.ts.map