Commit c637dfc454342c156dbe61ee8513f5e0ac0c4691 | the-knife

apps/server/src/git/GitManager.test.ts+8-6

 @@ -1589,16 +1589,18 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
       yield* initRepo(repoDir);
       const { manager } = yield* makeManager();
-      const errorMessage = yield* runStackedAction(manager, {
+      const error = yield* runStackedAction(manager, {
         cwd: repoDir,
         action: "commit",
         featureBranch: true,
-      }).pipe(
+      }).pipe(Effect.flip);
-        Effect.flip,
-        Effect.map((error) => error.message),
-      );
-      expect(errorMessage).toContain("no changes to commit");
+      expect(error).toMatchObject({
+        _tag: "GitManagerError",
+        operation: "runFeatureBranchStep",
+        cwd: repoDir,
+      });
+      expect(error.message).toContain("no changes to commit");
     }),
   );

apps/server/src/git/GitManager.ts+86-57

 @@ -320,14 +320,6 @@ function toPullRequestInfo(summary: ChangeRequest): PullRequestInfo {
   };
 }
-function gitManagerError(operation: string, detail: string, cause?: unknown): GitManagerError {
-  return new GitManagerError({
-    operation,
-    detail,
-    ...(cause !== undefined ? { cause } : {}),
-  });
-}
 function limitContext(value: string, maxChars: number): string {
   if (value.length <= maxChars) return value;
   return `${value.slice(0, maxChars)}\n\n[truncated]`;
 @@ -535,17 +527,27 @@ export const make = Effect.gen(function* () {
   const sourceControlProvider = (cwd: string) => sourceControlProviders.resolve({ cwd });
   const serverSettingsService = yield* ServerSettings.ServerSettingsService;
-  const randomUUIDv4 = crypto.randomUUIDv4.pipe(
+  const randomUUIDv4 = (cwd: string) =>
-    Effect.mapError((cause) =>
+    crypto.randomUUIDv4.pipe(
-      gitManagerError("randomUUIDv4", "Failed to generate Git operation identifier.", cause),
+      Effect.mapError(
-    ),
+        (cause) =>
-  );
+          new GitManagerError({
+            operation: "randomUUIDv4",
+            cwd,
+            detail: "Failed to generate Git operation identifier.",
+            cause,
+          }),
+      ),
+    );
   const createProgressEmitter = (
     input: { cwd: string; action: GitStackedAction },
     options?: GitRunStackedActionOptions,
   ) =>
-    (options?.actionId === undefined ? randomUUIDv4 : Effect.succeed(options.actionId)).pipe(
+    (options?.actionId === undefined
+      ? randomUUIDv4(input.cwd)
+      : Effect.succeed(options.actionId)
+    ).pipe(
       Effect.map((actionId) => {
         const reporter = options?.progressReporter;
         const emit = (event: GitActionProgressPayload) =>
 @@ -1284,16 +1286,18 @@ export const make = Effect.gen(function* () {
     const details = yield* gitCore.statusDetails(cwd);
     const branch = details.branch ?? fallbackBranch;
     if (!branch) {
-      return yield* gitManagerError(
+      return yield* new GitManagerError({
-        "runPrStep",
+        operation: "runPrStep",
-        "Cannot create a pull request from detached HEAD.",
+        cwd,
-      );
+        detail: "Cannot create a pull request from detached HEAD.",
+      });
     }
     if (!details.hasUpstream) {
-      return yield* gitManagerError(
+      return yield* new GitManagerError({
-        "runPrStep",
+        operation: "runPrStep",
-        "Current branch has not been pushed. Push before creating a PR.",
+        cwd,
-      );
+        detail: "Current branch has not been pushed. Push before creating a PR.",
+      });
     }
     const headContext = yield* resolveBranchHeadContext(cwd, {
 @@ -1332,14 +1336,21 @@ export const make = Effect.gen(function* () {
       modelSelection,
     });
-    const bodyFile = path.join(tempDir, `t3code-pr-body-${process.pid}-${yield* randomUUIDv4}.md`);
+    const bodyFile = path.join(
-    yield* fileSystem
+      tempDir,
-      .writeFileString(bodyFile, generated.body)
+      `t3code-pr-body-${process.pid}-${yield* randomUUIDv4(cwd)}.md`,
-      .pipe(
+    );
-        Effect.mapError((cause) =>
+    yield* fileSystem.writeFileString(bodyFile, generated.body).pipe(
-          gitManagerError("runPrStep", "Failed to write pull request body temp file.", cause),
+      Effect.mapError(
-        ),
+        (cause) =>
-      );
+          new GitManagerError({
+            operation: "runPrStep",
+            cwd,
+            detail: "Failed to write pull request body temp file.",
+            cause,
+          }),
+      ),
+    );
     yield* emit({
       kind: "phase_started",
       phase: "pr",
 @@ -1541,10 +1552,12 @@ export const make = Effect.gen(function* () {
         };
       }
       if (existingBranchBeforeFetchPath === rootWorktreePath) {
-        return yield* gitManagerError(
+        return yield* new GitManagerError({
-          "preparePullRequestThread",
+          operation: "preparePullRequestThread",
-          "This PR branch is already checked out in the main repo. Use Local, or switch the main repo off that branch before creating a worktree thread.",
+          cwd: input.cwd,
-        );
+          detail:
+            "This PR branch is already checked out in the main repo. Use Local, or switch the main repo off that branch before creating a worktree thread.",
+        });
       }
       yield* materializePullRequestHeadBranch(
 @@ -1569,10 +1582,12 @@ export const make = Effect.gen(function* () {
         };
       }
       if (existingBranchAfterFetchPath === rootWorktreePath) {
-        return yield* gitManagerError(
+        return yield* new GitManagerError({
-          "preparePullRequestThread",
+          operation: "preparePullRequestThread",
-          "This PR branch is already checked out in the main repo. Use Local, or switch the main repo off that branch before creating a worktree thread.",
+          cwd: input.cwd,
-        );
+          detail:
+            "This PR branch is already checked out in the main repo. Use Local, or switch the main repo off that branch before creating a worktree thread.",
+        });
       }
       const worktree = yield* gitCore.createWorktree({
 @@ -1607,10 +1622,11 @@ export const make = Effect.gen(function* () {
       modelSelection,
     });
     if (!suggestion) {
-      return yield* gitManagerError(
+      return yield* new GitManagerError({
-        "runFeatureBranchStep",
+        operation: "runFeatureBranchStep",
-        "Cannot create a feature branch because there are no changes to commit.",
+        cwd,
-      );
+        detail: "Cannot create a feature branch because there are no changes to commit.",
+      });
     }
     const preferredBranch = suggestion.branch ?? sanitizeFeatureBranchName(suggestion.subject);
 @@ -1647,16 +1663,18 @@ export const make = Effect.gen(function* () {
         const wantsPr = input.action === "create_pr" || input.action === "commit_push_pr";
         if (input.featureBranch && !wantsCommit) {
-          return yield* gitManagerError(
+          return yield* new GitManagerError({
-            "runStackedAction",
+            operation: "runStackedAction",
-            "Feature-branch checkout is only supported for commit actions.",
+            cwd: input.cwd,
-          );
+            detail: "Feature-branch checkout is only supported for commit actions.",
+          });
         }
         if (input.action === "create_pr" && initialStatus.hasWorkingTreeChanges) {
-          return yield* gitManagerError(
+          return yield* new GitManagerError({
-            "runStackedAction",
+            operation: "runStackedAction",
-            "Commit local changes before creating a PR.",
+            cwd: input.cwd,
-          );
+            detail: "Commit local changes before creating a PR.",
+          });
         }
         const phases: GitActionProgressPhase[] = [
 @@ -1672,13 +1690,18 @@ export const make = Effect.gen(function* () {
         });
         if (!input.featureBranch && wantsPush && !initialStatus.branch) {
-          return yield* gitManagerError("runStackedAction", "Cannot push from detached HEAD.");
+          return yield* new GitManagerError({
+            operation: "runStackedAction",
+            cwd: input.cwd,
+            detail: "Cannot push from detached HEAD.",
+          });
         }
         if (!input.featureBranch && wantsPr && !initialStatus.branch) {
-          return yield* gitManagerError(
+          return yield* new GitManagerError({
-            "runStackedAction",
+            operation: "runStackedAction",
-            "Cannot create a pull request from detached HEAD.",
+            cwd: input.cwd,
-          );
+            detail: "Cannot create a pull request from detached HEAD.",
+          });
         }
         let branchStep: { status: "created" | "skipped_not_requested"; name?: string };
 @@ -1687,8 +1710,14 @@ export const make = Effect.gen(function* () {
         const modelSelection = yield* serverSettingsService.getSettings.pipe(
           Effect.map((settings) => settings.textGenerationModelSelection),
-          Effect.mapError((cause) =>
+          Effect.mapError(
-            gitManagerError("runStackedAction", "Failed to get server settings.", cause),
+            (cause) =>
+              new GitManagerError({
+                operation: "runStackedAction",
+                cwd: input.cwd,
+                detail: "Failed to get server settings.",
+                cause,
+              }),
           ),
         );

apps/server/src/git/GitWorkflowService.test.ts+58-1

...	@@ -1,7 +1,9 @@	...	@@ -1,7 +1,9 @@
1	import { assert, describe, it, vi } from "@effect/vitest";	1	import { assert, describe, expect, it, vi } from "@effect/vitest";
2	import * as Effect from "effect/Effect";	2	import * as Effect from "effect/Effect";
3	import * as Layer from "effect/Layer";	3	import * as Layer from "effect/Layer";
4		4
		5	import { VcsRepositoryDetectionError } from "@t3tools/contracts";
		6
5	import * as GitManager from "./GitManager.ts";	7	import * as GitManager from "./GitManager.ts";
6	import * as GitWorkflowService from "./GitWorkflowService.ts";	8	import * as GitWorkflowService from "./GitWorkflowService.ts";
7	import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";	9	import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
...	@@ -132,4 +134,59 @@ describe("GitWorkflowService", () => {	...	@@ -132,4 +134,59 @@ describe("GitWorkflowService", () => {
132	),	134	),
133	),	135	),
134	);	136	);
		137
		138	it.effect("structures workflow detection failures without exposing upstream details", () => {
		139	const cause = new VcsRepositoryDetectionError({
		140	operation: "VcsDriverRegistry.detect",
		141	cwd: "/repo",
		142	detail: "upstream detail must stay in the cause chain",
		143	});
		144
		145	return Effect.gen(function* () {
		146	const workflow = yield* GitWorkflowService.GitWorkflowService;
		147	const error = yield* workflow.status({ cwd: "/repo" }).pipe(Effect.flip);
		148
		149	expect(error).toMatchObject({
		150	_tag: "GitManagerError",
		151	operation: "GitWorkflowService.status",
		152	cwd: "/repo",
		153	detail: "Failed to detect a VCS repository for this Git workflow.",
		154	});
		155	expect(error.message).not.toContain(cause.detail);
		156	}).pipe(
		157	Effect.provide(
		158	makeLayer({
		159	detect: () => Effect.fail(cause),
		160	}),
		161	),
		162	);
		163	});
		164
		165	it.effect("structures command detection failures without exposing upstream details", () => {
		166	const cause = new VcsRepositoryDetectionError({
		167	operation: "VcsDriverRegistry.detect",
		168	cwd: "/repo",
		169	detail: "upstream command detail must stay in the cause chain",
		170	});
		171
		172	return Effect.gen(function* () {
		173	const workflow = yield* GitWorkflowService.GitWorkflowService;
		174	const error = yield* workflow.listRefs({ cwd: "/repo" }).pipe(Effect.flip);
		175
		176	expect(error).toMatchObject({
		177	_tag: "GitCommandError",
		178	operation: "GitWorkflowService.listRefs",
		179	command: "vcs-route",
		180	cwd: "/repo",
		181	detail: "Failed to detect a VCS repository for this Git command.",
		182	});
		183	expect(error.message).not.toContain(cause.detail);
		184	}).pipe(
		185	Effect.provide(
		186	makeLayer({
		187	detect: () => Effect.fail(cause),
		188	}),
		189	),
		190	);
		191	});
135	});	192	});

apps/server/src/git/GitWorkflowService.ts+52-62

 @@ -94,20 +94,6 @@ export class GitWorkflowService extends Context.Service<
   }
 >()("t3/git/GitWorkflowService") {}
-const unsupportedGitWorkflow = (operation: string, cwd: string, detail: string) =>
-  new GitManagerError({
-    operation,
-    detail: `${detail} (${cwd})`,
-  });
-const unsupportedGitCommand = (operation: string, cwd: string, detail: string) =>
-  new GitCommandError({
-    operation,
-    command: "vcs-route",
-    cwd,
-    detail,
-  });
 function nonRepositoryLocalStatus(): VcsStatusLocalResult {
   return {
     isRepo: false,
 @@ -153,23 +139,23 @@ export const make = Effect.gen(function* () {
     operation: string,
     cwd: string,
   ) {
-    const handle = yield* registry
+    const handle = yield* registry.resolve({ cwd }).pipe(
-      .resolve({ cwd })
+      Effect.mapError(
-      .pipe(
+        (cause) =>
-        Effect.mapError((error) =>
+          new GitManagerError({
-          unsupportedGitWorkflow(
             operation,
             cwd,
-            error instanceof Error ? error.message : String(error),
+            detail: "Failed to resolve the VCS driver for this Git workflow.",
-          ),
+            cause,
-        ),
+          }),
-      );
+      ),
+    );
     if (handle.kind !== "git") {
-      return yield* unsupportedGitWorkflow(
+      return yield* new GitManagerError({
         operation,
         cwd,
-        `The ${operation} workflow currently supports Git repositories only; detected ${handle.kind}.`,
+        detail: `The ${operation} workflow currently supports Git repositories only; detected ${handle.kind}. (${cwd})`,
-      );
+      });
     }
   });
 @@ -177,48 +163,50 @@ export const make = Effect.gen(function* () {
     operation: string,
     cwd: string,
   ) {
-    const handle = yield* registry
+    const handle = yield* registry.resolve({ cwd }).pipe(
-      .resolve({ cwd })
+      Effect.mapError(
-      .pipe(
+        (cause) =>
-        Effect.mapError((error) =>
+          new GitCommandError({
-          unsupportedGitCommand(
             operation,
+            command: "vcs-route",
             cwd,
-            error instanceof Error ? error.message : String(error),
+            detail: "Failed to resolve the VCS driver for this Git command.",
-          ),
+            cause,
-        ),
+          }),
-      );
+      ),
+    );
     if (handle.kind !== "git") {
-      return yield* unsupportedGitCommand(
+      return yield* new GitCommandError({
         operation,
+        command: "vcs-route",
         cwd,
-        `The ${operation} command currently supports Git repositories only; detected ${handle.kind}.`,
+        detail: `The ${operation} command currently supports Git repositories only; detected ${handle.kind}.`,
-      );
+      });
     }
   });
   const detectGitRepositoryForStatus = Effect.fn("GitWorkflowService.detectGitRepositoryForStatus")(
     function* (operation: string, cwd: string) {
-      const handle = yield* registry
+      const handle = yield* registry.detect({ cwd }).pipe(
-        .detect({ cwd })
+        Effect.mapError(
-        .pipe(
+          (cause) =>
-          Effect.mapError((error) =>
+            new GitManagerError({
-            unsupportedGitWorkflow(
               operation,
               cwd,
-              error instanceof Error ? error.message : String(error),
+              detail: "Failed to detect a VCS repository for this Git workflow.",
-            ),
+              cause,
-          ),
+            }),
-        );
+        ),
+      );
       if (!handle) {
         return false;
       }
       if (handle.kind !== "git") {
-        return yield* unsupportedGitWorkflow(
+        return yield* new GitManagerError({
           operation,
           cwd,
-          `The ${operation} workflow currently supports Git repositories only; detected ${handle.kind}.`,
+          detail: `The ${operation} workflow currently supports Git repositories only; detected ${handle.kind}. (${cwd})`,
-        );
+        });
       }
       return true;
     },
 @@ -227,26 +215,28 @@ export const make = Effect.gen(function* () {
   const detectGitRepositoryForCommand = Effect.fn(
     "GitWorkflowService.detectGitRepositoryForCommand",
   )(function* (operation: string, cwd: string) {
-    const handle = yield* registry
+    const handle = yield* registry.detect({ cwd }).pipe(
-      .detect({ cwd })
+      Effect.mapError(
-      .pipe(
+        (cause) =>
-        Effect.mapError((error) =>
+          new GitCommandError({
-          unsupportedGitCommand(
             operation,
+            command: "vcs-route",
             cwd,
-            error instanceof Error ? error.message : String(error),
+            detail: "Failed to detect a VCS repository for this Git command.",
-          ),
+            cause,
-        ),
+          }),
-      );
+      ),
+    );
     if (!handle) {
       return false;
     }
     if (handle.kind !== "git") {
-      return yield* unsupportedGitCommand(
+      return yield* new GitCommandError({
         operation,
+        command: "vcs-route",
         cwd,
-        `The ${operation} command currently supports Git repositories only; detected ${handle.kind}.`,
+        detail: `The ${operation} command currently supports Git repositories only; detected ${handle.kind}.`,
-      );
+      });
     }
     return true;
   });

apps/server/src/vcs/VcsStatusBroadcaster.test.ts+61-3

...	@@ -1,11 +1,13 @@	...	@@ -1,11 +1,13 @@
1	import { assert, it, describe } from "@effect/vitest";	1	import { assert, it, describe } from "@effect/vitest";
2	import * as NodeServices from "@effect/platform-node/NodeServices";	2	import * as NodeServices from "@effect/platform-node/NodeServices";
		3	import * as Cause from "effect/Cause";
3	import * as Deferred from "effect/Deferred";	4	import * as Deferred from "effect/Deferred";
4	import * as Duration from "effect/Duration";	5	import * as Duration from "effect/Duration";
5	import * as Effect from "effect/Effect";	6	import * as Effect from "effect/Effect";
6	import * as Exit from "effect/Exit";	7	import * as Exit from "effect/Exit";
7	import * as FileSystem from "effect/FileSystem";	8	import * as FileSystem from "effect/FileSystem";
8	import * as Layer from "effect/Layer";	9	import * as Layer from "effect/Layer";
		10	import * as Logger from "effect/Logger";
9	import * as Option from "effect/Option";	11	import * as Option from "effect/Option";
10	import * as Path from "effect/Path";	12	import * as Path from "effect/Path";
11	import * as Scope from "effect/Scope";	13	import * as Scope from "effect/Scope";
...	@@ -190,6 +192,7 @@ describe("VcsStatusBroadcaster", () => {	...	@@ -190,6 +192,7 @@ describe("VcsStatusBroadcaster", () => {
190	? Effect.fail(	192	? Effect.fail(
191	new GitManagerError({	193	new GitManagerError({
192	operation: "VcsStatusBroadcaster.test",	194	operation: "VcsStatusBroadcaster.test",
		195	cwd: "/repo",
193	detail: "remote status failed",	196	detail: "remote status failed",
194	}),	197	}),
195	)	198	)
...	@@ -431,6 +434,12 @@ describe("VcsStatusBroadcaster", () => {	...	@@ -431,6 +434,12 @@ describe("VcsStatusBroadcaster", () => {
431	remoteInvalidationCalls: 0,	434	remoteInvalidationCalls: 0,
432	remoteStatusRefreshUpstreamValues: [] as Array<boolean \| undefined>,	435	remoteStatusRefreshUpstreamValues: [] as Array<boolean \| undefined>,
433	};	436	};
		437	const privateCwd = "/private/user/workspace/repo";
		438	const nestedCause = new Error("private nested VCS failure");
		439	const messages: Array<ReadonlyArray<unknown>> = [];
		440	const logger = Logger.make<unknown, void>(({ message }) => {
		441	messages.push(message as ReadonlyArray<unknown>);
		442	});
434	let firstRemoteAttemptDeferred: Deferred.Deferred<void> \| null = null;	443	let firstRemoteAttemptDeferred: Deferred.Deferred<void> \| null = null;
435	const testLayer = VcsStatusBroadcaster.layer.pipe(	444	const testLayer = VcsStatusBroadcaster.layer.pipe(
436	Layer.provideMerge(NodeServices.layer),	445	Layer.provideMerge(NodeServices.layer),
...	@@ -449,7 +458,9 @@ describe("VcsStatusBroadcaster", () => {	...	@@ -449,7 +458,9 @@ describe("VcsStatusBroadcaster", () => {
449	return Effect.fail(	458	return Effect.fail(
450	new GitManagerError({	459	new GitManagerError({
451	operation: "VcsStatusBroadcaster.test",	460	operation: "VcsStatusBroadcaster.test",
452	detail: "initial remote status failed",	461	cwd: privateCwd,
		462	detail: "private initial remote status failure",
		463	cause: nestedCause,
453	}),	464	}),
454	).pipe(	465	).pipe(
455	Effect.ensuring(	466	Effect.ensuring(
...	@@ -480,7 +491,7 @@ describe("VcsStatusBroadcaster", () => {	...	@@ -480,7 +491,7 @@ describe("VcsStatusBroadcaster", () => {
480	const remoteUpdatedDeferred = yield* Deferred.make<VcsStatusStreamEvent>();	491	const remoteUpdatedDeferred = yield* Deferred.make<VcsStatusStreamEvent>();
481	yield* Stream.runForEach(	492	yield* Stream.runForEach(
482	broadcaster.streamStatus(	493	broadcaster.streamStatus(
483	{ cwd: "/repo" },	494	{ cwd: privateCwd },
484	{ automaticRemoteRefreshInterval: Effect.succeed(Duration.zero) },	495	{ automaticRemoteRefreshInterval: Effect.succeed(Duration.zero) },
485	),	496	),
486	(event) =>	497	(event) =>
...	@@ -492,6 +503,24 @@ describe("VcsStatusBroadcaster", () => {	...	@@ -492,6 +503,24 @@ describe("VcsStatusBroadcaster", () => {
492	yield* Deferred.await(firstRemoteAttemptDeferred);	503	yield* Deferred.await(firstRemoteAttemptDeferred);
493	yield* Effect.yieldNow;	504	yield* Effect.yieldNow;
494	assert.equal(state.remoteStatusCalls, 1);	505	assert.equal(state.remoteStatusCalls, 1);
		506	assert.deepStrictEqual(
		507	messages.find((message) => message[0] === "VCS remote status refresh failed"),
		508	[
		509	"VCS remote status refresh failed",
		510	{
		511	cwdLength: privateCwd.length,
		512	reasonCount: 1,
		513	failureCount: 1,
		514	failureTags: ["GitManagerError"],
		515	failureOperations: ["VcsStatusBroadcaster.test"],
		516	defectCount: 0,
		517	defectTags: [],
		518	interruptionCount: 0,
		519	consecutiveFailures: 1,
		520	nextDelayMs: 30_000,
		521	},
		522	],
		523	);
495		524
496	yield* TestClock.adjust(Duration.seconds(30));	525	yield* TestClock.adjust(Duration.seconds(30));
497	const remoteUpdated = yield* Deferred.await(remoteUpdatedDeferred);	526	const remoteUpdated = yield* Deferred.await(remoteUpdatedDeferred);
...	@@ -505,7 +534,15 @@ describe("VcsStatusBroadcaster", () => {	...	@@ -505,7 +534,15 @@ describe("VcsStatusBroadcaster", () => {
505	assert.deepStrictEqual(state.remoteStatusRefreshUpstreamValues, [false, false]);	534	assert.deepStrictEqual(state.remoteStatusRefreshUpstreamValues, [false, false]);
506		535
507	yield* Scope.close(scope, Exit.void);	536	yield* Scope.close(scope, Exit.void);
508	}).pipe(Effect.provide(Layer.merge(testLayer, TestClock.layer())));	537	}).pipe(
		538	Effect.provide(
		539	Layer.mergeAll(
		540	testLayer,
		541	TestClock.layer(),
		542	Logger.layer([logger], { mergeWithExisting: false }),
		543	),
		544	),
		545	);
509	});	546	});
510		547
511	it.effect("delays automatic refresh when a cached remote snapshot is available", () => {	548	it.effect("delays automatic refresh when a cached remote snapshot is available", () => {
...	@@ -573,6 +610,27 @@ describe("VcsStatusBroadcaster", () => {	...	@@ -573,6 +610,27 @@ describe("VcsStatusBroadcaster", () => {
573	);	610	);
574	});	611	});
575		612
		613	it("summarizes refresh causes without exposing nested failure details", () => {
		614	const nestedCause = new Error("private nested failure detail");
		615	const failure = new GitManagerError({
		616	operation: "VcsStatusBroadcaster.remoteStatus",
		617	cwd: "/private/user/workspace/repo",
		618	detail: "private Git failure detail",
		619	cause: nestedCause,
		620	});
		621	const cause = Cause.combine(Cause.fail(failure), Cause.die(new TypeError("private defect")));
		622
		623	assert.deepStrictEqual(VcsStatusBroadcaster.remoteRefreshFailureDiagnostics(cause), {
		624	reasonCount: 2,
		625	failureCount: 1,
		626	failureTags: ["GitManagerError"],
		627	failureOperations: ["VcsStatusBroadcaster.remoteStatus"],
		628	defectCount: 1,
		629	defectTags: ["TypeError"],
		630	interruptionCount: 0,
		631	});
		632	});
		633
576	it.effect("stops the remote poller after the last stream subscriber disconnects", () => {	634	it.effect("stops the remote poller after the last stream subscriber disconnects", () => {
577	const state = {	635	const state = {
578	currentLocalStatus: baseLocalStatus,	636	currentLocalStatus: baseLocalStatus,

apps/server/src/vcs/VcsStatusBroadcaster.ts+93-2

...	@@ -1,3 +1,4 @@	...	@@ -1,3 +1,4 @@
		1	import * as Cause from "effect/Cause";
1	import * as Context from "effect/Context";	2	import * as Context from "effect/Context";
2	import * as Duration from "effect/Duration";	3	import * as Duration from "effect/Duration";
3	import * as Effect from "effect/Effect";	4	import * as Effect from "effect/Effect";
...	@@ -26,6 +27,91 @@ import * as GitWorkflowService from "../git/GitWorkflowService.ts";	...	@@ -26,6 +27,91 @@ import * as GitWorkflowService from "../git/GitWorkflowService.ts";
26	const DEFAULT_VCS_STATUS_REFRESH_INTERVAL = Duration.seconds(30);	27	const DEFAULT_VCS_STATUS_REFRESH_INTERVAL = Duration.seconds(30);
27	const VCS_STATUS_REFRESH_FAILURE_BASE_DELAY = Duration.seconds(30);	28	const VCS_STATUS_REFRESH_FAILURE_BASE_DELAY = Duration.seconds(30);
28	const VCS_STATUS_REFRESH_FAILURE_MAX_DELAY = Duration.minutes(15);	29	const VCS_STATUS_REFRESH_FAILURE_MAX_DELAY = Duration.minutes(15);
		30	const MAX_FAILURE_DIAGNOSTIC_VALUES = 8;
		31	const MAX_FAILURE_DIAGNOSTIC_VALUE_LENGTH = 128;
		32
		33	function boundedDiagnosticValue(value: string): string {
		34	return value.slice(0, MAX_FAILURE_DIAGNOSTIC_VALUE_LENGTH);
		35	}
		36
		37	function diagnosticValueTag(value: unknown): string {
		38	try {
		39	if (
		40	typeof value === "object" &&
		41	value !== null &&
		42	"_tag" in value &&
		43	typeof value._tag === "string"
		44	) {
		45	return boundedDiagnosticValue(value._tag);
		46	}
		47	if (value instanceof Error) {
		48	return boundedDiagnosticValue(value.name);
		49	}
		50	return typeof value;
		51	} catch {
		52	return "Uninspectable";
		53	}
		54	}
		55
		56	function diagnosticFailureOperation(value: unknown): string \| undefined {
		57	try {
		58	if (
		59	typeof value === "object" &&
		60	value !== null &&
		61	"operation" in value &&
		62	typeof value.operation === "string"
		63	) {
		64	return boundedDiagnosticValue(value.operation);
		65	}
		66	} catch {
		67	return undefined;
		68	}
		69	return undefined;
		70	}
		71
		72	function addUniqueDiagnosticValue(values: Array<string>, value: string \| undefined): void {
		73	if (
		74	value !== undefined &&
		75	values.length < MAX_FAILURE_DIAGNOSTIC_VALUES &&
		76	!values.includes(value)
		77	) {
		78	values.push(value);
		79	}
		80	}
		81
		82	export function remoteRefreshFailureDiagnostics(cause: Cause.Cause<unknown>) {
		83	const failureTags: Array<string> = [];
		84	const failureOperations: Array<string> = [];
		85	const defectTags: Array<string> = [];
		86	let failureCount = 0;
		87	let defectCount = 0;
		88	let interruptionCount = 0;
		89
		90	for (const reason of cause.reasons) {
		91	if (Cause.isFailReason(reason)) {
		92	failureCount += 1;
		93	addUniqueDiagnosticValue(failureTags, diagnosticValueTag(reason.error));
		94	addUniqueDiagnosticValue(failureOperations, diagnosticFailureOperation(reason.error));
		95	continue;
		96	}
		97	if (Cause.isDieReason(reason)) {
		98	defectCount += 1;
		99	addUniqueDiagnosticValue(defectTags, diagnosticValueTag(reason.defect));
		100	continue;
		101	}
		102	interruptionCount += 1;
		103	}
		104
		105	return {
		106	reasonCount: cause.reasons.length,
		107	failureCount,
		108	failureTags,
		109	failureOperations,
		110	defectCount,
		111	defectTags,
		112	interruptionCount,
		113	};
		114	}
29		115
30	interface VcsStatusChange {	116	interface VcsStatusChange {
31	readonly cwd: string;	117	readonly cwd: string;
...	@@ -318,14 +404,19 @@ export const make = Effect.gen(function* () {	...	@@ -318,14 +404,19 @@ export const make = Effect.gen(function* () {
318	return activeInterval;	404	return activeInterval;
319	}	405	}
320		406
		407	const interruptionReasons = exit.cause.reasons.filter(Cause.isInterruptReason);
		408	if (interruptionReasons.length > 0) {
		409	return yield* Effect.failCause(Cause.fromReasons<never>(interruptionReasons));
		410	}
		411
321	const consecutiveFailures = yield* Ref.updateAndGet(	412	const consecutiveFailures = yield* Ref.updateAndGet(
322	consecutiveFailuresRef,	413	consecutiveFailuresRef,
323	(count) => count + 1,	414	(count) => count + 1,
324	);	415	);
325	const nextDelay = remoteRefreshFailureDelay(consecutiveFailures, activeInterval);	416	const nextDelay = remoteRefreshFailureDelay(consecutiveFailures, activeInterval);
326	yield* Effect.logWarning("VCS remote status refresh failed", {	417	yield* Effect.logWarning("VCS remote status refresh failed", {
327	cwd,	418	cwdLength: cwd.length,
328	detail: exit.cause.toString(),	419	...remoteRefreshFailureDiagnostics(exit.cause),
329	consecutiveFailures,	420	consecutiveFailures,
330	nextDelayMs: Duration.toMillis(nextDelay),	421	nextDelayMs: Duration.toMillis(nextDelay),
331	});	422	});

packages/contracts/src/git.ts+1

...	@@ -352,6 +352,7 @@ export class TextGenerationError extends Schema.TaggedErrorClass<TextGenerationE	...	@@ -352,6 +352,7 @@ export class TextGenerationError extends Schema.TaggedErrorClass<TextGenerationE
352		352
353	export class GitManagerError extends Schema.TaggedErrorClass<GitManagerError>()("GitManagerError", {	353	export class GitManagerError extends Schema.TaggedErrorClass<GitManagerError>()("GitManagerError", {
354	operation: Schema.String,	354	operation: Schema.String,
		355	cwd: Schema.String,
355	detail: Schema.String,	356	detail: Schema.String,
356	cause: Schema.optional(Schema.Defect()),	357	cause: Schema.optional(Schema.Defect()),
357	}) {	358	}) {

author	Julius Marminge <julius0216@outlook.com> 2026-06-20 13:16:32-07:00
committer	GitHub <noreply@github.com> 2026-06-20 13:16:32-07:00
log	c637dfc454342c156dbe61ee8513f5e0ac0c4691
tree	e0b1f3a079ddccfd1edd2352b42f6728855fcae4
parent	6e9b43cb84c1b93c348d76880a0bf0083f395e47
signature	Signed by PGP key B5690EEEBB952194

[codex] enrich Git workflow errors (#3241)