@blackbelt-technology/pi-agent-dashboard 0.2.8 → 0.3.0

package/packages/server/src/tunnel.ts

@@ -27,6 +27,12 @@ const SPAWN_TIMEOUT_MS = 30_000;
 let activeProcess: ChildProcess | null = null;
 let activeTunnelUrl: string | null = null;
 let zrokAvailable: boolean | null = null;
+// Serialization: any concurrent createTunnel() call while one is already in
+// flight returns the same promise instead of spawning a second zrok process.
+// Without this, a UI double-click or a race between startup auto-connect and
+// an explicit `/api/tunnel-connect` created two parallel reservations and
+// two running `zrok share` processes for the same port.
+let pendingCreate: Promise<string | null> | null = null;
 
 // ── Binary Detection ────────────────────────────────────────────────
 
@@ -160,6 +166,72 @@ function saveReservedToken(token: string): void {
   }
 }
 
+/**
+ * Release a reserved share via `zrok release <token>`. Best-effort, non-throwing.
+ * Returns true if the release command exited cleanly, false otherwise. Callers
+ * should invoke this whenever abandoning a reserved token so the zrok edge
+ * doesn't keep an orphaned reservation record (which is what causes stale
+ * URLs like `tgbdzzvlar6b.share.zrok.io` to persist after the agent dies).
+ */
+export function releaseShare(token: string): boolean {
+  if (!token) return false;
+  try {
+    execSync(`zrok release ${token}`, {
+      timeout: 10_000,
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Scan `ps` for orphan `zrok share` processes that point at the given port
+ * via `--override-endpoint http://localhost:<port>` and SIGTERM them.
+ *
+ * This complements `cleanupStaleZrok` (which only knows about the single PID
+ * in our pid-file): when the retry logic in `createTunnel` leaks processes
+ * across failures, or when a previous server instance crashed, the pid-file
+ * loses track of them. On startup we scavenge them directly from the process
+ * table so a fresh tunnel doesn't compete with orphans.
+ *
+ * Returns the list of PIDs we killed.
+ */
+export function scavengeOrphanZrokProcesses(port: number): number[] {
+  const killed: number[] = [];
+  let output = "";
+  try {
+    output = execSync("ps -ax -o pid=,args=", {
+      encoding: "utf-8",
+      timeout: 5_000,
+    }).toString();
+  } catch {
+    return killed;
+  }
+
+  const endpointMarker = `--override-endpoint http://localhost:${port}`;
+  for (const line of output.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (!trimmed.includes("zrok share")) continue;
+    if (!trimmed.includes(endpointMarker)) continue;
+    const m = trimmed.match(/^(\d+)\s+/);
+    if (!m) continue;
+    const pid = parseInt(m[1], 10);
+    if (!Number.isFinite(pid) || pid <= 0) continue;
+    if (pid === process.pid) continue; // never kill ourselves
+    try {
+      process.kill(pid, "SIGTERM");
+      killed.push(pid);
+      console.log(`Scavenged orphan zrok process (PID ${pid})`);
+    } catch {
+      // Process may have exited between ps and kill — ignore
+    }
+  }
+  return killed;
+}
+
 /**
  * Create a reserved share via `zrok reserve public`.
  * Returns the share token or null on failure.
@@ -195,7 +267,29 @@ function reserveShare(port: number): Promise<string | null> {
  * On subsequent runs, reuses the reserved token.
  * Returns URL or null on failure.
  */
-export function createTunnel(port: number, reservedToken?: string): Promise<string | null> {
+export function createTunnel(
+  port: number,
+  reservedToken?: string,
+  retriesLeft: number = 1,
+): Promise<string | null> {
+  // Fast path: another caller is already creating a tunnel — join that promise.
+  if (pendingCreate) return pendingCreate;
+  // Fast path: tunnel already up — return its URL without spawning.
+  if (activeTunnelUrl) return Promise.resolve(activeTunnelUrl);
+
+  const promise = _createTunnelInner(port, reservedToken, retriesLeft);
+  pendingCreate = promise;
+  promise.finally(() => {
+    if (pendingCreate === promise) pendingCreate = null;
+  });
+  return promise;
+}
+
+function _createTunnelInner(
+  port: number,
+  reservedToken?: string,
+  retriesLeft: number = 1,
+): Promise<string | null> {
   return new Promise(async (resolve) => {
     if (!detectZrokBinary()) {
       resolve(null);
@@ -209,7 +303,11 @@ export function createTunnel(port: number, reservedToken?: string): Promise<stri
       return;
     }
 
-    // Try to get or create a reserved token
+    // Track whether this call reserved the token itself (so we know to
+    // release it if we subsequently time out or fail — the caller-provided
+    // `reservedToken` is owned by the caller / config and must not be released
+    // on transient timeouts).
+    const callerProvidedToken = !!reservedToken;
     let token = reservedToken;
     if (!token) {
       token = await reserveShare(port) ?? undefined;
@@ -228,12 +326,19 @@ export function createTunnel(port: number, reservedToken?: string): Promise<stri
       detached: false,
     });
 
-    // Timeout: kill process if URL not parsed in time
+    // Timeout: kill process if URL not parsed in time. Escalate SIGTERM
+    // → SIGKILL after a grace period so a wedged zrok doesn't keep a stale
+    // reservation attached after we've moved on. If we reserved the token
+    // just-in-time within this call, release it on the zrok edge too so we
+    // don't leak a dead reservation (root cause of stale URLs like
+    // `tgbdzzvlar6b.share.zrok.io`).
     const timeout = setTimeout(() => {
       if (!resolved) {
         resolved = true;
         console.warn("zrok tunnel creation timed out (30s)");
         try { child.kill("SIGTERM"); } catch {}
+        setTimeout(() => { try { child.kill("SIGKILL"); } catch {} }, 2_000);
+        if (token && !callerProvidedToken) releaseShare(token);
         removeZrokPid();
         resolve(null);
       }
@@ -270,10 +375,20 @@ export function createTunnel(port: number, reservedToken?: string): Promise<stri
       if (!resolved) {
         resolved = true;
         clearTimeout(timeout);
-        // If reserved share failed, token may be expired — retry with fresh reservation
-        if (token) {
-          console.warn(`Reserved share failed (code ${code}), creating new reservation...`);
-          resolve(createTunnel(port)); // retry without token
+        // If reserved share failed, token may be expired or already attached
+        // to an orphan process. Release it on the zrok edge before retrying so
+        // we don't leak dead reservations (which is what produced stale URLs
+        // like `tgbdzzvlar6b.share.zrok.io` pointing at nothing).
+        if (token && retriesLeft > 0) {
+          console.warn(`Reserved share failed (code ${code}), releasing token ${token} and creating new reservation...`);
+          releaseShare(token);
+          // Bypass the mutex wrapper so we don't self-deadlock: call the inner
+          // implementation directly for the retry attempt.
+          resolve(_createTunnelInner(port, undefined, retriesLeft - 1));
+        } else if (token) {
+          console.warn(`Reserved share failed (code ${code}) and retry budget exhausted; releasing token ${token}`);
+          releaseShare(token);
+          resolve(null);
         } else {
           console.warn(`zrok process exited before producing URL (code ${code})`);
           resolve(null);
@@ -291,8 +406,11 @@ export function createTunnel(port: number, reservedToken?: string): Promise<stri
 
 /**
  * Stop the active tunnel. Kills the subprocess and removes PID file.
+ * Also sweeps any orphan zrok processes bound to the given port so restart
+ * paths (which call `deleteTunnel` then spawn a new server) don't leave
+ * dead reservations attached to the zrok edge.
  */
-export async function deleteTunnel(): Promise<void> {
+export async function deleteTunnel(port?: number): Promise<void> {
   const child = activeProcess;
   activeProcess = null;
   activeTunnelUrl = null;
@@ -305,6 +423,12 @@ export async function deleteTunnel(): Promise<void> {
     }
   }
   removeZrokPid();
+
+  // Belt-and-braces: sweep any orphan zrok processes that escaped pid-file
+  // tracking (e.g. from a previous crash or a failed retry chain).
+  if (typeof port === "number") {
+    try { scavengeOrphanZrokProcesses(port); } catch { /* best-effort */ }
+  }
 }
 
 /**

package/packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-shared",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "Shared types and utilities for pi-dashboard",
   "type": "module",
   "exports": {

package/packages/shared/src/__tests__/config.test.ts

@@ -27,7 +27,7 @@ describe("loadConfig", () => {
     expect(config.port).toBe(8000);
     expect(config.piPort).toBe(9999);
     expect(config.autoStart).toBe(true);
-    expect(config.autoShutdown).toBe(true);
+    expect(config.autoShutdown).toBe(false);
     expect(config.lastServer).toBeUndefined();
     expect(config.shutdownIdleSeconds).toBe(300);
   });
@@ -52,7 +52,7 @@ describe("loadConfig", () => {
     expect(config.port).toBe(3000);
     expect(config.piPort).toBe(9999);
     expect(config.autoStart).toBe(true);
-    expect(config.autoShutdown).toBe(true);
+    expect(config.autoShutdown).toBe(false);
     expect(config.shutdownIdleSeconds).toBe(300);
   });
 
@@ -333,7 +333,7 @@ describe("ensureConfig", () => {
     expect(content.port).toBe(8000);
     expect(content.piPort).toBe(9999);
     expect(content.autoStart).toBe(true);
-    expect(content.autoShutdown).toBe(true);
+    expect(content.autoShutdown).toBe(false);
     expect(content.shutdownIdleSeconds).toBe(300);
     expect(content.devBuildOnReload).toBe(false);
     expect(content.electronMode).toBeUndefined();

package/packages/shared/src/__tests__/openspec-poller.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { buildOpenSpecData } from "../openspec-poller.js";
+
+describe("buildOpenSpecData - isComplete pass-through", () => {
+  const listResult = {
+    changes: [
+      { name: "a", status: "in-progress", completedTasks: 1, totalTasks: 3 },
+      { name: "b", status: "in-progress", completedTasks: 0, totalTasks: 5 },
+      { name: "c", status: "complete", completedTasks: 2, totalTasks: 2 },
+    ],
+  };
+
+  it("passes isComplete=true through", () => {
+    const statusResults = new Map<string, any>([
+      ["a", { artifacts: [{ id: "proposal", status: "done" }], isComplete: true }],
+      ["b", null],
+      ["c", null],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults);
+    const a = data.changes.find((c) => c.name === "a")!;
+    expect(a.isComplete).toBe(true);
+  });
+
+  it("passes isComplete=false through", () => {
+    const statusResults = new Map<string, any>([
+      ["a", { artifacts: [], isComplete: false }],
+      ["b", null],
+      ["c", null],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults);
+    expect(data.changes.find((c) => c.name === "a")!.isComplete).toBe(false);
+  });
+
+  it("leaves isComplete undefined when absent from status result", () => {
+    const statusResults = new Map<string, any>([
+      ["a", { artifacts: [] }],
+      ["b", null],
+      ["c", null],
+    ]);
+    const data = buildOpenSpecData(listResult, statusResults);
+    expect("isComplete" in data.changes.find((c) => c.name === "a")!).toBe(false);
+    expect(data.changes.find((c) => c.name === "b")!.isComplete).toBeUndefined();
+  });
+});

package/packages/shared/src/__tests__/recommended-extensions.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect } from "vitest";
+import {
+	RECOMMENDED_EXTENSIONS,
+	getRecommendedExtension,
+	getRecommendedByStatus,
+	type RecommendedExtension,
+} from "../recommended-extensions.js";
+
+describe("RECOMMENDED_EXTENSIONS manifest", () => {
+	it("contains exactly the five expected entries", () => {
+		const ids = RECOMMENDED_EXTENSIONS.map((e) => e.id).sort();
+		expect(ids).toEqual(
+			[
+				"pi-anthropic-messages",
+				"pi-agent-browser",
+				"pi-flows",
+				"pi-web-access",
+				"tintinweb-pi-subagents",
+			].sort(),
+		);
+	});
+
+	it("every entry has the required shape", () => {
+		for (const entry of RECOMMENDED_EXTENSIONS) {
+			expect(typeof entry.id).toBe("string");
+			expect(entry.id.length).toBeGreaterThan(0);
+			expect(typeof entry.source).toBe("string");
+			expect(entry.source.length).toBeGreaterThan(0);
+			expect(typeof entry.displayName).toBe("string");
+			expect(typeof entry.fallbackDescription).toBe("string");
+			expect(entry.fallbackDescription.length).toBeGreaterThan(10);
+			expect(["required", "strongly-suggested", "optional"]).toContain(entry.status);
+			expect(Array.isArray(entry.unlocks)).toBe(true);
+			expect(entry.unlocks.length).toBeGreaterThan(0);
+		}
+	});
+
+	it("pi-anthropic-messages is marked required and uses SSH git URL", () => {
+		const entry = getRecommendedExtension("pi-anthropic-messages");
+		expect(entry).toBeDefined();
+		expect(entry?.status).toBe("required");
+		expect(entry?.source).toContain("git@github.com:BlackBeltTechnology/pi-anthropic-messages.git");
+		expect(entry?.autowired).toBe(true);
+	});
+
+	it("pi-flows uses SSH git URL and registers flow-engine tools", () => {
+		const entry = getRecommendedExtension("pi-flows");
+		expect(entry).toBeDefined();
+		expect(entry?.source).toBe("git@github.com:BlackBeltTechnology/pi-flows.git");
+		expect(entry?.toolsRegistered).toContain("subagent");
+		expect(entry?.toolsRegistered).toContain("flow_write");
+	});
+
+	it("tintinweb-pi-subagents registers Agent under its canonical capitalization", () => {
+		const entry = getRecommendedExtension("tintinweb-pi-subagents");
+		expect(entry).toBeDefined();
+		expect(entry?.source).toBe("npm:@tintinweb/pi-subagents");
+		expect(entry?.toolsRegistered).toContain("Agent");
+	});
+
+	it("npm-sourced entries use the npm: prefix", () => {
+		const npmEntries = RECOMMENDED_EXTENSIONS.filter((e) => e.source.startsWith("npm:"));
+		expect(npmEntries.map((e) => e.id).sort()).toEqual(
+			["pi-agent-browser", "pi-web-access", "tintinweb-pi-subagents"].sort(),
+		);
+	});
+
+	it("git-sourced entries use the git@github.com:/.git SSH form", () => {
+		const gitEntries = RECOMMENDED_EXTENSIONS.filter((e) =>
+			e.source.startsWith("git@github.com:"),
+		);
+		for (const entry of gitEntries) {
+			expect(entry.source).toMatch(/^git@github\.com:[^/]+\/[^/]+\.git$/);
+		}
+		expect(gitEntries.map((e) => e.id).sort()).toEqual(
+			["pi-anthropic-messages", "pi-flows"].sort(),
+		);
+	});
+});
+
+describe("getRecommendedExtension", () => {
+	it("returns the entry when id matches", () => {
+		const e = getRecommendedExtension("pi-web-access");
+		expect(e?.displayName).toBe("pi-web-access");
+	});
+
+	it("returns undefined for unknown ids", () => {
+		expect(getRecommendedExtension("does-not-exist")).toBeUndefined();
+	});
+});
+
+describe("getRecommendedByStatus", () => {
+	it("filters by required", () => {
+		const required = getRecommendedByStatus("required");
+		expect(required.map((e) => e.id)).toEqual(["pi-anthropic-messages"]);
+	});
+
+	it("filters by strongly-suggested", () => {
+		const suggested = getRecommendedByStatus("strongly-suggested");
+		expect(suggested.map((e) => e.id).sort()).toEqual(
+			["pi-flows", "pi-web-access", "tintinweb-pi-subagents"].sort(),
+		);
+	});
+
+	it("filters by optional", () => {
+		const optional = getRecommendedByStatus("optional");
+		expect(optional.map((e) => e.id)).toEqual(["pi-agent-browser"]);
+	});
+});
+
+describe("RecommendedExtension type", () => {
+	it("accepts a minimal entry", () => {
+		const entry: RecommendedExtension = {
+			id: "x",
+			source: "npm:x",
+			displayName: "X",
+			fallbackDescription: "A test extension description.",
+			status: "optional",
+			unlocks: ["something"],
+		};
+		expect(entry.id).toBe("x");
+	});
+});

package/packages/shared/src/__tests__/source-matching.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect } from "vitest";
+import { parseSourceKey, sourcesMatch } from "../source-matching.js";
+
+describe("parseSourceKey", () => {
+	it("parses npm:<name>", () => {
+		expect(parseSourceKey("npm:pi-web-access")).toEqual({ kind: "npm", name: "pi-web-access" });
+	});
+
+	it("parses npm:<name>@<version>", () => {
+		expect(parseSourceKey("npm:pi-web-access@0.10.6")).toEqual({
+			kind: "npm",
+			name: "pi-web-access",
+		});
+	});
+
+	it("parses scoped npm name without version", () => {
+		expect(parseSourceKey("npm:@tintinweb/pi-subagents")).toEqual({
+			kind: "npm",
+			name: "@tintinweb/pi-subagents",
+		});
+	});
+
+	it("parses scoped npm name with version", () => {
+		expect(parseSourceKey("npm:@tintinweb/pi-subagents@0.5.2")).toEqual({
+			kind: "npm",
+			name: "@tintinweb/pi-subagents",
+		});
+	});
+
+	it("parses git SSH sources", () => {
+		expect(parseSourceKey("git@github.com:BlackBeltTechnology/pi-flows.git")).toEqual({
+			kind: "git",
+			host: "github.com",
+			owner: "BlackBeltTechnology",
+			repo: "pi-flows",
+		});
+	});
+
+	it("parses git HTTPS sources", () => {
+		expect(parseSourceKey("https://github.com/BlackBeltTechnology/pi-flows.git")).toEqual({
+			kind: "git",
+			host: "github.com",
+			owner: "BlackBeltTechnology",
+			repo: "pi-flows",
+		});
+	});
+
+	it("parses git:<host>/... sources", () => {
+		expect(parseSourceKey("git:github.com/BlackBeltTechnology/pi-flows#main")).toEqual({
+			kind: "git",
+			host: "github.com",
+			owner: "BlackBeltTechnology",
+			repo: "pi-flows",
+		});
+	});
+
+	it("returns raw for local paths", () => {
+		expect(parseSourceKey("../pi-flows")).toEqual({ kind: "raw", source: "../pi-flows" });
+		expect(parseSourceKey("/abs/path")).toEqual({ kind: "raw", source: "/abs/path" });
+	});
+});
+
+describe("sourcesMatch", () => {
+	it("matches npm by name regardless of version", () => {
+		expect(sourcesMatch("npm:pi-web-access@0.10.6", "npm:pi-web-access")).toBe(true);
+	});
+
+	it("matches scoped npm names", () => {
+		expect(
+			sourcesMatch("npm:@tintinweb/pi-subagents@0.5.2", "npm:@tintinweb/pi-subagents"),
+		).toBe(true);
+	});
+
+	it("matches git SSH vs HTTPS forms", () => {
+		expect(
+			sourcesMatch(
+				"git@github.com:BlackBeltTechnology/pi-flows.git",
+				"https://github.com/BlackBeltTechnology/pi-flows.git",
+			),
+		).toBe(true);
+	});
+
+	it("is case-insensitive for git host/owner/repo", () => {
+		expect(
+			sourcesMatch(
+				"git@github.com:BlackBeltTechnology/pi-flows.git",
+				"git@github.com:blackbelttechnology/pi-flows.git",
+			),
+		).toBe(true);
+	});
+
+	it("distinguishes different repos", () => {
+		expect(
+			sourcesMatch(
+				"git@github.com:BlackBeltTechnology/pi-flows.git",
+				"git@github.com:BlackBeltTechnology/pi-anthropic-messages.git",
+			),
+		).toBe(false);
+	});
+
+	it("distinguishes different npm names", () => {
+		expect(sourcesMatch("npm:pi-web-access", "npm:pi-agent-browser")).toBe(false);
+	});
+
+	it("cross-matches git URL against local path whose basename is the repo", () => {
+		expect(
+			sourcesMatch(
+				"git@github.com:BlackBeltTechnology/pi-flows.git",
+				"../pi-flows",
+			),
+		).toBe(true);
+		expect(
+			sourcesMatch(
+				"../pi-anthropic-messages/",
+				"git@github.com:BlackBeltTechnology/pi-anthropic-messages.git",
+			),
+		).toBe(true);
+		expect(
+			sourcesMatch(
+				"git@github.com:Org/pi-flows.git",
+				"/abs/path/to/pi-flows.git",
+			),
+		).toBe(true);
+	});
+
+	it("does not cross-match a git URL against an unrelated local path", () => {
+		expect(
+			sourcesMatch(
+				"git@github.com:BlackBeltTechnology/pi-flows.git",
+				"../pi-web-access",
+			),
+		).toBe(false);
+	});
+
+	it("does not cross-match a git URL against a deep local path", () => {
+		expect(
+			sourcesMatch(
+				"git@github.com:BlackBeltTechnology/pi-flows.git",
+				"../pi-flows/packages/core",
+			),
+		).toBe(false);
+	});
+});

package/packages/shared/src/browser-protocol.ts

@@ -92,6 +92,10 @@ export interface BrowserModelsListMessage {
   models: ModelInfo[];
 }
 
+export interface ModelsRefreshedMessage {
+  type: "models_refreshed";
+}
+
 export interface BrowserRolesListMessage {
   type: "roles_list";
   sessionId: string;
@@ -207,6 +211,21 @@ export interface PackageProgressMessage {
   };
 }
 
+/** Progress event streamed during a pi core package update. */
+export interface PiCoreUpdateProgressMessage {
+  type: "pi_core_update_progress";
+  name: string;
+  phase: "start" | "output" | "complete" | "error";
+  message?: string;
+}
+
+/** Sent when a full pi core update batch finishes. */
+export interface PiCoreUpdateCompleteMessage {
+  type: "pi_core_update_complete";
+  results: Array<{ name: string; success: boolean; error?: string }>;
+  sessionsReloaded: number;
+}
+
 /** Sent when a package operation finishes (success or failure). */
 export interface PackageOperationCompleteMessage {
   type: "package_operation_complete";
@@ -244,6 +263,8 @@ export type ServerToBrowserMessage =
   | SessionStateResetMessage
   | PackageProgressMessage
   | PackageOperationCompleteMessage
+  | PiCoreUpdateProgressMessage
+  | PiCoreUpdateCompleteMessage
   | EditorStatusMessage
   | ForceKillResultMessage
   | BrowserRolesListMessage
@@ -252,7 +273,8 @@ export type ServerToBrowserMessage =
   | ServersUpdatedMessage
   | BrowserPromptRequestMessage
   | BrowserPromptDismissMessage
-  | BrowserPromptCancelMessage;
+  | BrowserPromptCancelMessage
+  | ModelsRefreshedMessage;
 
 // ── Browser → Server ────────────────────────────────────────────────
 

package/packages/shared/src/openspec-poller.ts

@@ -40,9 +40,9 @@ async function runOpenSpecAsync(args: string[], cwd: string): Promise<unknown |
   }
 }
 
-function buildOpenSpecData(
+export function buildOpenSpecData(
   listResult: { changes?: Array<{ name: string; status: string; completedTasks: number; totalTasks: number }> } | null,
-  statusResults: Map<string, { artifacts?: Array<{ id: string; status: string }> } | null>,
+  statusResults: Map<string, { artifacts?: Array<{ id: string; status: string }>; isComplete?: boolean } | null>,
 ): OpenSpecData {
   if (!listResult || !Array.isArray(listResult.changes)) {
     return EMPTY_DATA;
@@ -55,13 +55,18 @@ function buildOpenSpecData(
       status: (a.status === "done" ? "done" : a.status === "ready" ? "ready" : "blocked") as OpenSpecArtifact["status"],
     }));
 
-    return {
+    const isComplete =
+      typeof statusResult?.isComplete === "boolean" ? statusResult.isComplete : undefined;
+
+    const change: OpenSpecChange = {
       name: c.name,
       status: (c.status === "complete" ? "complete" : c.status === "in-progress" ? "in-progress" : "no-tasks") as OpenSpecChange["status"],
       completedTasks: c.completedTasks ?? 0,
       totalTasks: c.totalTasks ?? 0,
       artifacts,
     };
+    if (isComplete !== undefined) change.isComplete = isComplete;
+    return change;
   });
 
   return { initialized: true, changes };