@xopcai/xopc 0.0.190 → 0.0.192

package/dist/src/runtime-tools/network.js

@@ -0,0 +1,41 @@
+import { ProxyAgent, fetch } from "undici";
+//#region src/runtime-tools/network.ts
+const PROXY_AGENTS = /* @__PURE__ */ new Map();
+function dispatcher(proxy) {
+	if (!proxy) return void 0;
+	const existing = PROXY_AGENTS.get(proxy);
+	if (existing) return existing;
+	const created = new ProxyAgent(proxy);
+	PROXY_AGENTS.set(proxy, created);
+	return created;
+}
+async function fetchRuntimeResource(params) {
+	const timeoutSignal = AbortSignal.timeout(params.timeoutMs);
+	const signal = params.signal ? AbortSignal.any([params.signal, timeoutSignal]) : timeoutSignal;
+	return await fetch(params.url, {
+		...params.init,
+		dispatcher: dispatcher(params.proxy),
+		signal
+	});
+}
+async function readRuntimeResponseText(response, maxBytes) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			bytes += value.byteLength;
+			if (bytes > maxBytes) throw new Error("Response exceeds size limit");
+			chunks.push(Buffer.from(value));
+		}
+	} catch (error) {
+		await reader.cancel().catch(() => {});
+		throw error;
+	}
+	return Buffer.concat(chunks, bytes).toString("utf8");
+}
+//#endregion
+export { fetchRuntimeResource, readRuntimeResponseText };

package/dist/src/runtime-tools/offline-bundle.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeKind } from './types.js';
+export type OfflineBundleArtifact = {
+    archivePath: string;
+    archiveFile: string;
+    archiveType: 'zip' | 'tar.gz';
+    sha256: string;
+};
+export declare function bundledPythonArchiveName(params: {
+    version: string;
+    platform: string;
+}): string;
+export declare function resolveOfflineBundleArtifact(params: {
+    bundleDir: string;
+    runtime: RuntimeKind;
+    archiveFile: string;
+}): Promise<OfflineBundleArtifact>;

package/dist/src/runtime-tools/offline-bundle.js

@@ -0,0 +1,41 @@
+import { RuntimeError } from "./errors.js";
+import { sha256File } from "./downloader.js";
+import { isAbsolute, join } from "node:path";
+import { access, readFile } from "node:fs/promises";
+//#region src/runtime-tools/offline-bundle.ts
+function parseChecksum(text, archiveFile) {
+	for (const line of text.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+		const match = line.match(/^([a-fA-F0-9]{64})(?:\s+[*]?(.+))?$/);
+		if (match && (!match[2] || match[2] === archiveFile)) return match[1].toLowerCase();
+	}
+	return null;
+}
+function bundledPythonArchiveName(params) {
+	const extension = params.platform.startsWith("win32-") ? "zip" : "tar.gz";
+	return `python-${params.version}-${params.platform}.${extension}`;
+}
+async function resolveOfflineBundleArtifact(params) {
+	if (!isAbsolute(params.bundleDir)) throw new RuntimeError("runtimeTools.download.bundleDir must be an absolute path", "RUNTIME_ARCHIVE_INVALID", params.runtime, "offline_bundle", false);
+	const archivePath = join(params.bundleDir, params.archiveFile);
+	try {
+		await access(archivePath);
+	} catch {
+		throw new RuntimeError(`Offline bundle is missing ${params.archiveFile}`, "RUNTIME_NOT_FOUND", params.runtime, "offline_bundle", true);
+	}
+	const checksumFiles = [`${archivePath}.sha256`, join(params.bundleDir, "SHASUMS256.txt")];
+	let expected = null;
+	for (const checksumPath of checksumFiles) try {
+		expected = parseChecksum(await readFile(checksumPath, "utf8"), params.archiveFile);
+		if (expected) break;
+	} catch {}
+	if (!expected) throw new RuntimeError(`Offline bundle has no checksum for ${params.archiveFile}`, "RUNTIME_CHECKSUM_MISMATCH", params.runtime, "offline_bundle", false);
+	if (await sha256File(archivePath) !== expected) throw new RuntimeError(`Offline bundle checksum mismatch for ${params.archiveFile}`, "RUNTIME_CHECKSUM_MISMATCH", params.runtime, "offline_bundle", true);
+	return {
+		archivePath,
+		archiveFile: params.archiveFile,
+		archiveType: params.archiveFile.endsWith(".zip") ? "zip" : "tar.gz",
+		sha256: expected
+	};
+}
+//#endregion
+export { bundledPythonArchiveName, resolveOfflineBundleArtifact };

package/dist/src/runtime-tools/paths.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeKind } from './types.js';
+export declare function runtimeToolsRoot(stateDir: string): string;
+export declare function runtimeVersionDir(stateDir: string, runtime: RuntimeKind, version: string): string;
+export declare function runtimeManifestPath(stateDir: string, runtime: RuntimeKind): string;
+export declare function runtimeLockPath(stateDir: string, runtime: RuntimeKind, version: string): string;
+export declare function runtimeDownloadPath(stateDir: string, archiveFile: string): string;
+export declare function runtimeStagingDir(stateDir: string, runtime: RuntimeKind, version: string, operationId: string): string;

package/dist/src/runtime-tools/paths.js

@@ -0,0 +1,22 @@
+import { join } from "node:path";
+//#region src/runtime-tools/paths.ts
+function runtimeToolsRoot(stateDir) {
+	return join(stateDir, "tools");
+}
+function runtimeVersionDir(stateDir, runtime, version) {
+	return join(runtimeToolsRoot(stateDir), runtime, "versions", version);
+}
+function runtimeManifestPath(stateDir, runtime) {
+	return join(runtimeToolsRoot(stateDir), "manifests", `${runtime}.json`);
+}
+function runtimeLockPath(stateDir, runtime, version) {
+	return join(runtimeToolsRoot(stateDir), "locks", `${runtime}-${version}.lock`);
+}
+function runtimeDownloadPath(stateDir, archiveFile) {
+	return join(runtimeToolsRoot(stateDir), "downloads", `${archiveFile}.partial`);
+}
+function runtimeStagingDir(stateDir, runtime, version, operationId) {
+	return join(runtimeToolsRoot(stateDir), "staging", `${runtime}-${version}-${operationId}`);
+}
+//#endregion
+export { runtimeDownloadPath, runtimeLockPath, runtimeManifestPath, runtimeStagingDir, runtimeToolsRoot, runtimeVersionDir };

package/dist/src/runtime-tools/probe.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeExecutables, RuntimeKind } from './types.js';
+export declare function parseRuntimeVersion(output: string): string | null;
+export declare function versionSatisfies(actual: string, requested: string): boolean;
+export declare function probeSystemRuntime(runtime: RuntimeKind, requestedVersion: string): Promise<{
+    version: string;
+    executables: RuntimeExecutables;
+} | null>;

package/dist/src/runtime-tools/probe.js

@@ -0,0 +1,71 @@
+import { runRuntimeCommand } from "./command.js";
+import semver from "semver";
+//#region src/runtime-tools/probe.ts
+function parseRuntimeVersion(output) {
+	return output.match(/v?(\d+\.\d+\.\d+)/)?.[1] ?? null;
+}
+function versionSatisfies(actual, requested) {
+	const normalized = semver.valid(actual);
+	if (!normalized) return false;
+	if (/^\d+$/.test(requested)) return semver.major(normalized) === Number(requested);
+	if (/^\d+\.\d+$/.test(requested)) {
+		const [major, minor] = requested.split(".").map(Number);
+		return semver.major(normalized) === major && semver.minor(normalized) === minor;
+	}
+	return semver.satisfies(normalized, requested) || normalized === requested;
+}
+function commandNames(runtime) {
+	if (runtime === "node") return process.platform === "win32" ? ["node.exe", "node"] : ["node"];
+	if (runtime === "uv") return process.platform === "win32" ? ["uv.exe", "uv"] : ["uv"];
+	return process.platform === "win32" ? [
+		"python.exe",
+		"python3.exe",
+		"python"
+	] : ["python3", "python"];
+}
+async function probeSystemRuntime(runtime, requestedVersion) {
+	for (const command of commandNames(runtime)) {
+		const versionResult = await runRuntimeCommand({
+			command,
+			args: ["--version"]
+		});
+		if (!versionResult.ok) continue;
+		const version = parseRuntimeVersion(`${versionResult.stdout}\n${versionResult.stderr}`);
+		if (!version || !versionSatisfies(version, requestedVersion)) continue;
+		if (runtime === "node") {
+			const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+			const npx = process.platform === "win32" ? "npx.cmd" : "npx";
+			const [npmResult, npxResult] = await Promise.all([runRuntimeCommand({
+				command: npm,
+				args: ["--version"]
+			}), runRuntimeCommand({
+				command: npx,
+				args: ["--version"]
+			})]);
+			if (!npmResult.ok || !npxResult.ok) continue;
+			return {
+				version,
+				executables: {
+					primary: command,
+					node: command,
+					npm,
+					npx
+				}
+			};
+		}
+		return {
+			version,
+			executables: runtime === "uv" ? {
+				primary: command,
+				uv: command,
+				uvx: process.platform === "win32" ? "uvx.exe" : "uvx"
+			} : {
+				primary: command,
+				python: command
+			}
+		};
+	}
+	return null;
+}
+//#endregion
+export { parseRuntimeVersion, probeSystemRuntime, versionSatisfies };

