Skip to content

Fork cannot follow upstream #792

Closed
Closed

Description

@github-actions

Fork cannot follow upstream

Plan: The plan did not finish. Run: https://github.com/scuttletoby/t3code/actions/runs/44928132410

The series does not fit the seam list (.github/fork-seams.json):

Fork changes to upstream files must stay within the seam lines in .github/fork-seams.json (list from the head):
- apps/server/src/mcp/OrchestratorMcpService.ts: 5 upstream lines deleted, moved or re-indented, more than its "lost" lines count of 4 (keep upstream's lines; a fork change goes in a file of the fork's own).
- apps/server/src/mcp/OrchestratorMcpService.ts: 5 upstream lines deleted or changed (its text is gone), more than its "lost" gone count of 4 (keep upstream's lines; a fork change goes in a file of the fork's own).
- apps/server/src/mcp/OrchestratorMcpService.ts: "pending" with 35 fork lines, more than its ceiling of 34 (fork lines to move out, not add).
Put the change in a file of the fork's own (a fork setting goes in packages/contracts/src/forkSettings.ts; see docs/fork/updates.md). A new seam line needs its own entry in .github/fork-seams.json, which the owner approves.

The series was left as it is.

What State now
Series branch main at e0e01b97ae8f
Candidate branch fork-follow/candidate at 8b669dfc567d
Backups of earlier series (tags) fork-follow/pre-v0.1.11-nightly.20261118.4890-1974264545d5, fork-follow/pre-v0.1.11-nightly.20261119.4954-f49745fab25a
Release none: the plan did not pick a commit

