@devries-cameron20 / t3code-1 / commits / 4773ab7a71
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(server): scheduled tasks start from the default branch, not always main (#27983)

Vux committed Nov 1, 2026 at 09:44 UTC 4773ab7a716bc8493b97ec8521965a265497ea4b
2 files changed +261 -10
apps/server/src/mcp/OrchestratorMcpService.test.ts
+213
@@ -3,6 +3,7 @@ import { assert, describe, it } from "@effect/vitest";
3 import {
4 CommandId,
5 EnvironmentId,
6 + GitCommandError,
7 MessageId,
8 NodeId,
9 ORCHESTRATOR_MCP_RUNNING_TASK_NEXT,
@@ -2577,6 +2578,218 @@ describe("OrchestratorMcpService provider resolution", () => {
2578 }),
2579 );
2580 });
2581 +
2582 + describe("the base branch of an unbound scheduled task", () => {
2583 + const projectId = ProjectId.make("project:scheduled-base");
2584 + const workspaceRoot = "/repo/scheduled-base";
2585 + const existing: ScheduledTask = {
2586 + id: ScheduledTaskId.make("scheduled-task:base"),
2587 + title: "Nightly",
2588 + prompt: "Check the build",
2589 + enabled: true,
2590 + schedule: { type: "interval", everyMs: 3_600_000 },
2591 + projectId,
2592 + threadId: null,
2593 + workspaceStrategy: { type: "root" },
2594 + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5" },
2595 + runtimeMode: "approval-required",
2596 + interactionMode: "default",
2597 + createdBy: "agent",
2598 + creationSource: "mcp",
2599 + createdAt: "2026-10-05T00:00:00.000Z",
2600 + updatedAt: "2026-10-05T00:00:00.000Z",
2601 + nextRunAt: null,
2602 + lastRunAt: null,
2603 + lastRunStatus: "never",
2604 + lastRunError: null,
2605 + runCount: 0,
2606 + };
2607 + const client: McpInvocationScope = {
2608 + environmentId: EnvironmentId.make("environment:scheduled-base"),
2609 + requestNamespace: "client:scheduled-base",
2610 + thread: undefined,
2611 + client: {
2612 + sessionId: "scheduled-base",
2613 + label: "Claude Code",
2614 + access: "approval-required",
2615 + },
2616 + capabilities: new Set(["orchestration"]),
2617 + issuedAt: 1,
2618 + };
2619 + const service = (
2620 + git: Partial<GitVcsDriver.GitVcsDriver["Service"]>,
2621 + saved: Ref.Ref<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>,
2622 + ) =>
2623 + OrchestratorMcpService.layer.pipe(
2624 + Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
2625 + Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)(git)),
2626 + Layer.provide(
2627 + Layer.mergeAll(
2628 + NodeServices.layer,
2629 + Layer.mock(ThreadManagementService.ThreadManagementService)({}),
2630 + ServerSettings.layerTest(),
2631 + Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
2632 + Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
2633 + list: () => Effect.succeed([]),
2634 + }),
2635 + Layer.mock(ProjectService.ProjectService)({
2636 + getById: () =>
2637 + Effect.succeedSome({
2638 + id: projectId,
2639 + workspaceRoot,
2640 + defaultModelSelection: existing.modelSelection,
2641 + } as never),
2642 + }),
2643 + Layer.mock(SecretRequests.SecretRequests)({}),
2644 + Layer.mock(RemoteDelegation.RemoteDelegation)({}),
2645 + Layer.mock(ScheduledTaskService.ScheduledTaskService)({
2646 + list: () => Effect.succeed({ tasks: [existing] }),
2647 + upsert: (input) =>
2648 + Ref.update(saved, (strategies) => [...strategies, input.workspaceStrategy]).pipe(
2649 + Effect.as({ task: existing }),
2650 + ),
2651 + }),
2652 + ),
2653 + ),
2654 + );
2655 + const masterRepository: Partial<GitVcsDriver.GitVcsDriver["Service"]> = {
2656 + resolvePrimaryRemoteName: () => Effect.succeed("origin"),
2657 + resolveDefaultBranchName: (cwd, remoteName) =>
2658 + Effect.succeed(cwd === workspaceRoot && remoteName === "origin" ? "master" : null),
2659 + resolveCommit: () => Effect.succeed({ commitSha: "abc123" }),
2660 + };
2661 + const schedule = { type: "interval", everyMs: 3_600_000 } as const;
2662 +
2663 + it.effect("starts from the project's default branch", () =>
2664 + Effect.gen(function* () {
2665 + const saved = yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]);
2666 + const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
2667 + Effect.provide(service(masterRepository, saved)),
2668 + );
2669 + yield* mcp.scheduleTask(client, { projectId, prompt: "Check the build", schedule });
2670 + assert.deepEqual(yield* Ref.get(saved), [
2671 + { type: "worktree", baseRef: "origin/master", startFromOrigin: true },
2672 + ]);
2673 + }),
2674 + );
2675 +
2676 + it.effect("follows the default branch when a task is unbound from its thread", () =>
2677 + Effect.gen(function* () {
2678 + const saved = yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]);
2679 + const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
2680 + Effect.provide(service(masterRepository, saved)),
2681 + );
2682 + yield* mcp.updateScheduledTask(client, {
2683 + scheduledTaskId: existing.id,
2684 + bindToCurrentThread: false,
2685 + });
2686 + assert.deepEqual(yield* Ref.get(saved), [
2687 + { type: "worktree", baseRef: "origin/master", startFromOrigin: true },
2688 + ]);
2689 + }),
2690 + );
2691 +
2692 + it.effect.each([
2693 + {
2694 + name: "no remote, only master",
2695 + remote: null,
2696 + remoteDefault: null,
2697 + refs: ["refs/heads/master"],
2698 + baseRef: "master",
2699 + },
2700 + {
2701 + name: "no remote, main and master",
2702 + remote: null,
2703 + remoteDefault: null,
2704 + refs: ["refs/heads/master", "refs/heads/main"],
2705 + baseRef: "main",
2706 + },
2707 + {
2708 + name: "no remote, neither main nor master",
2709 + remote: null,
2710 + remoteDefault: null,
2711 + refs: ["refs/heads/develop"],
2712 + baseRef: "main",
2713 + },
2714 + {
2715 + name: "no recorded HEAD, remote main and a stale local master",
2716 + remote: "origin",
2717 + remoteDefault: null,
2718 + refs: ["refs/heads/master", "refs/remotes/origin/main"],
2719 + baseRef: "origin/main",
2720 + },
2721 + {
2722 + name: "no recorded HEAD, master only on the remote",
2723 + remote: "origin",
2724 + remoteDefault: null,
2725 + refs: ["refs/remotes/origin/master"],
2726 + baseRef: "origin/master",
2727 + },
2728 + {
2729 + name: "no recorded HEAD, local main and master only on the remote",
2730 + remote: "origin",
2731 + remoteDefault: null,
2732 + refs: ["refs/heads/main", "refs/remotes/origin/master"],
2733 + baseRef: "origin/master",
2734 + },
2735 + {
2736 + name: "no recorded HEAD, nothing conventional on the remote, local main",
2737 + remote: "origin",
2738 + remoteDefault: null,
2739 + refs: ["refs/heads/main", "refs/remotes/origin/develop"],
2740 + baseRef: "main",
2741 + },
2742 + {
2743 + name: "a recorded HEAD whose branch is gone",
2744 + remote: "origin",
2745 + remoteDefault: "main",
2746 + refs: ["refs/heads/main", "refs/remotes/origin/master"],
2747 + baseRef: "origin/master",
2748 + },
2749 + {
2750 + name: "a remote not called origin",
2751 + remote: "upstream",
2752 + remoteDefault: "develop",
2753 + refs: ["refs/remotes/upstream/develop"],
2754 + baseRef: "upstream/develop",
2755 + },
2756 + {
2757 + name: "a remote not called origin, no recorded HEAD",
2758 + remote: "upstream",
2759 + remoteDefault: null,
2760 + refs: ["refs/remotes/upstream/main"],
2761 + baseRef: "upstream/main",
2762 + },
2763 + ])("$name starts from $baseRef", ({ remote, remoteDefault, refs, baseRef }) =>
2764 + Effect.gen(function* () {
2765 + const saved = yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]);
2766 + const gitFailure = (cwd: string, detail: string) =>
2767 + new GitCommandError({ operation: "GitVcsDriver.test", command: "git", cwd, detail });
2768 + const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
2769 + Effect.provide(
2770 + service(
2771 + {
2772 + resolvePrimaryRemoteName: (cwd) =>
2773 + remote === null
2774 + ? Effect.fail(gitFailure(cwd, "No git remote is configured."))
2775 + : Effect.succeed(remote),
2776 + resolveDefaultBranchName: () => Effect.succeed(remoteDefault),
2777 + resolveCommit: ({ cwd, revision }) =>
2778 + refs.includes(revision)
2779 + ? Effect.succeed({ commitSha: "abc123" })
2780 + : Effect.fail(gitFailure(cwd, "Needed a single revision")),
2781 + },
2782 + saved,
2783 + ),
2784 + ),
2785 + );
2786 + yield* mcp.scheduleTask(client, { projectId, prompt: "Check the build", schedule });
2787 + assert.deepEqual(yield* Ref.get(saved), [
2788 + { type: "worktree", baseRef, startFromOrigin: true },
2789 + ]);
2790 + }),
2791 + );
2792 + });
2793 it.effect(
2794 "reports the child run's selection after a restart and the thread selection before launch",
2795 () =>
apps/server/src/mcp/OrchestratorMcpService.ts
+48 -10
@@ -252,14 +252,6 @@ function errorMessage(error: unknown): string {
252 return error instanceof Error ? error.message : String(error);
253 }
254
255 -function scheduledTaskWorkspaceStrategy(
256 - boundToThread: boolean,
257 -): ScheduledTask["workspaceStrategy"] {
258 - return boundToThread
259 - ? { type: "root" }
260 - : { type: "worktree", baseRef: "main", startFromOrigin: true };
261 -}
262 -
255 function scheduledTaskSummary(task: ScheduledTask, mayRun: boolean): OrchestratorMcpScheduledTask {
256 return {
257 scheduledTaskId: task.id,
@@ -1821,6 +1813,52 @@ const make = Effect.gen(function* () {
1813 effect.pipe(Effect.timeoutOption(Duration.millis(timeoutMs)), Effect.map(Option.flatten)),
1814 );
1815
1816 + const refExists = (cwd: string, revision: string) =>
1817 + gitDriver.resolveCommit({ cwd, revision }).pipe(
1818 + Effect.as(true),
1819 + Effect.orElseSucceed(() => false),
1820 + );
1821 +
1822 + const resolveScheduledTaskBaseRef = Effect.fn(
1823 + "OrchestratorMcpService.resolveScheduledTaskBaseRef",
1824 + )(function* (cwd: string) {
1825 + const remoteName = yield* gitDriver
1826 + .resolvePrimaryRemoteName(cwd)
1827 + .pipe(Effect.orElseSucceed(() => null));
1828 + const conventional = ["main", "master"];
1829 + if (remoteName !== null) {
1830 + const remoteDefault = yield* gitDriver
1831 + .resolveDefaultBranchName(cwd, remoteName)
1832 + .pipe(Effect.orElseSucceed(() => null));
1833 + // Fetch does not update a recorded HEAD, so it can outlive the branch it names.
1834 + for (const branch of remoteDefault === null
1835 + ? conventional
1836 + : [remoteDefault, ...conventional]) {
1837 + // Launch resolves a bare name through a local branch's upstream, or else assumes `origin`.
1838 + if (yield* refExists(cwd, `refs/remotes/${remoteName}/${branch}`)) {
1839 + return `${remoteName}/${branch}`;
1840 + }
1841 + }
1842 + }
1843 + // Local-only repositories, or a remote with neither a usable HEAD nor a conventional branch.
1844 + for (const branch of conventional) {
1845 + if (yield* refExists(cwd, `refs/heads/${branch}`)) return branch;
1846 + }
1847 + return "main";
1848 + });
1849 +
1850 + const scheduledTaskWorkspaceStrategy = Effect.fn(
1851 + "OrchestratorMcpService.scheduledTaskWorkspaceStrategy",
1852 + )(function* (boundToThread: boolean, projectId: ProjectId) {
1853 + if (boundToThread) return { type: "root" as const };
1854 + const { workspaceRoot } = yield* requireProject(projectId);
1855 + return {
1856 + type: "worktree" as const,
1857 + baseRef: yield* resolveScheduledTaskBaseRef(workspaceRoot),
1858 + startFromOrigin: true,
1859 + };
1860 + });
1861 +
1862 const scheduledTaskRunModes = Effect.fn("OrchestratorMcpService.scheduledTaskRunModes")(
1863 function* (task: ScheduledTask) {
1864 const modes = [{ runtimeMode: task.runtimeMode, interactionMode: task.interactionMode }];
@@ -1932,7 +1970,7 @@ const make = Effect.gen(function* () {
1970 schedule: input.schedule,
1971 projectId,
1972 threadId: bindToCurrentThread && parent !== undefined ? parent.thread.id : null,
1935 - workspaceStrategy: scheduledTaskWorkspaceStrategy(bindToCurrentThread),
1973 + workspaceStrategy: yield* scheduledTaskWorkspaceStrategy(bindToCurrentThread, projectId),
1974 modelSelection,
1975 runtimeMode: limits.runtimeMode,
1976 interactionMode: limits.interactionMode,
@@ -2004,7 +2042,7 @@ const make = Effect.gen(function* () {
2042 const workspaceStrategy =
2043 input.bindToCurrentThread === undefined
2044 ? existing.workspaceStrategy
2007 - : scheduledTaskWorkspaceStrategy(input.bindToCurrentThread);
2045 + : yield* scheduledTaskWorkspaceStrategy(input.bindToCurrentThread, existing.projectId);
2046 const upsertInput: ScheduledTaskUpsertInput = {
2047 id: existing.id,
2048 title: input.title ?? existing.title,