package/dist/src/runtime-tools/prune.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeToolsConfig } from '../config/schema.js';
+export type RuntimePruneResult = {
+    removed: string[];
+    reclaimedBytes: number;
+};
+export declare function pruneRuntimeTools(params: {
+    stateDir: string;
+    config: RuntimeToolsConfig;
+    now?: number;
+}): Promise<RuntimePruneResult>;

package/dist/src/runtime-tools/prune.js

@@ -0,0 +1,93 @@
+import { runtimeToolsRoot } from "./paths.js";
+import { readRuntimeManifest } from "./manifest-store.js";
+import { join, resolve } from "node:path";
+import { lstat, readdir, rm, stat } from "node:fs/promises";
+//#region src/runtime-tools/prune.ts
+const RUNTIMES = [
+	"node",
+	"uv",
+	"python"
+];
+const STALE_TEMP_MS = 1440 * 60 * 1e3;
+async function pathSize(path) {
+	const details = await lstat(path);
+	if (details.isSymbolicLink()) return details.size;
+	if (!details.isDirectory()) return details.size;
+	let total = 0;
+	for (const entry of await readdir(path)) total += await pathSize(join(path, entry));
+	return total;
+}
+async function listEntries(path) {
+	try {
+		return await Promise.all((await readdir(path)).map(async (name) => {
+			const entryPath = join(path, name);
+			return {
+				path: entryPath,
+				mtimeMs: (await stat(entryPath)).mtimeMs,
+				size: await pathSize(entryPath)
+			};
+		}));
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+async function pruneRuntimeTools(params) {
+	const removed = [];
+	let reclaimedBytes = 0;
+	const root = runtimeToolsRoot(params.stateDir);
+	for (const runtime of RUNTIMES) {
+		const entries = (await listEntries(join(root, runtime, "versions"))).sort((a, b) => b.mtimeMs - a.mtimeMs);
+		const manifest = await readRuntimeManifest(params.stateDir, runtime);
+		const entryPaths = new Set(entries.map((entry) => resolve(entry.path)));
+		const activePath = manifest && entryPaths.has(resolve(manifest.installDir)) ? resolve(manifest.installDir) : null;
+		const keep = /* @__PURE__ */ new Set();
+		if (activePath) keep.add(activePath);
+		for (const entry of entries) {
+			if (keep.size >= params.config.retention.keepVersions) break;
+			keep.add(resolve(entry.path));
+		}
+		for (const entry of entries) {
+			if (keep.has(resolve(entry.path))) continue;
+			await rm(entry.path, {
+				recursive: true,
+				force: true
+			});
+			removed.push(entry.path);
+			reclaimedBytes += entry.size;
+		}
+	}
+	const now = params.now ?? Date.now();
+	for (const entry of await listEntries(join(root, "staging"))) {
+		if (now - entry.mtimeMs < STALE_TEMP_MS) continue;
+		await rm(entry.path, {
+			recursive: true,
+			force: true
+		});
+		removed.push(entry.path);
+		reclaimedBytes += entry.size;
+	}
+	const maxCacheBytes = params.config.retention.maxCacheBytes;
+	if (maxCacheBytes !== void 0) {
+		const cacheEntries = (await listEntries(join(root, "downloads"))).sort((a, b) => b.mtimeMs - a.mtimeMs);
+		let retained = 0;
+		for (const entry of cacheEntries) {
+			if (retained + entry.size <= maxCacheBytes) {
+				retained += entry.size;
+				continue;
+			}
+			await rm(entry.path, {
+				recursive: true,
+				force: true
+			});
+			removed.push(entry.path);
+			reclaimedBytes += entry.size;
+		}
+	}
+	return {
+		removed,
+		reclaimedBytes
+	};
+}
+//#endregion
+export { pruneRuntimeTools };

package/dist/src/runtime-tools/types.d.ts

@@ -0,0 +1,70 @@
+import type { RuntimeToolsConfig } from '../config/schema.js';
+export type RuntimeKind = 'node' | 'uv' | 'python';
+export type RuntimeSource = 'managed' | 'system';
+export type RuntimeState = 'disabled' | 'unsupported' | 'absent' | 'installing' | 'ready' | 'degraded' | 'corrupted' | 'failed';
+export interface RuntimeExecutables {
+    primary: string;
+    node?: string;
+    npm?: string;
+    npx?: string;
+    corepack?: string;
+    uv?: string;
+    uvx?: string;
+    python?: string;
+}
+export interface InstalledRuntimeManifest {
+    schemaVersion: 1;
+    runtime: RuntimeKind;
+    version: string;
+    source: RuntimeSource;
+    platform: string;
+    arch: string;
+    installDir: string;
+    executables: RuntimeExecutables;
+    installedAt: string;
+    verifiedAt: string;
+    distribution?: {
+        url: string;
+        sha256: string;
+        archiveFile: string;
+        catalogVersion: string;
+    };
+    probe: {
+        versionOutput: string;
+        packageManagerVersion?: string;
+    };
+}
+export interface ResolvedRuntime {
+    runtime: RuntimeKind;
+    version: string;
+    source: RuntimeSource;
+    executable: string;
+    executables: RuntimeExecutables;
+    installDir?: string;
+}
+export interface RuntimeStatus {
+    runtime: RuntimeKind;
+    state: RuntimeState;
+    requestedVersion: string;
+    resolved?: ResolvedRuntime;
+    message: string;
+    repairable: boolean;
+}
+export interface RuntimeRequest {
+    runtime: RuntimeKind;
+    version?: string;
+    allowProvision?: boolean;
+    signal?: AbortSignal;
+}
+export interface RuntimeManagerOptions {
+    stateDir: string;
+    config: RuntimeToolsConfig;
+}
+export interface RuntimeProgressEvent {
+    operationId: string;
+    runtime: RuntimeKind;
+    phase: 'resolve' | 'download' | 'verify' | 'extract' | 'install' | 'probe' | 'complete';
+    message: string;
+    downloadedBytes?: number;
+    totalBytes?: number;
+}

package/dist/src/runtime-tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/share/share-zip.js

@@ -2,8 +2,8 @@ import { isPathUnderWorkspace } from "../gateway/workspace-editor-path.js";
 import { relative, resolve } from "node:path";
 import { createReadStream } from "node:fs";
 import { lstat, readdir, realpath, stat } from "node:fs/promises";
-import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { Readable, Transform } from "node:stream";
 import { crc32, createDeflateRaw } from "node:zlib";
 //#region src/share/share-zip.ts
 const SIG_LOCAL = 67324752;

package/dist/src/storage/sqlite/migrations/113_memory_evidence_single_source.sql

@@ -2,16 +2,20 @@ ALTER TABLE memory_evidence ADD COLUMN session_key TEXT;
 ALTER TABLE memory_evidence ADD COLUMN turn_id TEXT;
 ALTER TABLE memory_evidence ADD COLUMN tool_call_id TEXT;
 
+-- Preserve evidence while treating deleted legacy sources like ON DELETE SET NULL.
 WITH legacy AS (
   SELECT
     r.record_id,
-    json_extract(j.value, '$.sourceItemId') AS source_item_id,
+    source.item_id AS source_item_id,
     COALESCE(json_extract(j.value, '$.relation'), 'supports') AS relation,
     MAX(CAST(strftime('%s', json_extract(j.value, '$.observedAt')) AS INTEGER) * 1000) AS observed_at,
     MAX(json_extract(j.value, '$.sessionKey')) AS session_key,
     MAX(json_extract(j.value, '$.turnId')) AS turn_id,
     MAX(json_extract(j.value, '$.toolCallId')) AS tool_call_id
-  FROM memory_records r, json_each(r.evidence_json) j
+  FROM memory_records r
+  JOIN json_each(r.evidence_json) j
+  LEFT JOIN knowledge_source_items source
+    ON source.item_id = json_extract(j.value, '$.sourceItemId')
   WHERE json_valid(r.evidence_json)
   GROUP BY r.record_id, source_item_id, relation
 )
@@ -26,29 +30,47 @@ WHERE evidence.record_id = legacy.record_id
   AND COALESCE(evidence.source_item_id, '') = COALESCE(legacy.source_item_id, '')
   AND evidence.relation = legacy.relation;
 
+WITH legacy AS (
+  SELECT
+    r.record_id,
+    source.item_id AS source_item_id,
+    COALESCE(json_extract(j.value, '$.relation'), 'supports') AS relation,
+    MAX(json_extract(j.value, '$.sourceText')) AS excerpt,
+    MAX(json_extract(j.value, '$.confidence')) AS confidence,
+    MAX(CAST(strftime('%s', json_extract(j.value, '$.observedAt')) AS INTEGER) * 1000) AS observed_at,
+    MAX(json_extract(j.value, '$.sessionKey')) AS session_key,
+    MAX(json_extract(j.value, '$.turnId')) AS turn_id,
+    MAX(json_extract(j.value, '$.toolCallId')) AS tool_call_id,
+    MAX(r.created_at) AS created_at
+  FROM memory_records r
+  JOIN json_each(r.evidence_json) j
+  LEFT JOIN knowledge_source_items source
+    ON source.item_id = json_extract(j.value, '$.sourceItemId')
+  WHERE json_valid(r.evidence_json)
+  GROUP BY r.record_id, source_item_id, relation
+)
 INSERT INTO memory_evidence (
   evidence_id, record_id, source_item_id, relation, excerpt, confidence,
   observed_at, session_key, turn_id, tool_call_id, created_at
 )
 SELECT
   lower(hex(randomblob(16))),
-  r.record_id,
-  json_extract(j.value, '$.sourceItemId'),
-  COALESCE(json_extract(j.value, '$.relation'), 'supports'),
-  json_extract(j.value, '$.sourceText'),
-  json_extract(j.value, '$.confidence'),
-  CAST(strftime('%s', json_extract(j.value, '$.observedAt')) AS INTEGER) * 1000,
-  json_extract(j.value, '$.sessionKey'),
-  json_extract(j.value, '$.turnId'),
-  json_extract(j.value, '$.toolCallId'),
-  r.created_at
-FROM memory_records r, json_each(r.evidence_json) j
-WHERE json_valid(r.evidence_json)
-  AND NOT EXISTS (
-    SELECT 1 FROM memory_evidence e
-    WHERE e.record_id = r.record_id
-      AND COALESCE(e.source_item_id, '') = COALESCE(json_extract(j.value, '$.sourceItemId'), '')
-      AND e.relation = COALESCE(json_extract(j.value, '$.relation'), 'supports')
-  );
+  legacy.record_id,
+  legacy.source_item_id,
+  legacy.relation,
+  legacy.excerpt,
+  legacy.confidence,
+  legacy.observed_at,
+  legacy.session_key,
+  legacy.turn_id,
+  legacy.tool_call_id,
+  legacy.created_at
+FROM legacy
+WHERE NOT EXISTS (
+  SELECT 1 FROM memory_evidence e
+  WHERE e.record_id = legacy.record_id
+    AND COALESCE(e.source_item_id, '') = COALESCE(legacy.source_item_id, '')
+    AND e.relation = legacy.relation
+);
 
 ALTER TABLE memory_records DROP COLUMN evidence_json;

package/dist/src/tasks/home-query-service.js

@@ -81,11 +81,7 @@ function attentionDetail(kind, status, locale, timeoutSeconds) {
 }
 function decisionFromTask(model, projectName) {
 	const item = model.attention[0];
-	if (!item || ![
-		"input_required",
-		"approval_required",
-		"dependency_blocked"
-	].includes(item.kind)) return null;
+	if (!item || !["input_required", "approval_required"].includes(item.kind)) return null;
 	const task = model.task;
 	return {
 		id: `task:${task.id}`,

package/dist/src/tasks/index.js

@@ -13,9 +13,9 @@ import { ModelTaskContractPlanner, parseTaskContractResponse } from "./task-cont
 import { assembleTaskContext, buildTaskExecutionDirective, getTaskContextManifest, getTaskExecutionBrief } from "./task-context-assembler.js";
 import { TaskRunCoordinator } from "./task-run-coordinator.js";
 import { ProjectMonitoringService, decideProactiveDisposition } from "./project-monitoring-service.js";
-import { ProjectOperatingViewService } from "./project-operating-view-service.js";
+import { ProjectOperatingViewService, projectTaskLane } from "./project-operating-view-service.js";
 import { TaskValueMetricsService } from "./task-value-metrics-service.js";
 import { TaskOutboxDispatcher } from "./task-outbox-dispatcher.js";
 import { TaskRunDispatcher } from "./task-run-dispatcher.js";
 import { TaskSignalService } from "./task-signal-service.js";
-export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskDependencyError, TaskDependencyService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeBriefing, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, getTaskContextManifest, getTaskExecutionBrief, parseTaskContractResponse, resolveExecutionContext };
+export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskDependencyError, TaskDependencyService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeBriefing, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, getTaskContextManifest, getTaskExecutionBrief, parseTaskContractResponse, projectTaskLane, resolveExecutionContext };

package/dist/src/tasks/project-operating-view-service.d.ts

@@ -1,5 +1,6 @@
-import type { ProjectOperatingView } from '@xopcai/gateway-contract';
+import type { ProjectOperatingView, ProjectTaskCard } from '@xopcai/gateway-contract';
 import type { ProjectService } from '../projects/index.js';
+export declare function projectTaskLane(card: Pick<ProjectTaskCard, 'phase' | 'operationalState' | 'attention'>): ProjectTaskCard['lane'];
 export declare class ProjectOperatingViewService {
     #private;
     private readonly projects;

package/dist/src/tasks/project-operating-view-service.js

@@ -4,14 +4,15 @@ import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import { TaskDependencyService } from "./task-dependency-service.js";
 import { ProjectMonitoringService } from "./project-monitoring-service.js";
 //#region src/tasks/project-operating-view-service.ts
-function lane(card) {
+function projectTaskLane(card) {
 	if (card.phase === "closed") return "done";
-	if (card.operationalState === "waiting" || card.operationalState === "blocked") return "needs_user";
+	if (card.attention.some((item) => item.kind === "input_required" || item.kind === "approval_required")) return "needs_user";
 	if ([
 		"queued",
 		"running",
 		"verifying"
 	].includes(card.operationalState)) return "moving";
+	if (card.operationalState === "waiting" || card.operationalState === "blocked") return "waiting";
 	return "ready";
 }
 var ProjectOperatingViewService = class {
@@ -48,7 +49,7 @@ var ProjectOperatingViewService = class {
 			};
 			return {
 				...base,
-				lane: lane(base)
+				lane: projectTaskLane(base)
 			};
 		});
 		const recentReceipts = projectTasks.flatMap((task) => this.#runs.listReceipts(task.id, 10)).sort((a, b) => b.finalizedAt - a.finalizedAt).slice(0, 10);
@@ -56,6 +57,7 @@ var ProjectOperatingViewService = class {
 		return {
 			project,
 			tasks: cards.sort((a, b) => b.updatedAt - a.updatedAt),
+			dependencyEdges: this.#dependencies.listProjectEdges(project.id),
 			blockers: cards.flatMap((card) => card.attention.map((item) => ({
 				id: item.sourceId ?? `${card.id}:${item.kind}`,
 				kind: item.kind,
@@ -74,4 +76,4 @@ var ProjectOperatingViewService = class {
 	}
 };
 //#endregion
-export { ProjectOperatingViewService };
+export { ProjectOperatingViewService, projectTaskLane };

package/dist/src/tasks/task-dependency-service.d.ts

@@ -1,4 +1,4 @@
-import type { TaskDependencySummary } from '@xopcai/gateway-contract';
+import type { ProjectTaskDependencyEdge, TaskDependencySummary } from '@xopcai/gateway-contract';
 import { type TaskAggregate } from './task-repository.js';
 export type TaskDependencyErrorCode = 'not_found' | 'conflict' | 'invalid_dependency' | 'cycle';
 export declare class TaskDependencyError extends Error {
@@ -10,6 +10,7 @@ export declare class TaskDependencyService {
     listDependencies(taskId: string): TaskDependencySummary[];
     listDependents(taskId: string): TaskDependencySummary[];
     listBlocking(taskId: string): TaskDependencySummary[];
+    listProjectEdges(projectId: string): ProjectTaskDependencyEdge[];
     listReadyDependents(taskId: string): TaskAggregate[];
     replace(input: {
         taskId: string;

package/dist/src/tasks/task-dependency-service.js

@@ -23,6 +23,21 @@ var TaskDependencyService = class {
 	listBlocking(taskId) {
 		return this.listDependencies(taskId).filter((dependency) => dependency.phase !== "closed" || dependency.resolution !== "done");
 	}
+	listProjectEdges(projectId) {
+		return getSqliteDatabase().prepare(`SELECT edge.depends_on_task_id AS dependency_task_id,
+              edge.task_id AS dependent_task_id
+       FROM task_dependencies edge
+       JOIN tasks dependency ON dependency.task_id = edge.depends_on_task_id
+       JOIN tasks dependent ON dependent.task_id = edge.task_id
+       WHERE dependency.project_id = ? AND dependent.project_id = ?
+       ORDER BY edge.created_at ASC, edge.depends_on_task_id ASC, edge.task_id ASC`).all(projectId, projectId).map((row) => {
+			const edge = row;
+			return {
+				dependencyTaskId: edge.dependency_task_id,
+				dependentTaskId: edge.dependent_task_id
+			};
+		});
+	}
 	listReadyDependents(taskId) {
 		return getSqliteDatabase().prepare(`SELECT dependent.task_id
        FROM task_dependencies completed_edge

package/dist/src/tunnel/frpc-binary.js

@@ -6,8 +6,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { chmodSync, createWriteStream, existsSync, mkdirSync, rmSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
 //#region src/tunnel/frpc-binary.ts
 init_paths();
 init_logger();

package/dist/src/user-context/domain.d.ts

@@ -14,7 +14,8 @@ export type UserContextScope = {
     type: 'global' | 'workspace' | 'project' | 'session';
     id?: string;
 };
-export type UnderstandingKind = 'preference' | 'boundary' | 'relationship' | 'routine' | 'current_state' | 'long_term_goal' | 'project_context' | 'task_lesson' | 'derived_insight';
+export declare const UNDERSTANDING_KINDS: readonly ["preference", "boundary", "relationship", "routine", "current_state", "long_term_goal", "project_context", "task_lesson", "derived_insight"];
+export type UnderstandingKind = typeof UNDERSTANDING_KINDS[number];
 export type UnderstandingStatus = 'candidate' | 'active' | 'needs_review' | 'stale' | 'archived' | 'rejected';
 export type UserUnderstanding = {
     id: string;

package/dist/src/user-context/domain.js

@@ -1,4 +1,15 @@
 //#region src/user-context/domain.ts
 const USER_CONTEXT_PRINCIPAL_ID = "local-owner";
+const UNDERSTANDING_KINDS = [
+	"preference",
+	"boundary",
+	"relationship",
+	"routine",
+	"current_state",
+	"long_term_goal",
+	"project_context",
+	"task_lesson",
+	"derived_insight"
+];
 //#endregion
-export { USER_CONTEXT_PRINCIPAL_ID };
+export { UNDERSTANDING_KINDS, USER_CONTEXT_PRINCIPAL_ID };