Activity

  1. github-actions commented on Nov 21, 2026

    @github-actions
    Author

    Fork cannot follow upstream

    Plan: The plan did not finish. Run: https://github.com/scuttletoby/t3code/actions/runs/44929539061

    Rebasing the series from v0.1.11-nightly.20261119.4954 onto v0.1.12-nightly.20261121.5051 stopped at: ce9e2c4 Auto-update (server): background service updates itself when quiet (#5)

    Conflicting files:

    apps/server/src/orchestration-v2/ThreadLaunchService.ts
    

    What git said:

    Auto-merging apps/server/src/orchestration-v2/EffectWorker.ts
    Auto-merging apps/server/src/orchestration-v2/ProviderRuntimeRecoveryService.ts
    Auto-merging apps/server/src/orchestration-v2/ThreadLaunchService.test.ts
    Auto-merging apps/server/src/orchestration-v2/ThreadLaunchService.ts
    CONFLICT (content): Merge conflict in apps/server/src/orchestration-v2/ThreadLaunchService.ts
    Auto-merging apps/server/src/orchestration-v2/runtimeLayer.test.ts
    Auto-merging apps/server/src/server.ts
    Auto-merging apps/server/src/serverRuntimeStartup.ts
    Auto-merging apps/server/src/serverSettings.ts
    Auto-merging packages/contracts/src/settings.ts
    error: could not apply ce9e2c4518... Auto-update (server): background service updates itself when quiet (#5)
    hint: Resolve all conflicts manually, mark them as resolved with
    hint: "git add/rm <conflicted_files>", then run "git rebase --continue".
    hint: You can instead skip this commit: run "git rebase --skip".
    hint: To abort and get back to the state before "git rebase", run "git rebase --abort".
    hint: Disable this message with "git config set advice.mergeConflict false"
    Could not apply ce9e2c4518... # Auto-update (server): background service updates itself when quiet (#5)
    

    The series was left as it is. To follow by hand: git fetch https://github.com/pingdotgg/t3code.git tag v0.1.12-nightly.20261121.5051,
    git rebase --onto v0.1.12-nightly.20261121.5051 v0.1.11-nightly.20261119.4954 <series branch>, resolve, run the tests, then push the branch with
    --force-with-lease, and start the follow workflow once (gh workflow run fork-follow.yml --repo scuttletoby/t3code):
    it releases the series and disables the upstream workflows that push started.

    What State now
    Series branch main at 4549be532b35
    Candidate branch fork-follow/candidate at 8b669dfc567d
    Backups of earlier series (tags) fork-follow/pre-v0.1.11-nightly.20261118.4890-1974264545d5, fork-follow/pre-v0.1.11-nightly.20261119.4954-f49745fab25a
    Release none: the plan did not pick a commit
  2. scuttletoby commented on Nov 21, 2026

    @scuttletoby
    Owner

    Hand rebase onto v0.1.12-nightly.20261121.5051: candidate ready for review

    Candidate: branch fork-follow/candidate at 733d372dfc295f5f850d6c5ecfc5b2c22311749c (409 commits on the tag). main is not moved; nothing released; fork-follow.yml not started.
    Fork CI: https://github.com/scuttletoby/t3code/actions/runs/44936643721 (fork-tests.yml dispatched on the candidate sha, as in #553).
    Seam check: node .github/scripts/fork-seam-check.cjs --from-upstream v0.1.12-nightly.20261121.5051 HEAD passes.

    What upstream changed in the conflict files

    Fixes after the rebase (folded into the commit that owns each)

    Typecheck and tests found four things the merge alone did not show:

    1. Refuse a narrowed MCP profile at turn start on a provider that cannot apply it #679, server.ts (seam change, please review): upstream's 19 steps in layerRuntimeCoreDependenciesBase's pipe plus the fork's two make 21, and Effect's pipe takes at most 20 (TS2554). The fork line now carries upstream's next one, wired exactly as before: Layer.provideMerge(ForkLayers.mcpProfileTurnCheck.pipe(Layer.provideMerge(layerTaskFolders))), // Fork: MCP profiles. In fork-seams.json: the server.ts added text for that line updated, its why explains it, and its lost count goes from 6 to 7 (lines and gone): upstream's Layer.provideMerge(layerTaskFolders), is the one line lost. This raises a count, so it needs your OK. The other route, splitting the pipe with a fork ).pipe( line, makes the formatter re-indent about 35 upstream lines, so I did not take it.
    2. feat(slots): agent slot gate on delegate_task (off by default) #89, slot-gate test: "a call cancelled during the dispatch gives its slot back" now hangs, because upstream finishes a dispatch whose caller went away. The test now checks the combined behaviour: the cancelled call still starts its child, the slot passes to that child until its run shows (start grace), then it is free. Nothing leaks, and nothing is counted twice.
    3. feat(server): Claude threads apply their MCP profile's outside servers #528, MCP profile key: upstream's new key test expects claudeEffectiveQueryPolicyKey to be a pure function (same input, same key). The fork gave overrides with no worked-out plan a new key on every call. They now get one fixed key unplanned, which still never matches a planned turn's key (undefined for all, or mcp NUL ...). In production the adapter always plans before it computes the key, so only tests reach this. The fork's own planKeyFor test was updated to match. Also in feat(server): Claude threads apply their MCP profile's outside servers #528: the fork's fake Claude session gains upstream's three new methods (mcpAuthenticate, mcpSubmitOAuthCallbackUrl, reconnectMcpServer).
    4. fork: serve --hold-work (go-live kit PR 1) #175 and Fork: one first-come line in the slot gate; idle compaction retried while due (#738) #752, tests: upstream's new mcpApps/McpSignIn.ts reads a live session through ProviderSessionManagerV2 and never starts one, so it is added to the known users in workAdmission.startPaths.test.ts. pullRequestWatchSlot.test.ts now provides layerNoTaskFolders and ModelManifest.layerTest, which upstream's runtime layer now needs (as in upstream's own runtimeLayer test).

    Plus one new commit on top: fork seams: exclude upstream's new .repos/effect/.../test/utils/forkRegistration.ts from fork files. Upstream vendors that Effect test helper, and its name matches the fork-file pattern. It adds one ! exclude, changes no count, and is a separate commit because no seam commit owns it (the same as #554 last time).

    Range-diff (v0.1.11-nightly.20261119.4954..4549be53 vs v0.1.12-nightly.20261121.5051..733d372dfc)

    0.1.11 to 0.1.12

    No fork code, test or release script assumes 0.1.11. The only hits are made-up versions in test fixtures (fork-follow.test.sh synthetic tags, fork-release.test.sh, fork-kit go-live and agent tests). Upstream's own package.json files still say 0.1.11 at the v0.1.12 tag.

    Local checks (under the capacity gate, one at a time)

    • Typecheck (vp run -r typecheck): 43/43 ok. Lint: ok (warnings only, in upstream files).
    • Server tests, all passed: ThreadLaunchService, cloud/autoUpdate and autoUpdateSettings, workAdmission (3 files), serverRuntimeStartup (3 files), holdWork.boot, OrchestratorMcpService (main, activity, slotGate, usageGate), fork delegateChecks (2), delegateOwnOptions, claudeMcpProfile (2), mcpProfileTurnCheck, handoffShell, pullRequestWatchSlot, runtimeLayer, slots (3), ClaudeAdapterV2, bootstrap.
    • One test fails here for a reason outside the rebase: upstream's ProjectionStore test "reads a fixed SQL turn-item window ..." calls StatementSync.stat, which this machine's Node 24 lacks. The repo pins Node 26.13.1, which CI uses, so the run above decides it.
    • Fork script tests: fork-seam-check.test.cjs, fork-ci-tests.test.cjs, fork-follow.test.sh (186 ok). The full .github/fork-ci-tests.txt list runs in the CI run above.
    Conflict resolution diff (conflicted merge to final, per file)
    diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts
    index 578aea9814..02be3a8f01 100644
    --- a/apps/server/src/mcp/OrchestratorMcpService.ts
    +++ b/apps/server/src/mcp/OrchestratorMcpService.ts
    @@ -2930,83 +2930,13 @@ const make = Effect.gen(function* () {
             }
             workspaceStrategy = { type: "worktree", baseRef: base.commitSha, startFromOrigin: false };
           }
    -<<<<<<< 4549be53
    +      const parentNodeId = parentRun.rootNodeId;
           // Fork: seat 2 of the checks, last before the dispatch (its hold: fork/delegateChecks.ts).
           const forkHold = yield* delegateChecks.afterWorkspace({
             isRetry: isRetryOfAcceptedDelegation,
             callerThreadId: scope.thread.threadId,
             target: pacedTarget,
           });
    -      // ThreadManagementService.dispatch is the chokepoint for this command
    -      // type's own enablement check, using the same command id and its
    -      // receipt-replay exemption, so no separate assert runs here.
    -      const result = yield* threadManagement
    -        .dispatch({
    -          type: "delegated_task.request",
    -          createdBy: "agent",
    -          creationSource: "mcp",
    -          commandId,
    -          parentThreadId: scope.thread.threadId,
    -          parentRunId: parentRun.id,
    -          parentNodeId: parentRun.rootNodeId,
    -          task: taskPrompt(input),
    -          ...(input.title === undefined ? {} : { title: input.title }),
    -          modelSelection: pacedTarget.modelSelection,
    -          runtimeMode,
    -          interactionMode,
    -          ...(workspaceStrategy === undefined ? {} : { workspaceStrategy }),
    -          // Async delegations wake the parent on every child terminal; wait
    -          // delegations deliver through the blocking tool call until `awaitTask`
    -          // gives up the wait (timeout, cancelled call) and upgrades the wake.
    -          completionWake: input.mode === "wait" ? "settled_only" : "always",
    -        })
    -        .pipe(
    -          Effect.mapError((error) =>
    -            error._tag === "ThreadManagementProviderInstanceDisabledError"
    -              ? threadManagementFailure(error)
    -              : failure(
    -                  "orchestration_error",
    -                  `Unable to create delegated task: ${userFacingDispatchErrorMessage(error) ?? errorMessage(error)}`,
    -                ),
    -          ),
    -        );
    -      const taskEvent = result.storedEvents.find(
    -        (stored) =>
    -          stored.event.type === "subagent.updated" && stored.event.payload.origin === "app_owned",
    -      );
    -      if (taskEvent?.event.type !== "subagent.updated") {
    -        return yield* failure(
    -          "orchestration_error",
    -          "Delegated task command did not produce a task projection.",
    -        );
    -      }
    -      const taskId = taskEvent.event.payload.id;
    -      const childThreadId = taskEvent.event.payload.childThreadId;
    -      if (childThreadId !== null) yield* forkHold.started(childThreadId);
    -      const childRunEvent = result.storedEvents.find(
    -        (stored) => stored.event.type === "run.created" && stored.event.threadId === childThreadId,
    -      );
    -      if (
    -        childThreadId !== null &&
    -        childRunEvent?.event.type === "run.created" &&
    -        childRunEvent.event.payload.workspacePreparation !== undefined
    -      ) {
    -        yield* threadLaunch.prepareRun({
    -          commandId,
    -          threadId: childThreadId,
    -          runId: childRunEvent.event.payload.id,
    -        });
    -      }
    -      // Fork: the dispatch is done; a named child keeps counting until its run shows.
    -      yield* forkHold.release;
    -
    -      const task = yield* input.mode === "wait"
    -        ? awaitTask(scope, taskId, key, input.timeoutMs)
    -        : readTask(scope, taskId, false, true);
    -      return usagePacingNote === undefined ? task : { ...task, usagePacingNote };
    -    }, Effect.scoped),
    -=======
    -      const parentNodeId = parentRun.rootNodeId;
           // The command commits the child's preparing run, which only this call
           // prepares, so a caller that goes away must not stop it in between.
           return yield* Effect.uninterruptibleMask((restore) =>
    @@ -3025,7 +2955,7 @@ const make = Effect.gen(function* () {
                   parentNodeId,
                   task: taskPrompt(input),
                   ...(input.title === undefined ? {} : { title: input.title }),
    -              modelSelection: target.modelSelection,
    +              modelSelection: pacedTarget.modelSelection,
                   runtimeMode,
                   interactionMode,
                   ...(workspaceStrategy === undefined ? {} : { workspaceStrategy }),
    @@ -3057,6 +2987,7 @@ const make = Effect.gen(function* () {
               }
               const taskId = taskEvent.event.payload.id;
               const childThreadId = taskEvent.event.payload.childThreadId;
    +          if (childThreadId !== null) yield* forkHold.started(childThreadId);
               const childRunEvent = result.storedEvents.find(
                 (stored) =>
                   stored.event.type === "run.created" && stored.event.threadId === childThreadId,
    @@ -3072,13 +3003,15 @@ const make = Effect.gen(function* () {
                   runId: childRunEvent.event.payload.id,
                 });
               }
    -          return yield* input.mode === "wait"
    +          // Fork: the dispatch is done; a named child keeps counting until its run shows.
    +          yield* forkHold.release;
    +          const task = yield* input.mode === "wait"
                 ? awaitTask(scope, taskId, key, input.timeoutMs, restore)
                 : restore(readTask(scope, taskId, false, true));
    +          return usagePacingNote === undefined ? task : { ...task, usagePacingNote };
             }),
           );
    -    }),
    ->>>>>>> v0.1.12-nightly.20261121.5051
    +    }, Effect.scoped),
         taskStatus: Effect.fn("OrchestratorMcpService.taskStatus")(function* (callerScope, taskId) {
           const scope = yield* requireThreadScope(callerScope, "task_status");
           return yield* readTask(scope, taskId, false, true);
    diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
    index 88f39238a2..b7137af30d 100644
    --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
    +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
    @@ -13124,18 +13124,14 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
                   ? {}
                   : { allowedTools: queryPolicy.allowedTools }),
               });
    -<<<<<<< 4549be53
               // Fork: a profile that cannot apply refuses here, before the live process is replaced.
               const mcpProfile = yield* mcpProfiles(turnInput.appThread, mcpOverrides);
               const checkMcpProfile = ClaudeMcpProfile.checkClaudeSession(mcpProfile, mcpOverrides);
    -          const queryPolicyKey = claudeEffectiveQueryPolicyKey(queryPolicy, mcpOverrides);
    -=======
               const queryPolicyKey = claudeEffectiveQueryPolicyKey(
                 queryPolicy,
                 mcpOverrides,
                 turnInput.runtimePolicy.workspace,
               );
    ->>>>>>> v0.1.12-nightly.20261121.5051
               const resumeSessionAt = yield* getNativeConversationHeadId(turnInput.providerThread);
               const existing = yield* Ref.get(queryContext);
               // Continuations drain existing output without prompting; retain the live process regardless of selection.
    diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
    index 05cf92cc9c..6480854467 100644
    --- a/apps/server/src/orchestration-v2/ProjectionStore.ts
    +++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
    @@ -103,11 +103,8 @@ import type * as Statement from "effect/sql/Statement";
     
     import { MCP_APP_OUTPUT_KEY } from "@t3tools/shared/mcpApp";
     import { threadHtmlRenderAttachmentIds } from "../attachmentStore.ts";
    -<<<<<<< 4549be53
    -import * as ForkHandoffShell from "../fork/handoff/handoffShell.ts"; // Fork: quiet handoff runs
    -=======
     import { DELEGATED_TASK_MESSAGE_CONDITION } from "./delegatedTaskMessage.ts";
    ->>>>>>> v0.1.12-nightly.20261121.5051
    +import * as ForkHandoffShell from "../fork/handoff/handoffShell.ts"; // Fork: quiet handoff runs
     import {
       DEFERRED_COMMAND_MESSAGE_CONDITION,
       JAVASCRIPT_TRIM_WHITESPACE,
    diff --git a/apps/server/src/orchestration-v2/ThreadLaunchService.ts b/apps/server/src/orchestration-v2/ThreadLaunchService.ts
    index 9445654c00..c94c93d490 100644
    --- a/apps/server/src/orchestration-v2/ThreadLaunchService.ts
    +++ b/apps/server/src/orchestration-v2/ThreadLaunchService.ts
    @@ -65,11 +65,8 @@ import { makeProviderFailure } from "@t3tools/provider-core/server/failure";
     import { randomUuidV4 } from "@t3tools/provider-core/server/randomUuid";
     import { DispatchModeLimit } from "./DispatchModeLimit.ts";
     import * as ThreadManagement from "./ThreadManagementService.ts";
    -<<<<<<< 4549be53
    -import { WorkAdmission } from "../workAdmission.ts";
    -=======
     import * as TaskFolders from "../workspace/TaskFolders.ts";
    ->>>>>>> v0.1.12-nightly.20261121.5051
    +import { WorkAdmission } from "../workAdmission.ts";
     
     // The agent waits for its branch name; a rate-limited provider would hold it for minutes.
     const BRANCH_NAME_TIMEOUT = "20 seconds";
    diff --git a/apps/server/src/orchestration-v2/runtimeLayer.ts b/apps/server/src/orchestration-v2/runtimeLayer.ts
    index 3d9565c151..afd91d09c8 100644
    --- a/apps/server/src/orchestration-v2/runtimeLayer.ts
    +++ b/apps/server/src/orchestration-v2/runtimeLayer.ts
    @@ -63,12 +63,9 @@ import * as ThreadForkService from "./ThreadForkService.ts";
     import * as TurnItemPositionStore from "./TurnItemPositionStore.ts";
     import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
     import * as SecretRequests from "../secrets/SecretRequests.ts";
    -<<<<<<< 4549be53
    -import * as SlotGate from "../slots/SlotGate.ts";
    -=======
     import * as WorkspaceFolders from "../workspace/WorkspaceFolders.ts";
     import * as TaskFolderStore from "../workspace/TaskFolderStore.ts";
    ->>>>>>> v0.1.12-nightly.20261121.5051
    +import * as SlotGate from "../slots/SlotGate.ts";
     
     export const layerEventInfrastructure = Layer.mergeAll(
       OrchestrationEventStore.layer,
    diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
    index 7047b53884..d310a6bded 100644
    --- a/apps/server/src/server.ts
    +++ b/apps/server/src/server.ts
    @@ -764,11 +764,8 @@ const layerRuntimeCoreDependenciesBase = Layer.mergeAll(
     ).pipe(
       Layer.provide(ForkLayers.handoffThreadsSkipIdleCompaction), // Fork: one owner (fork/handoff)
       Layer.provideMerge(layerOrchestrationApplication),
    -<<<<<<< 4549be53
       Layer.provideMerge(ForkLayers.mcpProfileTurnCheck), // Fork: a narrowed MCP profile refuses off Claude
    -=======
       Layer.provideMerge(layerTaskFolders),
    ->>>>>>> v0.1.12-nightly.20261121.5051
       Layer.provideMerge(RuntimeLayer.layerEventInfrastructure),
       Layer.provideMerge(Layer.merge(ProjectStore.layer, ThreadSearch.layer)),
       Layer.provideMerge(SecretCheck.layer),
    Fixes after the rebase (first rebase result ebe4045551 to candidate)
    diff --git a/.github/fork-seams.json b/.github/fork-seams.json
    index 68a3fe814f..73edbaee85 100644
    --- a/.github/fork-seams.json
    +++ b/.github/fork-seams.json
    @@ -31,7 +31,7 @@
           ]
         },
         "apps/server/src/server.ts": {
    -      "why": "The fork's service layers are wired here in one place each, from fork/forkLayers.ts (#384), so this file keeps as few fork lines as it can. The ten lines in \"added\" were its pending lines (ceiling 10) when it moved here (#361). The last line in \"added\" gives the runtime's workers upstream's orchestrator with one change: an idle compaction send to a thread whose handoff mode is \"handoff\" is skipped, so the handoff service alone owns that thread (fork/handoff, #361). The line naming ForkLayers.mcpProfileTurnCheck gives the runtime upstream's provider instance registry with one change: a provider that cannot apply MCP profiles (all but Claude) refuses a turn whose thread's profile is narrower than \"all\", at turn start (fork/mcpProfileTurnCheck.ts, #672).",
    +      "why": "The fork's service layers are wired here in one place each, from fork/forkLayers.ts (#384), so this file keeps as few fork lines as it can. The ten lines in \"added\" were its pending lines (ceiling 10) when it moved here (#361). The last line in \"added\" gives the runtime's workers upstream's orchestrator with one change: an idle compaction send to a thread whose handoff mode is \"handoff\" is skipped, so the handoff service alone owns that thread (fork/handoff, #361). The line naming ForkLayers.mcpProfileTurnCheck gives the runtime upstream's provider instance registry with one change: a provider that cannot apply MCP profiles (all but Claude) refuses a turn whose thread's profile is narrower than \"all\", at turn start (fork/mcpProfileTurnCheck.ts, #672). That line also carries upstream's next one, its task folders (upstream's `Layer.provideMerge(layerTaskFolders)`, the one upstream line it lost), wired exactly as before: Effect's pipe takes at most 20 steps, and upstream's 19 here plus the fork's two would be 21.",
           "added": [
             "import * as ForkLayers from \"./fork/forkLayers.ts\";",
             "// Fork (waits): the `pr` judge reads through the same pull request service and its caches.",
    @@ -43,7 +43,7 @@
             "const layerWorkAdmission = yield* ForkLayers.makeWorkAdmissionLayer(config);",
             "Layer.provide(ForkLayers.holdWorkCloudLink(CloudLink.layer, ConnectReachability.layer)),",
             "Layer.provide(Layer.merge(layerActivation, layerWorkAdmission)),",
    -        "Layer.provideMerge(ForkLayers.mcpProfileTurnCheck), // Fork: a narrowed MCP profile refuses off Claude",
    +        "Layer.provideMerge(ForkLayers.mcpProfileTurnCheck.pipe(Layer.provideMerge(layerTaskFolders))), // Fork: MCP profiles",
             "Layer.provide(ForkLayers.handoffThreadsSkipIdleCompaction), // Fork: one owner (fork/handoff)"
           ]
         },
    @@ -463,8 +463,8 @@
           "gone": 1
         },
         "apps/server/src/server.ts": {
    -      "lines": 6,
    -      "gone": 6
    +      "lines": 7,
    +      "gone": 7
         },
         "apps/server/src/serverRuntimeStartup.ts": {
           "lines": 6,
    diff --git a/apps/server/src/fork/claudeMcpProfile.adapter.test.ts b/apps/server/src/fork/claudeMcpProfile.adapter.test.ts
    index f2999ab234..4fe2bf668c 100644
    --- a/apps/server/src/fork/claudeMcpProfile.adapter.test.ts
    +++ b/apps/server/src/fork/claudeMcpProfile.adapter.test.ts
    @@ -87,6 +87,9 @@ const runTurns = (
                       ? Effect.die("the default profile asked Claude for its MCP servers")
                       : Effect.succeed(statuses),
                   readMcpResource: () => Effect.die("unused"),
    +              mcpAuthenticate: () => Effect.die("unused"),
    +              mcpSubmitOAuthCallbackUrl: () => Effect.die("unused"),
    +              reconnectMcpServer: () => Effect.die("unused"),
                   callMcpTool: () => Effect.die("unused"),
                   listPermissionRules: Effect.die("unused"),
                   stopTask: () => Effect.void,
    diff --git a/apps/server/src/fork/claudeMcpProfile.test.ts b/apps/server/src/fork/claudeMcpProfile.test.ts
    index 09bc89b0e8..4ed7d184e7 100644
    --- a/apps/server/src/fork/claudeMcpProfile.test.ts
    +++ b/apps/server/src/fork/claudeMcpProfile.test.ts
    @@ -142,10 +142,13 @@ describe("claudeMcpCallOutsideProfile", () => {
     });
     
     describe("planKeyFor", () => {
    -  it("gives overrides with no worked-out plan a key no other turn has, never all's", () => {
    +  it("gives overrides with no worked-out plan a key no planned turn has, never all's", () => {
         const first = planKeyFor({});
         assert.isDefined(first);
    -    assert.notStrictEqual(planKeyFor({}), first);
    +    // A planned key is `undefined` (all) or starts "mcp" NUL (planKey).
    +    assert.isFalse(first?.startsWith("mcp\u0000"));
    +    // A pure function of its input (upstream's key test asks for one).
    +    assert.strictEqual(planKeyFor({}), first);
       });
     });
     
    diff --git a/apps/server/src/fork/claudeMcpProfile.ts b/apps/server/src/fork/claudeMcpProfile.ts
    index f7e2e363b6..42df3a618a 100644
    --- a/apps/server/src/fork/claudeMcpProfile.ts
    +++ b/apps/server/src/fork/claudeMcpProfile.ts
    @@ -314,15 +314,14 @@ export const claudeMcpProfileForThread = Effect.fn("ClaudeMcpProfile.forThread")
     });
     
     const PLAN_KEYS = new WeakMap<object, { readonly key: string | undefined }>();
    -let unplanned = 0;
     
     /**
      * The plan's part of the live-query key (`undefined` for `all`), found by the turn's MCP overrides,
    - * the only input of upstream's key line. Overrides with no plan get a key no other turn has, so
    - * such a turn opens a new process instead of reusing one a wider profile started.
    + * the only input of upstream's key line. Overrides with no plan get a key no planned turn has, so
    + * such a turn never reuses a process a profile started (a pure function, as upstream's test asks).
      */
     export const planKeyFor = (mcpOverrides: object): string | undefined =>
    -  (PLAN_KEYS.get(mcpOverrides) ?? { key: `unplanned\u0000${++unplanned}` }).key;
    +  (PLAN_KEYS.get(mcpOverrides) ?? { key: "unplanned" }).key;
     
     /** The plan's key part, or `undefined` for `all`. NUL keeps the joined names apart. */
     const planKey = (plan: ClaudeMcpProfilePlan): string | undefined =>
    diff --git a/apps/server/src/fork/pullRequestWatchSlot.test.ts b/apps/server/src/fork/pullRequestWatchSlot.test.ts
    index 2c70a715cb..69f4a829fe 100644
    --- a/apps/server/src/fork/pullRequestWatchSlot.test.ts
    +++ b/apps/server/src/fork/pullRequestWatchSlot.test.ts
    @@ -48,10 +48,12 @@ import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
     import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
     import * as ProjectStore from "../orchestration-v2/ProjectStore.ts";
     import * as PullRequestWatchReactor from "../orchestration-v2/PullRequestWatchReactor.ts";
    +import { layerNoTaskFolders } from "../orchestration-v2/ProviderTurnStartService.testkit.ts";
     import * as RuntimeLayer from "../orchestration-v2/runtimeLayer.ts";
     import * as ThreadCommandExecutor from "../orchestration-v2/ThreadCommandExecutor.ts";
     import * as SqlitePersistence from "../persistence/Sqlite.ts";
     import * as ProjectService from "../project/ProjectService.ts";
    +import * as ModelManifest from "../provider/ModelManifest.ts";
     import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
     import * as PullRequestService from "../pullRequest/PullRequestService.ts";
     import * as ServerSettings from "../serverSettings.ts";
    @@ -410,6 +412,8 @@ const layerRuntimeTest = Layer.mergeAll(
         }),
       ),
       Layer.provide(Layer.mock(ProjectService.ProjectService)({ getById: () => Effect.succeedNone })),
    +  // Upstream's runtime layer now needs task folders and the model manifest (as in its own test).
    +  Layer.provide(Layer.merge(layerNoTaskFolders, ModelManifest.layerTest)),
       Layer.provide(layerPlatformTest),
     );
     
    diff --git a/apps/server/src/mcp/OrchestratorMcpService.slotGate.test.ts b/apps/server/src/mcp/OrchestratorMcpService.slotGate.test.ts
    index 785d5cda77..64597c8fc0 100644
    --- a/apps/server/src/mcp/OrchestratorMcpService.slotGate.test.ts
    +++ b/apps/server/src/mcp/OrchestratorMcpService.slotGate.test.ts
    @@ -635,19 +635,28 @@ describe("OrchestratorMcpService agent slot gate", () => {
         }),
       );
     
    -  it.effect("stops half-way: a call cancelled during the dispatch gives its slot back", () =>
    -    Effect.gen(function* () {
    -      const world = newWorld();
    -      world.dispatchDelaysMs.push(60_000);
    -      yield* Effect.gen(function* () {
    -        const cancelled = yield* Effect.forkChild(delegate("slot-cancel"));
    -        yield* Deferred.await(world.dispatchBegun);
    -        yield* TestClock.adjust("1 second");
    -        assert.strictEqual(failureOf(yield* delegate("slot-cancel-2")).code, "slots_full");
    -        yield* Fiber.interrupt(cancelled);
    -        assert.strictEqual((yield* delegate("slot-cancel-3"))._tag, "Success");
    -      }).pipe(Effect.provide(serverLayer(world, slots({ maxPerMachine: 1 }), roomy)));
    -    }),
    +  it.effect(
    +    "stops half-way: a call cancelled during the dispatch still starts its child, which keeps the slot",
    +    () =>
    +      Effect.gen(function* () {
    +        const world = newWorld();
    +        world.dispatchDelaysMs.push(60_000);
    +        yield* Effect.gen(function* () {
    +          const cancelled = yield* Effect.forkChild(delegate("slot-cancel"));
    +          yield* Deferred.await(world.dispatchBegun);
    +          yield* TestClock.adjust("1 second");
    +          assert.strictEqual(failureOf(yield* delegate("slot-cancel-2")).code, "slots_full");
    +          // Upstream finishes a dispatch whose caller went away, so the cancel waits for it.
    +          const cancelling = yield* Effect.forkChild(Fiber.interrupt(cancelled));
    +          yield* TestClock.adjust("59 seconds");
    +          yield* Fiber.join(cancelling);
    +          assert.strictEqual(world.dispatched.length, 1);
    +          // Its child holds the one slot until its run shows (start grace), then gives it back.
    +          assert.strictEqual(failureOf(yield* delegate("slot-cancel-3")).code, "slots_full");
    +          yield* TestClock.adjust("30 seconds");
    +          assert.strictEqual((yield* delegate("slot-cancel-4"))._tag, "Success");
    +        }).pipe(Effect.provide(serverLayer(world, slots({ maxPerMachine: 1 }), roomy)));
    +      }),
       );
     
       it.effect("stops half-way: a dispatch without a task event gives its slot back", () =>
    diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
    index d310a6bded..7e17ab68a8 100644
    --- a/apps/server/src/server.ts
    +++ b/apps/server/src/server.ts
    @@ -764,8 +764,7 @@ const layerRuntimeCoreDependenciesBase = Layer.mergeAll(
     ).pipe(
       Layer.provide(ForkLayers.handoffThreadsSkipIdleCompaction), // Fork: one owner (fork/handoff)
       Layer.provideMerge(layerOrchestrationApplication),
    -  Layer.provideMerge(ForkLayers.mcpProfileTurnCheck), // Fork: a narrowed MCP profile refuses off Claude
    -  Layer.provideMerge(layerTaskFolders),
    +  Layer.provideMerge(ForkLayers.mcpProfileTurnCheck.pipe(Layer.provideMerge(layerTaskFolders))), // Fork: MCP profiles
       Layer.provideMerge(RuntimeLayer.layerEventInfrastructure),
       Layer.provideMerge(Layer.merge(ProjectStore.layer, ThreadSearch.layer)),
       Layer.provideMerge(SecretCheck.layer),
    diff --git a/apps/server/src/workAdmission.startPaths.test.ts b/apps/server/src/workAdmission.startPaths.test.ts
    index c41db014b5..2356ca03f4 100644
    --- a/apps/server/src/workAdmission.startPaths.test.ts
    +++ b/apps/server/src/workAdmission.startPaths.test.ts
    @@ -86,6 +86,8 @@ describe("agent turn start paths stay behind the work gate", () => {
           [
             // Reads pending app requests of a live session.
             "mcpApps/McpAppRequests.ts",
    +        // Signs an MCP server in through a live session; never starts one.
    +        "mcpApps/McpSignIn.ts",
             // Opens a session only from an outbox effect (rollback).
             "orchestration-v2/CheckpointRollbackService.ts",
             "orchestration-v2/EffectWorker.ts",

    Note: GitHub shows the escape backslash-u-0000 (a NUL character) in two diff lines above as \^@; the code itself has the normal \u + 0000 escape.

  3. scuttletoby commented on Nov 21, 2026

    @scuttletoby
    Owner

    Review of the rebased series

    Candidate: fork-follow/candidate at 733d372dfc on upstream v0.1.12-nightly.20261121.5051. Old series: v0.1.11-nightly.20261119.4954..4549be532b.
    Verdict: NOT SAFE to move main yet. The rebase itself is clean, but the candidate's own fork CI (run 44936643721) is red: 3 fork tests fail. Old main passed the same suite (Fork tests run 44929515497). All 3 need small fixes, and each one comes from an upstream change in this range that a fork test or fork setting did not follow. The local run in the report did not include these test files.

    What I checked myself

    BLOCKING (candidate CI red)

    1. apps/server/src/policy/ManagedPolicy.test.ts:71 (upstream's new test) fails on handoff.idleTokens (job "Test Server 8").
      • Root cause: upstream's new listManageableSettings (apps/server/src/policy/managedSettings.ts:250) goes down into every settings struct. Then makeManagedSettings refuses any path inside a setting that decodes when set to null (managedSettings.ts:342-354).
      • The fork's handoff (packages/contracts/src/forkSettings.ts:114) reads any bad value, null included, as off. Upstream's check therefore treats it as a setting that can be empty.
      • Scenario: t3 policy settings (apps/server/src/cli/policy.ts:166) lists handoff.idleTokens and the other handoff fields, and a policy file that uses any of them is refused.
      • The other fork settings that read bad values leniently are mcpCarriedProfiles, modelPolicy, playtest and reviewRules. They are very likely hit the same way: the test stops at its first failure, and handoff sorts first.
      • Fix: list those fork keys as manageable only as a whole. That means one seam line in managedSettings.ts that reads a fork-owned set, or a fork-file helper, and not a change to upstream's test.
    2. apps/server/src/fork/remoteReplyRead.test.ts:296 "an older version's reply on its last page is read by the tail probe" (job "Test Server 5").
      • Upstream now sends afterPosition: -1 for the first page (apps/server/src/peer/RemoteDelegation.ts:641). Upstream's own RemoteDelegation.test.ts changed toBeUndefined() to toBe(-1).
      • The fork fixture olderPagedAnswer (remoteReplyRead.test.ts:143) still matches only afterPosition === undefined. It therefore answers {unexpectedPage: -1}, and the task fails.
      • Test-only fix: treat -1 as the first page. The fix(remote-delegation): a reply from a linked environment on another version still completes its task #540 code is unaffected, since it passes the input through unchanged.
    3. fork-kit/model-guard/tests/guard.test.py:1958 test_each_built_in_driver_reads_its_effort_where_the_guard_looks (OpenCodeDriver) (job "Fork kit tests 1").
      • Upstream moved the OpenCode variant read into OpenCodeRuntime.openCodeVariant (packages/provider-opencode/src/server/OpenCodeRuntime.ts:396). Both adapters now call that helper.
      • The effort id is still variant, so DRIVER_EFFORT_IDS stays right.
      • Fix: point the OpenCodeDriver reads at OpenCodeRuntime.ts, and check that both adapters call openCodeVariant(.

    MINOR

    1. New upstream value t3:default (packages/shared/src/model.ts:288), meaning "send no variant", is not known to the fork's model policy or model guard.
      • modelPolicyPickEfforts (packages/contracts/src/modelPolicy.ts:178) would read an OpenCode pick with variant: "t3:default" as the effort t3:default.
      • Under enforce, it refuses that pick unless a row lists t3:default, and Settings may mark it as outside the policy. It fails closed, so it is not a safety problem.
      • Follow-up: read t3:default as no effort. This can come after the rebase.
    2. "Fork checks ran" failed by design (#420 follow-ups: fork_checks_ran reads base config, pull_request_target-only runs, dispatch path, nits #430). The fork-tests run was dispatched on refs/heads/fork-follow/candidate, not on main with ref=, so no fork-ci-result is recorded. After the fixes, re-run it as the error says (from main with ref=fork-follow/candidate).

    The three points asked about

    • server.ts (apps/server/src/server.ts:767), allowance 6 → 7: OK.
      • X.pipe(provideMerge(T), provideMerge(TF)) and X.pipe(provideMerge(T.pipe(provideMerge(TF)))) give the same layer graph. TF is still built first, is provided to T and to everything above, and is not given T's wrapped registry. Layers memoize by reference, so it is built once.
      • The lost 6 → 7 in fork-seams.json is the only widening.
      • I found no cleaner way to stay at 6:
        • The fork's other line (handoffThreadsSkipIdleCompaction) must stay closer than layerOrchestrationApplication, or the workers get upstream's own orchestrator. So the two fork steps cannot be merged into one.
        • Wrapping an upstream line in a fork call loses an upstream line too.
        • A ).pipe( split re-indents upstream lines.
      • Accept it.
    • planKeyFor "unplanned": OK.
      • In production the adapter calls mcpProfiles(...) on the same overrides object right before the key (ClaudeAdapterV2.ts:13128-13134). PLAN_KEYS.set runs only after a plan succeeds, and a refusal ends the turn before the key line. So unplanned is not reachable there.
      • It can never equal a planned key, which is either left out (all) or starts with mcp NUL.
      • The overrides object is new on every turn, so there is no stale WeakMap entry. Keys live only in the in-memory queryContext Ref, so there is no old state with counter keys after a restart.
      • If unplanned were ever reached (tests only), two such turns on the same native thread with equal servers, tools and workspace could reuse one process. Neither turn has a profile, so nothing is widened.
    • Slot-gate test (OrchestratorMcpService.slotGate.test.ts:638): not weakened. It follows a real upstream change.
      • Upstream now runs the dispatch and prepareRun inside Effect.uninterruptibleMask. Interrupting the caller therefore waits for the 60 s fake dispatch, and the old test's Fiber.interrupt + immediate delegate hung.
      • The new test still checks the fork's guarantee for this case: exactly one child is dispatched, the slot stays held while the child may be starting (grace), and it is freed afterwards. No leak, no double count.
      • Small gap (not blocking): no test now interrupts a call during seat 2 (afterWorkspace), before the mask. That is now the only point where a cancel can still release through the scope finalizer. The failed-dispatch and no-task-event tests cover the same finalizer.
  4. scuttletoby commented on Nov 21, 2026

    @scuttletoby
    Owner

    Candidate fix round

    fork-follow/candidate moved from 733d372dfc to 7910eaab87. Each fix is folded into the fork commit that owns the code or test. Nothing else in the series changed.

    1. Blocking: ManagedPolicy.test.ts handoff.idleTokens. Fixed in fork code, folded into a4b3b42476 → e610aa9e8f "MCP profile carry ... (#640) (#648)". That is the first commit where all the affected settings exist.

    • What it does: a policy can now manage the fork's lenient settings only as a whole. New file apps/server/src/policy/forkManagedSettings.ts lists them: handoff, modelPolicy, playtest, reviewRules, mcpCarriedProfiles, mcpProfile, mcpProfiles, mcpSubagentProfile, mcpThreadProfiles. These are exactly the fork settings that read null as off or a default.
    • How: upstream's listManageableSettings gets one seam line. It stops at these settings, so it lists handoff but not handoff.idleTokens. The seam line is recorded in fork-seams.json.
    • What is not affected: agentSlots, placement and waitChecks do not read null. They keep their per-field paths, so the pc-agents kit's agentSlots.maxPerMachine lock still works.
    • Fail-closed (tests in managedSettings.forkKeys.test.ts):
      • When a policy locks handoff or modelPolicy as a whole, a user change to any field is refused as Locked. For handoff that covers mode, source and command, instructions, sizeTokens, idleTokens and threads. For modelPolicy it covers turning it off and changing its rows.
      • A per-field path such as handoff.idleTokens, modelPolicy.mode, playtest.enabled or reviewRules.preset is refused with the plain reason "... is inside a setting that can be empty; manage "handoff" as a whole".
      • A test fails if a new fork setting reads null and is missing from the list.
    • Old policy files: a file with a per-field path for one of these settings is refused, and the server does not start. The error names the file and says to manage the setting as a whole. The lock is never quietly dropped. The same refusal was already in upstream before the rebase, at v0.1.11-nightly.20261119.4954, so no policy file that used to work stops working. Only the list of manageable paths changed.

    2. Blocking: remoteReplyRead.test.ts "tail probe". This was a test-data fix only, folded into c8c0374210 → f004647fa9 (#540). Upstream now asks for the first page with afterPosition: -1, so the fake reader now checks for -1 instead of undefined. The fork code, remoteReplyRead.ts, never reads afterPosition; it passes the input through unchanged. So the fork code needs no change.

    3. Blocking: model-guard guard.test.py OpenCode case. Folded into a091bc54de → 1a20b16d83 (#629, #638). It changes the test, the kit job's sparse-checkout lists and one comment; the guard code is unchanged.

    • The real read site is now upstream's helper openCodeVariant in packages/provider-opencode/src/server/OpenCodeRuntime.ts. The test pins that helper reading "variant".
    • The test also pins both adapters (server/adapter.ts and server/v2/adapter.ts) calling the helper.
    • The old pattern, a direct read in the adapters, is gone from the source. So the guard finds the live read site, not a stale one.

    4. Minor: OpenCode t3:default. Fixed in packages/contracts/src/modelPolicy.ts, folded into 0bf94f9c0e → 5fba2cbc92 (#731, #747).

    • What it does: for the opencode driver, the variant t3:default now reads as "no effort option". Upstream sends no variant for it, which is the same as leaving the option out. So a row without efforts allows it, and a row with efforts still refuses it, because the pick names no effort. It never reads as a higher effort.
    • Tests:
      • contracts modelPolicy.test.ts covers equal verdicts with and without the option, and refusal by a row with efforts.
      • The same test checks that t3:default does not hide another effort option, and that it is still an effort for other drivers or ids.
      • A server test pins the constant to upstream's DEFAULT_VARIANT_CHOICE_ID.
    • Left as is: the Python model guard (fork-kit/model-guard) still treats t3:default as an effort. That is fail-closed, so I did not change it.

    5. Checks. The seam check from upstream (fork-seam-check.cjs --from-upstream v0.1.12-nightly.20261121.5051 HEAD) passes. Local results on Node 26.13.1:

    • vp run typecheck (all workspaces, then apps/server again after a lint fix) and vp lint: pass.
    • Server tests: src/policy/ (ManagedPolicy.test.ts included), remoteReplyRead, modelPolicyCheck and RemoteDelegation: 116 tests, 7 files, pass. contracts modelPolicy.test.ts: 19 tests, pass. guard.test.py: 97 tests, OK.
    • Fork test lists (fork-ci-tests.cjs): the workflows part and the fork-ci/fleet-walls part pass.
    • The fork-kit part passes, except for two failures that come from the local machine, not the change. schedule-kick wants root-owned temp folders, and CI runs it in the "as root" job. desk install.test.py tripped on a __pycache__ folder that the local fleet-walls run left behind. Neither file differs from 733d372dfc, and both pass on CI.

    6. CI on 7910eaab87.

    • Dispatched from main with ref=fork-follow/candidate, as the review asked: run 44942368885 failed. Every test job passed except Fork kit tests 1, which still cannot find OpenCodeRuntime.ts. A dispatch from main uses main's own fork-tests.yml, and main's sparse lists do not have the new path yet. So this job cannot pass from main until main moves. After that, a run on main uses the new lists.
    • To check the candidate's own workflow, I dispatched on the branch: run 44943253222. All 24 test and check jobs passed, including all fork kit shards, Test Server 1-8, Lint, and Build and Typecheck. The only failure is "Fork checks ran" (with fork-ci-result after it), which fails by design for a dispatch on a branch (#420 follow-ups: fork_checks_ran reads base config, pull_request_target-only runs, dispatch path, nits #430).
    • Decision for whoever moves main: after main moves, the first main run should be fully green. Until then, the run from main shows this one known failure.

    range-diff 733d372dfc...7910eaab87: 148 commits are compared. 144 are = and 4 are !, and the 4 changed ones are exactly the commits listed above. The final tree equals the old tip plus the four fixes.

      1:  c8c0374210 !   1:  f004647fa9 fix(remote-delegation): a reply from a linked environment on another version still completes its task (#540)
     60:  a091bc54de !  60:  1a20b16d83 model-guard: pin each built-in driver's effort option id; fail closed for unknown drivers (#629) (#638)
     66:  a4b3b42476 !  66:  e610aa9e8f MCP profile carry: per-machine refuse, Claude-only docs, no-store rule (#640) (#648)
    140:  0bf94f9c0e ! 140:  5fba2cbc92 Model policy: check agents' model picks on the server, mark picks outside it in Settings (#731) (#747)
    
  5. github-actions commented on Nov 21, 2026

    @github-actions
    Author

    Fork cannot follow upstream

    Plan: Release the series on v0.1.12-nightly.20261121.5051 as it is. Run: https://github.com/scuttletoby/t3code/actions/runs/44944687121

    A job failed without writing a reason (results: guard success, plan success, release failure, advance skipped); see the run.

    What State now
    Series branch main not moved: at 4460c8502297
    Candidate branch fork-follow/candidate at 7910eaab87a5
    Backups of earlier series (tags) fork-follow/pre-v0.1.11-nightly.20261118.4890-1974264545d5, fork-follow/pre-v0.1.11-nightly.20261119.4954-f49745fab25a, fork-follow/pre-v0.1.12-nightly.20261121.5051-4549be532b35
    Release none published for 7910eaab87a5
    Upstream workflows disabled .github/workflows/scratch-gate-graphql-92.yml, .github/workflows/tmp-handoff-smoke.yml
  6. github-actions commented on Nov 21, 2026

    @github-actions
    Author

    Fork cannot follow upstream

    Plan: Release the series on v0.1.12-nightly.20261121.5051 as it is. Run: https://github.com/scuttletoby/t3code/actions/runs/44944687121

    This is attempt 2 of the run, but the guard passed in attempt 1: "Re-run failed jobs" and "Re-run job" keep the guard's earlier result without checking again, so the jobs that get FORK_PUSH_TOKEN were skipped. Use "Re-run all jobs", or start a new run (gh workflow run fork-follow.yml --repo scuttletoby/t3code).

    What State now
    Series branch main not moved: at 4460c8502297
    Candidate branch fork-follow/candidate at 7910eaab87a5
    Backups of earlier series (tags) fork-follow/pre-v0.1.11-nightly.20261118.4890-1974264545d5, fork-follow/pre-v0.1.11-nightly.20261119.4954-f49745fab25a, fork-follow/pre-v0.1.12-nightly.20261121.5051-4549be532b35
    Release none published for 7910eaab87a5
    Upstream workflows disabled .github/workflows/scratch-gate-graphql-92.yml, .github/workflows/tmp-handoff-smoke.yml
  7. github-actions commented on Nov 21, 2026

    @github-actions
    Author

    Fork follows upstream

    Plan: Release the series on v0.1.12-nightly.20261121.5051 as it is. Run: https://github.com/scuttletoby/t3code/actions/runs/44946638590

    What State now
    Series branch main not moved: at 58d5012fae6a
    Candidate branch fork-follow/candidate at 7910eaab87a5
    Backups of earlier series (tags) fork-follow/pre-v0.1.11-nightly.20261118.4890-1974264545d5, fork-follow/pre-v0.1.11-nightly.20261119.4954-f49745fab25a, fork-follow/pre-v0.1.12-nightly.20261121.5051-4549be532b35
    Release v0.1.12-nightly.20261121.5051.fork.1 published at d4dccd3fa003
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions