excerpts.json

{
  "architecture-boundary": {
    "id": "architecture-boundary",
    "path": "docs/internals/overview.md",
    "start": 5,
    "end": 28,
    "language": "markdown",
    "label": "The execution boundary",
    "code": "T3 Code is a server runtime that owns agent sessions, workspaces, and version control, plus clients\n(web, desktop, mobile) that talk to it over one authenticated Effect RPC WebSocket. The server is the\nexecution boundary: every provider process, terminal, git operation, and filesystem read happens\nthere, never in the client.\n\n```\n┌────────────────────────────────────────────────┐\n│ Clients: apps/web, apps/desktop, apps/mobile   │\n│ shared runtime: packages/client-runtime        │\n│  connection supervisor, RPC session, Atom state│\n└──────────────────┬─────────────────────────────┘\n                   │ Effect RPC over WebSocket (/ws)\n                   │ contract: packages/contracts\n┌──────────────────▼─────────────────────────────┐\n│ apps/server                                    │\n│  orchestration engine (event-sourced)          │\n│  provider driver registry (5 built-in drivers) │\n│  checkpointing, VCS, terminals, filesystem     │\n└──────────────────┬─────────────────────────────┘\n                   │ per-driver transport\n┌──────────────────▼─────────────────────────────┐\n│ Agent CLIs: Codex, Claude, Cursor, Grok,       │\n│ OpenCode                                       │\n└────────────────────────────────────────────────┘",
    "checksum": "fd6effc6bfb1e04275e59190badc87399e6298b077fe3d05e7eb0f8544afd698"
  },
  "orchestration-rpc-methods": {
    "id": "orchestration-rpc-methods",
    "path": "packages/contracts/src/orchestration.ts",
    "start": 27,
    "end": 36,
    "language": "typescript",
    "label": "Orchestration RPC surface",
    "code": "export const ORCHESTRATION_WS_METHODS = {\n  dispatchCommand: \"orchestration.dispatchCommand\",\n  getWorkflowScript: \"orchestration.getWorkflowScript\",\n  getTurnDiff: \"orchestration.getTurnDiff\",\n  getFullThreadDiff: \"orchestration.getFullThreadDiff\",\n  searchThreads: \"orchestration.searchThreads\",\n  getArchivedShellSnapshot: \"orchestration.getArchivedShellSnapshot\",\n  subscribeShell: \"orchestration.subscribeShell\",\n  subscribeThread: \"orchestration.subscribeThread\",\n} as const;",
    "checksum": "654f6e0acadb65856a7b1267a314ba5d501fdb7bb2b44847ec54d2a77e034e7c"
  },
  "turn-start-command": {
    "id": "turn-start-command",
    "path": "packages/contracts/src/orchestration.ts",
    "start": 847,
    "end": 864,
    "language": "typescript",
    "label": "Client turn-start command",
    "code": "const ClientThreadTurnStartCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.turn.start\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  message: Schema.Struct({\n    messageId: MessageId,\n    role: Schema.Literal(\"user\"),\n    text: Schema.String,\n    attachments: Schema.Array(UploadChatAttachment),\n  }),\n  modelSelection: Schema.optional(ModelSelection),\n  titleSeed: Schema.optional(TrimmedNonEmptyString),\n  runtimeMode: RuntimeMode,\n  interactionMode: ProviderInteractionMode,\n  bootstrap: Schema.optional(ThreadTurnStartBootstrap),\n  sourceProposedPlan: Schema.optional(SourceProposedPlanReference),\n  createdAt: IsoDateTime,\n});",
    "checksum": "2a356b9b8badac1a1eda578900fc6847c5095057aaa4bc34c9ab057b352c64ec"
  },
  "provider-adapter-core": {
    "id": "provider-adapter-core",
    "path": "apps/server/src/provider/Services/ProviderAdapter.ts",
    "start": 47,
    "end": 71,
    "language": "typescript",
    "label": "Provider adapter lifecycle contract",
    "code": "export interface ProviderAdapterShape<TError> {\n  /**\n   * Provider kind implemented by this adapter.\n   */\n  readonly provider: ProviderDriverKind;\n  readonly capabilities: ProviderAdapterCapabilities;\n\n  /**\n   * Start a provider-backed session.\n   */\n  readonly startSession: (\n    input: ProviderSessionStartInput,\n  ) => Effect.Effect<ProviderSession, TError>;\n\n  /**\n   * Send a turn to an active provider session.\n   */\n  readonly sendTurn: (\n    input: ProviderSendTurnInput,\n  ) => Effect.Effect<ProviderTurnStartResult, TError>;\n\n  /**\n   * Interrupt an active turn.\n   */\n  readonly interruptTurn: (threadId: ThreadId, turnId?: TurnId) => Effect.Effect<void, TError>;",
    "checksum": "a75847d120df17015de3fdcd97ab0f5a3b5d3f7c8b19f950e0c0d484441e17cf"
  },
  "provider-adapter-interactions": {
    "id": "provider-adapter-interactions",
    "path": "apps/server/src/provider/Services/ProviderAdapter.ts",
    "start": 73,
    "end": 94,
    "language": "typescript",
    "label": "Provider approval and input contract",
    "code": "  /**\n   * Respond to an interactive approval request.\n   */\n  readonly respondToRequest: (\n    threadId: ThreadId,\n    requestId: ApprovalRequestId,\n    decision: ProviderApprovalDecision,\n  ) => Effect.Effect<void, TError>;\n\n  /**\n   * Respond to a structured user-input request.\n   */\n  readonly respondToUserInput: (\n    threadId: ThreadId,\n    requestId: ApprovalRequestId,\n    answers: ProviderUserInputAnswers,\n  ) => Effect.Effect<void, TError>;\n\n  /**\n   * Stop one provider session.\n   */\n  readonly stopSession: (threadId: ThreadId) => Effect.Effect<void, TError>;",
    "checksum": "67b4610571f49faa99826588c7af37dafaf379bc25f4e9d012a429cc31f5858d"
  },
  "provider-adapter-stream": {
    "id": "provider-adapter-stream",
    "path": "apps/server/src/provider/Services/ProviderAdapter.ts",
    "start": 126,
    "end": 134,
    "language": "typescript",
    "label": "Canonical provider event stream",
    "code": "  /**\n   * Stop all sessions owned by this adapter.\n   */\n  readonly stopAll: () => Effect.Effect<void, TError>;\n\n  /**\n   * Canonical runtime event stream emitted by this adapter.\n   */\n  readonly streamEvents: Stream.Stream<ProviderRuntimeEvent>;",
    "checksum": "4a95ebce476cfbf3fd22ef7f508d1ef5b55ac49db91548ed4b3ab8fdd482d443"
  },
  "orchestration-transaction": {
    "id": "orchestration-transaction",
    "path": "apps/server/src/orchestration/Layers/OrchestrationEngine.ts",
    "start": 197,
    "end": 259,
    "language": "typescript",
    "label": "Atomic command commit",
    "code": "        const committedCommand = yield* sql\n          .withTransaction(\n            Effect.gen(function* () {\n              const committedEvents: OrchestrationEvent[] = [];\n              let nextCommandReadModel = commandReadModel;\n\n              for (const nextEvent of eventBases) {\n                const savedEvent = yield* eventStore.append(nextEvent);\n                nextCommandReadModel = yield* projectEvent(nextCommandReadModel, savedEvent);\n                yield* projectionPipeline.projectEvent(savedEvent);\n                committedEvents.push(savedEvent);\n              }\n\n              const lastSavedEvent = committedEvents.at(-1) ?? null;\n              if (lastSavedEvent === null) {\n                return yield* new OrchestrationCommandInvariantError({\n                  commandType: envelope.command.type,\n                  detail: \"Command produced no events.\",\n                });\n              }\n\n              yield* commandReceiptRepository.upsert({\n                commandId: envelope.command.commandId,\n                aggregateKind: lastSavedEvent.aggregateKind,\n                aggregateId: lastSavedEvent.aggregateId,\n                acceptedAt: lastSavedEvent.occurredAt,\n                resultSequence: lastSavedEvent.sequence,\n                status: \"accepted\",\n                error: null,\n              });\n\n              return {\n                committedEvents,\n                lastSequence: lastSavedEvent.sequence,\n                nextCommandReadModel,\n              } as const;\n            }),\n          )\n          .pipe(\n            Effect.catchTag(\"SqlError\", (sqlError) =>\n              Effect.fail(\n                toPersistenceSqlError(\"OrchestrationEngine.processEnvelope:transaction\")(sqlError),\n              ),\n            ),\n          );\n\n        commandReadModel = committedCommand.nextCommandReadModel;\n        for (const [index, event] of committedCommand.committedEvents.entries()) {\n          yield* PubSub.publish(eventPubSub, event);\n          if (index === 0) {\n            yield* Metric.update(\n              Metric.withAttributes(\n                orchestrationCommandAckDuration,\n                metricAttributes({\n                  ...baseMetricAttributes,\n                  ackEventType: event.type,\n                }),\n              ),\n              Duration.millis(Math.max(0, (yield* Clock.currentTimeMillis) - envelope.startedAtMs)),\n            );\n          }\n        }\n        return { sequence: committedCommand.lastSequence };",
    "checksum": "24e00da0c432e501172e3847817fde311d8656b07e3b8261c657ecf6b4c35d4c"
  },
  "orchestration-dispatch": {
    "id": "orchestration-dispatch",
    "path": "apps/server/src/orchestration/Layers/OrchestrationEngine.ts",
    "start": 331,
    "end": 368,
    "language": "typescript",
    "label": "Serialized command dispatch and event fan-out",
    "code": "  yield* projectionPipeline.bootstrap;\n  commandReadModel = yield* projectionSnapshotQuery.getCommandReadModel();\n\n  const worker = Effect.forever(Queue.take(commandQueue).pipe(Effect.flatMap(processEnvelope)));\n  yield* Effect.forkScoped(worker);\n  yield* Effect.logDebug(\"orchestration engine started\").pipe(\n    Effect.annotateLogs({ sequence: commandReadModel.snapshotSequence }),\n  );\n\n  const readEvents: OrchestrationEngineShape[\"readEvents\"] = (fromSequenceExclusive, limit) =>\n    eventStore.readFromSequence(fromSequenceExclusive, limit);\n\n  const dispatch: OrchestrationEngineShape[\"dispatch\"] = (command, options) =>\n    Effect.gen(function* () {\n      const result = yield* Deferred.make<{ sequence: number }, OrchestrationDispatchError>();\n      yield* Queue.offer(commandQueue, {\n        command,\n        origin: options?.origin,\n        result,\n        startedAtMs: yield* Clock.currentTimeMillis,\n      });\n      return yield* Deferred.await(result);\n    });\n\n  return {\n    readEvents,\n    dispatch,\n    // Each access creates a fresh PubSub subscription so that multiple\n    // consumers (wsServer, ProviderRuntimeIngestion, CheckpointReactor, etc.)\n    // each independently receive all domain events.\n    get streamDomainEvents(): OrchestrationEngineShape[\"streamDomainEvents\"] {\n      return Stream.fromPubSub(eventPubSub);\n    },\n    // The command read model's snapshotSequence tracks the latest committed\n    // event sequence (updated on the worker fiber). A plain property read is a\n    // consistent, committed value — reassignment of `commandReadModel` is\n    // atomic on the single-threaded event loop.\n    latestSequence: Effect.sync(() => commandReadModel.snapshotSequence),",
    "checksum": "85e20350d344ef6e865480addc97f37638fb833acbee999092d2a1b537019bfa"
  },
  "server-runtime-core": {
    "id": "server-runtime-core",
    "path": "apps/server/src/server.ts",
    "start": 353,
    "end": 416,
    "language": "typescript",
    "label": "Authentication, remote endpoint, provider, and server dependency assembly",
    "code": "const AuthLayerLive = EnvironmentAuth.layer.pipe(\n  Layer.provideMerge(PersistenceLayerLive),\n  Layer.provide(ServerSecretStore.layer),\n);\n\nconst CloudManagedEndpointRuntimeLive = Layer.mergeAll(\n  RelayClientLive,\n  CloudManagedEndpointRuntime.layer.pipe(\n    Layer.provide(ServerSecretStore.layer),\n    Layer.provide(RelayClientLive),\n  ),\n);\n\nconst ProviderRuntimeLayerLive = ProviderSessionReaperLive.pipe(\n  Layer.provideMerge(ProviderLayerLive),\n  Layer.provideMerge(OrchestrationLayerLive),\n);\n\nconst RuntimeCoreDependenciesLive = ReactorLayerLive.pipe(\n  // Core Services\n  Layer.provideMerge(ServerSettingsLayerLive),\n  Layer.provideMerge(CheckpointingLayerLive),\n  Layer.provideMerge(SourceControlProviderRegistryLayerLive),\n  Layer.provideMerge(GitLayerLive),\n  Layer.provideMerge(VcsLayerLive),\n  Layer.provideMerge(ProviderRuntimeLayerLive),\n  Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive)),\n  Layer.provideMerge(PersistenceLayerLive),\n  Layer.provideMerge(Keybindings.layer),\n  Layer.provideMerge(ProviderRegistryLive),\n  // The instance registry is the new routing keystone — text generation,\n  // adapter lookup, and runtime ingestion all resolve `ProviderInstanceId`\n  // through this layer. Built-in drivers come from `BUILT_IN_DRIVERS`;\n  // `providerInstances` hydration merges `settings.providers.<kind>`\n  // with explicit `providerInstances` entries on boot.\n  Layer.provideMerge(ProviderInstanceRegistryHydrationLive),\n  // Shared native/canonical NDJSON writers used by both the per-instance\n  // drivers (native stream, written from inside each `<X>Adapter`) and\n  // `ProviderService` (canonical stream, written after event normalization).\n  // Provided once at the runtime level so every consumer sees the same\n  // logger instances.\n  Layer.provideMerge(ProviderEventLoggers.layer),\n  // `OpenCodeDriver.create()` yields `OpenCodeRuntime`; previously the old\n  // `ProviderRegistryLive` pulled `OpenCodeRuntimeLive` in for itself, but\n  // the rewritten registry reads snapshots off the instance registry and\n  // no longer transitively provides it. Exposing it at the runtime level\n  // keeps a single Live for all opencode consumers.\n  Layer.provideMerge(OpenCodeRuntime.OpenCodeRuntimeLive),\n  Layer.provideMerge(WorkspaceLayerLive),\n  Layer.provideMerge(ProjectFaviconResolverLayerLive),\n  Layer.provideMerge(RepositoryIdentityResolver.layer),\n  Layer.provideMerge(ServerEnvironment.layer),\n  Layer.provideMerge(AuthLayerLive),\n  Layer.provideMerge(ServerSecretStore.layer),\n  Layer.provideMerge(\n    Layer.mergeAll(\n      CloudCliTokenManager.layer.pipe(\n        Layer.provide(ServerSecretStore.layer),\n        Layer.provide(ExternalLauncher.layer),\n      ),\n      CloudManagedEndpointRuntimeLive,\n    ),\n  ),\n);",
    "checksum": "11cc88459d4db7e4b29b6b738dcdaba486d8385f6cec6e7dde0d7851c7ada9c5"
  },
  "dispatch-result": {
    "id": "dispatch-result",
    "path": "packages/contracts/src/orchestration.ts",
    "start": 1580,
    "end": 1583,
    "language": "typescript",
    "label": "Successful client dispatch result",
    "code": "export const DispatchResult = Schema.Struct({\n  sequence: NonNegativeInt,\n});\nexport type DispatchResult = typeof DispatchResult.Type;",
    "checksum": "151b83cdd47b9a449a38bb64d9f7b37ccd31ab6f109753cb6535214e12bf98de"
  },
  "rejected-receipt-best-effort": {
    "id": "rejected-receipt-best-effort",
    "path": "apps/server/src/orchestration/Layers/OrchestrationEngine.ts",
    "start": 287,
    "end": 325,
    "language": "typescript",
    "label": "Best-effort invariant-rejection receipt",
    "code": "          if (Exit.isSuccess(exit)) {\n            yield* Deferred.succeed(envelope.result, exit.value);\n            return;\n          }\n\n          const error = Cause.squash(exit.cause) as OrchestrationDispatchError;\n          if (\n            !isOrchestrationCommandPreviouslyRejectedError(error) &&\n            !isOrchestrationCommandIdConflictError(error)\n          ) {\n            yield* reconcileReadModelAfterDispatchFailure.pipe(\n              Effect.catch(() =>\n                Effect.logWarning(\n                  \"failed to reconcile orchestration read model after dispatch failure\",\n                ).pipe(\n                  Effect.annotateLogs({\n                    commandId: envelope.command.commandId,\n                    snapshotSequence: commandReadModel.snapshotSequence,\n                  }),\n                ),\n              ),\n            );\n\n            if (isOrchestrationCommandInvariantError(error)) {\n              yield* commandReceiptRepository\n                .upsert({\n                  commandId: envelope.command.commandId,\n                  aggregateKind: aggregateRef.aggregateKind,\n                  aggregateId: aggregateRef.aggregateId,\n                  acceptedAt: yield* nowIso,\n                  resultSequence: commandReadModel.snapshotSequence,\n                  status: \"rejected\",\n                  error: error.message,\n                })\n                .pipe(Effect.catch(() => Effect.void));\n            }\n          }\n\n          yield* Deferred.fail(envelope.result, error);",
    "checksum": "baa86ecd4a4a583386c539189ea6d26d3b4c6377201a660a9d22b2eb52a7645b"
  },
  "hot-reactor-no-replay": {
    "id": "hot-reactor-no-replay",
    "path": "apps/server/src/orchestration/Layers/ProviderCommandReactor.ts",
    "start": 1405,
    "end": 1409,
    "language": "typescript",
    "label": "Hot post-commit stream has no pending-work replay",
    "code": "    yield* forkParked(Stream.runForEach(orchestrationEngine.streamDomainEvents, processEvent));\n\n    // The domain event stream is hot, so work pending before this reactor\n    // starts cannot be resumed. Correlated completions only clear the request\n    // captured here, leaving any newer request untouched.",
    "checksum": "fe4e62df9690c497361768207b76ed48bb65364abc5ef5b123321deb6c0277ee"
  },
  "cli-entry-command": {
    "id": "cli-entry-command",
    "path": "apps/server/src/bin.ts",
    "start": 23,
    "end": 71,
    "language": "typescript",
    "label": "Root CLI and subcommand dispatch",
    "code": "const connectPublicConfigMissingMessage =\n  \"T3 Connect commands are unavailable: this build is missing T3 Connect public configuration.\";\n\nclass ConnectPublicConfigMissingError extends CliError.UserError {\n  override get message() {\n    return connectPublicConfigMissingMessage;\n  }\n}\n\nconst connectUnavailableCommand = Command.make(\"connect\", {\n  command: Argument.string(\"command\").pipe(Argument.variadic),\n}).pipe(\n  Command.withDescription(\"T3 Connect is unavailable in builds without public configuration.\"),\n  Command.withHidden,\n  Command.withHandler(() =>\n    Effect.fail(\n      new CliError.ShowHelp({\n        commandPath: [\"t3\", \"connect\"],\n        errors: [new ConnectPublicConfigMissingError({ cause: connectPublicConfigMissingMessage })],\n      }),\n    ),\n  ),\n);\n\nexport const makeCli = ({ cloudEnabled = hasCloudPublicConfig } = {}) =>\n  Command.make(\"t3\", { ...sharedServerCommandFlags }).pipe(\n    Command.withDescription(\"Run the T3 Code server.\"),\n    Command.withHandler((flags) => runServerCommand(flags)),\n    Command.withSubcommands([\n      startCommand,\n      serveCommand,\n      pairCommand,\n      authCommand,\n      projectCommand,\n      serviceCommand,\n      servicePreflightCommand,\n      triageCommand,\n      cloudEnabled ? connectCommand : connectUnavailableCommand,\n    ]),\n  );\n\nexport const cli = makeCli();\n\nif (import.meta.main) {\n  Command.run(cli, { version: packageJson.version }).pipe(\n    Effect.scoped,\n    Effect.provide(CliRuntimeLayer),\n    NodeRuntime.runMain,\n  );",
    "checksum": "4cbb1e2584966a2f8399dbdf57f860033d79e1da2aba843e49a008d4a4cdc2ab"
  },
  "cli-config-precedence": {
    "id": "cli-config-precedence",
    "path": "apps/server/src/cli/config.ts",
    "start": 244,
    "end": 280,
    "language": "typescript",
    "label": "Mode, port, and base-directory precedence",
    "code": "    const mode: ServerConfig.RuntimeMode = Option.getOrElse(\n      resolveOptionPrecedence(\n        normalizedFlags.mode,\n        Option.fromUndefinedOr(env.mode),\n        Option.fromUndefinedOr(bootstrap?.mode),\n      ),\n      () => \"web\",\n    );\n\n    const port = yield* Option.match(\n      resolveOptionPrecedence(\n        normalizedFlags.port,\n        Option.fromUndefinedOr(env.port),\n        Option.fromUndefinedOr(bootstrap?.port),\n      ),\n      {\n        onSome: (value) => Effect.succeed(value),\n        onNone: () => {\n          if (mode === \"desktop\") {\n            return Effect.succeed(ServerConfig.DEFAULT_PORT);\n          }\n          return findAvailablePort(ServerConfig.DEFAULT_PORT);\n        },\n      },\n    );\n    const devUrl = Option.getOrElse(\n      resolveOptionPrecedence(normalizedFlags.devUrl, Option.fromUndefinedOr(env.devUrl)),\n      () => undefined,\n    );\n    const explicitBaseDir = resolveOptionPrecedence(\n      normalizedFlags.baseDir,\n      Option.fromUndefinedOr(env.t3Home),\n    ).pipe(Option.filter((value) => value.trim().length > 0));\n    const baseDir = yield* resolveBaseDir(\n      Option.getOrUndefined(\n        resolveOptionPrecedence(explicitBaseDir, Option.fromUndefinedOr(bootstrap?.t3Home)),\n      ),",
    "checksum": "f772af33c3c09ffd6b1641fe1391724758215ae054421feba0e93fc83f736d87"
  },
  "cli-serve-semantics": {
    "id": "cli-serve-semantics",
    "path": "apps/server/src/cli/server.ts",
    "start": 21,
    "end": 35,
    "language": "typescript",
    "label": "Start and headless serve semantics",
    "code": "export const startCommand = Command.make(\"start\", { ...sharedServerCommandFlags }).pipe(\n  Command.withDescription(\"Run the T3 Code server.\"),\n  Command.withHandler((flags) => runServerCommand(flags)),\n);\n\nexport const serveCommand = Command.make(\"serve\", { ...sharedServerCommandFlags }).pipe(\n  Command.withDescription(\n    \"Run the T3 Code server without opening a browser and print headless pairing details.\",\n  ),\n  Command.withHandler((flags) =>\n    runServerCommand(flags, {\n      startupPresentation: \"headless\",\n      forceAutoBootstrapProjectFromCwd: false,\n    }),\n  ),",
    "checksum": "114413115c5143f5873145eb904d38d5ad2b7316516f397de0514fa0b41d8bf8"
  },
  "startup-readiness-order": {
    "id": "startup-readiness-order",
    "path": "apps/server/src/serverRuntimeStartup.ts",
    "start": 514,
    "end": 548,
    "language": "typescript",
    "label": "Prepared, activated, command-ready, and ready order",
    "code": "      yield* Effect.logDebug(\"startup phase: waiting for http listener\");\n      yield* runStartupPhase(\"http.wait\", Deferred.await(httpListening));\n      yield* runStartupPhase(\n        \"auxiliary-roots.parked\",\n        options?.awaitAuxiliaryParked ?? Effect.void,\n      );\n\n      // This is the prepared boundary. Every dependency has been acquired and\n      // every runtime root has confirmed that it is parked before this request.\n      const updateOutcome = yield* launcher.prepareTrial;\n      yield* runStartupPhase(\n        \"welcome.publish\",\n        lifecycleEvents.publish({\n          version: 1,\n          type: \"welcome\",\n          payload: { environment, ...welcomeBase },\n        }),\n      );\n      yield* options?.activate ?? Effect.void;\n\n      yield* Effect.logDebug(\"Accepting commands\");\n      yield* commandGate.signalCommandReady;\n      yield* runStartupPhase(\n        \"ready.publish\",\n        lifecycleEvents.publish({\n          version: 1,\n          type: \"ready\",\n          payload: {\n            at: DateTime.formatIso(yield* DateTime.now),\n            environment,\n            ...(updateOutcome === undefined ? {} : { updateOutcome }),\n          },\n        }),\n      );\n      yield* Effect.logDebug(\"startup phase: complete\");",
    "checksum": "8ed6988b351036573a062e87716f4a1154d4d3e69710d8041f6b849965ced364"
  },
  "command-readiness-middleware": {
    "id": "command-readiness-middleware",
    "path": "apps/server/src/server.ts",
    "start": 431,
    "end": 437,
    "language": "typescript",
    "label": "Global route-execution readiness barrier",
    "code": "const commandReadinessLayer = HttpRouter.middleware(\n  (httpEffect) =>\n    Effect.flatMap(ServerRuntimeStartup.ServerRuntimeStartup, (startup) =>\n      startup.awaitCommandReady.pipe(Effect.orDie, Effect.andThen(httpEffect)),\n    ),\n  { global: true },\n);",
    "checksum": "656843f40a4ec8a4e2b1a5dca6671d9264c33edd92731693262a960972ff770f"
  },
  "rpc-stream-contracts": {
    "id": "rpc-stream-contracts",
    "path": "packages/contracts/src/rpc.ts",
    "start": 933,
    "end": 948,
    "language": "typescript",
    "label": "Typed shell and thread streaming RPC contracts",
    "code": "export const WsOrchestrationSubscribeShellRpc = Rpc.make(ORCHESTRATION_WS_METHODS.subscribeShell, {\n  payload: OrchestrationRpcSchemas.subscribeShell.input,\n  success: OrchestrationRpcSchemas.subscribeShell.output,\n  error: Schema.Union([OrchestrationGetSnapshotError, EnvironmentAuthorizationError]),\n  stream: true,\n});\n\nexport const WsOrchestrationSubscribeThreadRpc = Rpc.make(\n  ORCHESTRATION_WS_METHODS.subscribeThread,\n  {\n    payload: OrchestrationRpcSchemas.subscribeThread.input,\n    success: OrchestrationRpcSchemas.subscribeThread.output,\n    error: Schema.Union([OrchestrationGetSnapshotError, EnvironmentAuthorizationError]),\n    stream: true,\n  },\n);",
    "checksum": "efb34f4d793fed351ef25bd2e61b7c448bea8748c2edede590ba9a0f72336b0b"
  },
  "thread-resume-race": {
    "id": "thread-resume-race",
    "path": "apps/server/src/ws.ts",
    "start": 1394,
    "end": 1521,
    "language": "typescript",
    "label": "Attach-before-read and bounded thread replay",
    "code": "        [ORCHESTRATION_WS_METHODS.subscribeThread]: (input) =>\n          observeRpcStreamEffect(\n            ORCHESTRATION_WS_METHODS.subscribeThread,\n            Effect.gen(function* () {\n              const isThisThreadDetailEvent = (event: OrchestrationEvent) =>\n                event.aggregateKind === \"thread\" &&\n                event.aggregateId === input.threadId &&\n                isThreadDetailEvent(event);\n\n              const liveStream = orchestrationEngine.streamDomainEvents.pipe(\n                Stream.filter(isThisThreadDetailEvent),\n                Stream.map((event) => ({\n                  kind: \"event\" as const,\n                  event: projectActivityEvent(event),\n                })),\n              );\n\n              // Attach live delivery before reading either replay or snapshot state.\n              // Otherwise an event published while the snapshot is loading is lost.\n              const liveBuffer = yield* Queue.unbounded<OrchestrationThreadStreamItem>();\n              yield* Effect.forkScoped(\n                liveStream.pipe(Stream.runForEach((item) => Queue.offer(liveBuffer, item))),\n              );\n              const bufferedLiveStream = Stream.fromQueue(liveBuffer);\n\n              // When the client already loaded the snapshot over HTTP it passes\n              // that snapshot's sequence, and we resume the live subscription by\n              // replaying persisted events after it instead of re-sending the\n              // (potentially multi-KB) snapshot frame over the socket.\n              //\n              // The live PubSub subscription must be attached *before* draining\n              // the catch-up replay, otherwise events published during the replay\n              // window are dropped (they are past the persisted tail the replay\n              // read, but the live stream is not yet subscribed). So fork the\n              // live stream into a buffer bound to this stream's scope, then emit\n              // catch-up followed by the buffered/ongoing live events. Overlapping\n              // events are deduped by sequence on the client.\n              //\n              // The replay is bounded to the projection head captured below. The\n              // catch-up range is normally tiny (a fresh HTTP snapshot sequence),\n              // but a stale cached cursor can sit hundreds of thousands of global\n              // events behind — replaying that decodes every intervening event\n              // (including every other thread's tool payloads) only to discard\n              // almost all of them, which has OOM-killed servers on large\n              // databases. A truncated replay would silently drop this thread's\n              // events, so past the gap cap we reset the client with a fresh\n              // thread snapshot instead, exactly like subscribeShell above.\n              if (input.afterSequence !== undefined) {\n                const afterSequence = input.afterSequence;\n                const headSequence = yield* orchestrationEngine.latestSequence;\n                const replayGap = headSequence - afterSequence;\n                if (replayGap >= 0 && replayGap <= THREAD_RESUME_MAX_GAP) {\n                  const catchUpStream = orchestrationEngine\n                    .readEvents(afterSequence, replayGap)\n                    .pipe(\n                      Stream.filter(isThisThreadDetailEvent),\n                      Stream.map((event) => ({\n                        kind: \"event\" as const,\n                        event: projectActivityEvent(event),\n                      })),\n                      Stream.mapError(\n                        (cause) =>\n                          new OrchestrationGetSnapshotError({\n                            message: `Failed to replay thread ${input.threadId} events`,\n                            cause,\n                          }),\n                      ),\n                    );\n                  const afterCatchUp =\n                    input.requestCompletionMarker === true\n                      ? Stream.concat(\n                          Stream.fromEffect(\n                            Queue.offer(liveBuffer, { kind: \"synchronized\" as const }),\n                          ).pipe(Stream.drain),\n                          bufferedLiveStream,\n                        )\n                      : bufferedLiveStream;\n                  return Stream.concat(catchUpStream, afterCatchUp);\n                }\n                // Gap too large (or cursor ahead of authoritative state): fall\n                // through to the snapshot path so the client converges from a\n                // fresh thread detail instead of an unbounded replay.\n              }\n\n              const snapshot = yield* projectionSnapshotQuery\n                .getThreadDetailSnapshot(\n                  input.threadId,\n                  // Windowing the fallback snapshot is opt-in per subscription:\n                  // clients that don't send turnLimit (including all\n                  // pre-pagination clients) get the full thread, since they\n                  // have no way to load older pages.\n                  input.turnLimit === undefined ? undefined : { turnLimit: input.turnLimit },\n                )\n                .pipe(\n                  Effect.mapError(\n                    (cause) =>\n                      new OrchestrationGetSnapshotError({\n                        message: `Failed to load thread ${input.threadId}`,\n                        cause,\n                      }),\n                  ),\n                );\n\n              if (Option.isNone(snapshot)) {\n                return yield* new OrchestrationGetSnapshotError({\n                  message: `Thread ${input.threadId} was not found`,\n                  cause: input.threadId,\n                });\n              }\n\n              const afterSnapshot =\n                input.requestCompletionMarker === true\n                  ? Stream.concat(\n                      Stream.fromEffect(\n                        Queue.offer(liveBuffer, { kind: \"synchronized\" as const }),\n                      ).pipe(Stream.drain),\n                      bufferedLiveStream,\n                    )\n                  : bufferedLiveStream;\n              return Stream.concat(\n                Stream.make({\n                  kind: \"snapshot\" as const,\n                  snapshot: projectThreadDetailSnapshot(snapshot.value),\n                }),\n                afterSnapshot,\n              );\n            }),\n            { \"rpc.aggregate\": \"orchestration\" },",
    "checksum": "0f57dcc6b6815e4cd36c8eca74f696252ba35e6d8446a41d66f413eb214f54f3"
  },
  "auth-credential-precedence": {
    "id": "auth-credential-precedence",
    "path": "apps/server/src/auth/EnvironmentAuth.ts",
    "start": 592,
    "end": 632,
    "language": "typescript",
    "label": "Cookie, Bearer, and DPoP authentication precedence",
    "code": "  const authenticateRequest = (\n    request: HttpServerRequest.HttpServerRequest,\n  ): Effect.Effect<AuthenticatedSession, ServerAuthCredentialError | ServerAuthInternalError> => {\n    const cookieToken = request.cookies[sessions.cookieName];\n    const bearerToken = parseBearerToken(request);\n    const dpopToken = parseDpopToken(request);\n    const credential = cookieToken ?? bearerToken ?? dpopToken;\n    if (!credential) {\n      return Effect.fail(new ServerAuthMissingCredentialError({}));\n    }\n    return authenticateToken(credential).pipe(\n      Effect.flatMap((session) => {\n        if (session.proofKeyThumbprint) {\n          if (!dpopToken || dpopToken !== credential) {\n            return Effect.fail(\n              new ServerAuthInvalidCredentialError({\n                diagnostic: \"DPoP-bound access token requires DPoP authorization.\",\n              }),\n            );\n          }\n          return verifyRequestDpopProof({\n            request,\n            expectedThumbprint: session.proofKeyThumbprint,\n            expectedAccessToken: dpopToken,\n          }).pipe(\n            Effect.provideService(ServerSecretStore.ServerSecretStore, secretStore),\n            Effect.provideService(Crypto.Crypto, crypto),\n            Effect.as(session),\n          );\n        }\n        if (dpopToken) {\n          return Effect.fail(\n            new ServerAuthInvalidCredentialError({\n              diagnostic: \"DPoP authorization requires a proof-bound access token.\",\n            }),\n          );\n        }\n        return Effect.succeed(session);\n      }),\n    );\n  };",
    "checksum": "d18c91b8d4ceaa79bc875630b87a342328ced1fc8a43556643ea32431af3232d"
  },
  "websocket-ticket-verification": {
    "id": "websocket-ticket-verification",
    "path": "apps/server/src/auth/SessionStore.ts",
    "start": 785,
    "end": 851,
    "language": "typescript",
    "label": "WebSocket ticket verification reloads session state",
    "code": "  const verifyWebSocketToken: SessionStore[\"Service\"][\"verifyWebSocketToken\"] = Effect.fn(\n    \"SessionStore.verifyWebSocketToken\",\n  )(function* (token) {\n    const [encodedPayload, signature] = token.split(\".\");\n    if (!encodedPayload || !signature) {\n      return yield* new MalformedWebSocketTokenError({});\n    }\n\n    const expectedSignature = signPayload(encodedPayload, signingSecret);\n    if (!timingSafeEqualBase64Url(signature, expectedSignature)) {\n      return yield* new InvalidWebSocketTokenSignatureError({});\n    }\n\n    const claims = yield* decodeWebSocketClaims(base64UrlDecodeUtf8(encodedPayload)).pipe(\n      Effect.mapError((cause) => new InvalidWebSocketTokenPayloadError({ cause })),\n    );\n\n    const observedAt = yield* DateTime.now;\n    const expiresAt = DateTime.make(claims.exp);\n    if (Option.isNone(expiresAt)) {\n      return yield* new InvalidSessionExpirationClaimError({\n        sessionId: claims.sid,\n        expirationClaim: claims.exp,\n      });\n    }\n    if (claims.exp <= observedAt.epochMilliseconds) {\n      return yield* new WebSocketTokenExpiredError({\n        sessionId: claims.sid,\n        expiresAt: expiresAt.value,\n        observedAt,\n      });\n    }\n\n    const row = yield* authSessions\n      .getById({ sessionId: claims.sid })\n      .pipe(\n        Effect.mapError(\n          (cause) => new WebSocketTokenVerificationError({ sessionId: claims.sid, cause }),\n        ),\n      );\n    if (Option.isNone(row)) {\n      return yield* new UnknownWebSocketSessionError({ sessionId: claims.sid });\n    }\n    if (row.value.expiresAt.epochMilliseconds <= observedAt.epochMilliseconds) {\n      return yield* new WebSocketSessionExpiredError({\n        sessionId: claims.sid,\n        expiresAt: row.value.expiresAt,\n        observedAt,\n      });\n    }\n    if (row.value.revokedAt !== null) {\n      return yield* new WebSocketSessionRevokedError({\n        sessionId: claims.sid,\n        revokedAt: row.value.revokedAt,\n      });\n    }\n\n    return {\n      sessionId: row.value.sessionId,\n      token,\n      method: row.value.method,\n      client: toClientMetadata(row.value.client),\n      expiresAt: row.value.expiresAt,\n      subject: row.value.subject,\n      scopes: row.value.scopes,\n    } satisfies VerifiedSession;\n  });",
    "checksum": "dcb5b1a1fbdbcb3efae560e941aeed24343450e553fb345e55b71c1707bd0f9f"
  },
  "command-union-boundary": {
    "id": "command-union-boundary",
    "path": "packages/contracts/src/orchestration.ts",
    "start": 913,
    "end": 1057,
    "language": "typescript",
    "label": "Client-dispatchable, normalized, and trusted internal command unions",
    "code": "const DispatchableClientOrchestrationCommand = Schema.Union([\n  ProjectCreateCommand,\n  ProjectMetaUpdateCommand,\n  ProjectDeleteCommand,\n  ThreadCreateCommand,\n  ThreadDeleteCommand,\n  ThreadArchiveCommand,\n  ThreadUnarchiveCommand,\n  ThreadSettleCommand,\n  ThreadUnsettleCommand,\n  ThreadSnoozeCommand,\n  ThreadUnsnoozeCommand,\n  ThreadPinCommand,\n  ThreadUnpinCommand,\n  ThreadPinReorderCommand,\n  ThreadMetaUpdateCommand,\n  ThreadRuntimeModeSetCommand,\n  ThreadInteractionModeSetCommand,\n  ThreadTurnStartCommand,\n  ThreadTurnInterruptCommand,\n  ThreadApprovalRespondCommand,\n  ThreadUserInputRespondCommand,\n  ThreadCheckpointRevertCommand,\n  ThreadSessionStopCommand,\n]);\nexport type DispatchableClientOrchestrationCommand =\n  typeof DispatchableClientOrchestrationCommand.Type;\n\nexport const ClientOrchestrationCommand = Schema.Union([\n  ProjectCreateCommand,\n  ProjectMetaUpdateCommand,\n  ProjectDeleteCommand,\n  ThreadCreateCommand,\n  ThreadDeleteCommand,\n  ThreadArchiveCommand,\n  ThreadUnarchiveCommand,\n  ThreadSettleCommand,\n  ThreadUnsettleCommand,\n  ThreadSnoozeCommand,\n  ThreadUnsnoozeCommand,\n  ThreadPinCommand,\n  ThreadUnpinCommand,\n  ThreadPinReorderCommand,\n  ThreadMetaUpdateCommand,\n  ThreadRuntimeModeSetCommand,\n  ThreadInteractionModeSetCommand,\n  ClientThreadTurnStartCommand,\n  ThreadTurnInterruptCommand,\n  ThreadApprovalRespondCommand,\n  ThreadUserInputRespondCommand,\n  ThreadCheckpointRevertCommand,\n  ThreadSessionStopCommand,\n]);\nexport type ClientOrchestrationCommand = typeof ClientOrchestrationCommand.Type;\n\nconst ThreadSessionSetCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.session.set\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  session: OrchestrationSession,\n  createdAt: IsoDateTime,\n});\n\nconst ThreadMessageAssistantDeltaCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.message.assistant.delta\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  messageId: MessageId,\n  delta: Schema.String,\n  turnId: Schema.optional(TurnId),\n  createdAt: IsoDateTime,\n});\n\nconst ThreadMessageAssistantCompleteCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.message.assistant.complete\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  messageId: MessageId,\n  turnId: Schema.optional(TurnId),\n  createdAt: IsoDateTime,\n});\n\nconst ThreadProposedPlanUpsertCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.proposed-plan.upsert\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  proposedPlan: OrchestrationProposedPlan,\n  createdAt: IsoDateTime,\n});\n\nconst ThreadTurnDiffCompleteCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.turn.diff.complete\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  turnId: TurnId,\n  completedAt: IsoDateTime,\n  checkpointRef: CheckpointRef,\n  status: OrchestrationCheckpointStatus,\n  files: Schema.Array(OrchestrationCheckpointFile),\n  assistantMessageId: Schema.optional(MessageId),\n  checkpointTurnCount: NonNegativeInt,\n  createdAt: IsoDateTime,\n});\n\nconst ThreadActivityAppendCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.activity.append\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  activity: OrchestrationThreadActivity,\n  createdAt: IsoDateTime,\n});\n\nconst ThreadRevertCompleteCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.revert.complete\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  turnCount: NonNegativeInt,\n  createdAt: IsoDateTime,\n});\n\nconst ThreadTitleRegenerationCompleteCommand = Schema.Struct({\n  type: Schema.Literal(\"thread.title.regeneration.complete\"),\n  commandId: CommandId,\n  threadId: ThreadId,\n  requestId: CommandId,\n  title: Schema.optional(TrimmedNonEmptyString),\n});\n\nconst InternalOrchestrationCommand = Schema.Union([\n  ThreadSessionSetCommand,\n  ThreadMessageAssistantDeltaCommand,\n  ThreadMessageAssistantCompleteCommand,\n  ThreadProposedPlanUpsertCommand,\n  ThreadTurnDiffCompleteCommand,\n  ThreadActivityAppendCommand,\n  ThreadRevertCompleteCommand,\n  ThreadTitleRegenerationCompleteCommand,\n]);\nexport type InternalOrchestrationCommand = typeof InternalOrchestrationCommand.Type;\n\nexport const OrchestrationCommand = Schema.Union([\n  DispatchableClientOrchestrationCommand,\n  InternalOrchestrationCommand,\n]);\nexport type OrchestrationCommand = typeof OrchestrationCommand.Type;",
    "checksum": "318896f2aa24bd67ad6b1e40f4fd3b7ac6b7f29240f9290046af5135c8048721"
  },
  "normalizer-staging-boundary": {
    "id": "normalizer-staging-boundary",
    "path": "apps/server/src/orchestration/Normalizer.ts",
    "start": 18,
    "end": 179,
    "language": "typescript",
    "label": "Pre-transaction timestamp, workspace, and attachment staging",
    "code": "export const canonicalizeClientCommandTimestamps = (\n  command: ClientOrchestrationCommand,\n  receivedAt: IsoDateTime,\n): ClientOrchestrationCommand => {\n  const canonicalCommand =\n    \"createdAt\" in command\n      ? {\n          ...command,\n          createdAt: receivedAt,\n        }\n      : command;\n\n  if (canonicalCommand.type !== \"thread.turn.start\" || !canonicalCommand.bootstrap?.createThread) {\n    return canonicalCommand;\n  }\n\n  return {\n    ...canonicalCommand,\n    bootstrap: {\n      ...canonicalCommand.bootstrap,\n      createThread: {\n        ...canonicalCommand.bootstrap.createThread,\n        createdAt: receivedAt,\n      },\n    },\n  };\n};\n\nexport const normalizeDispatchCommand = (command: ClientOrchestrationCommand) =>\n  Effect.gen(function* () {\n    const receivedAt = DateTime.formatIso(yield* DateTime.now);\n    const canonicalCommand = canonicalizeClientCommandTimestamps(command, receivedAt);\n    const fileSystem = yield* FileSystem.FileSystem;\n    const path = yield* Path.Path;\n    const serverConfig = yield* ServerConfig;\n    const workspacePaths = yield* WorkspacePaths.WorkspacePaths;\n\n    const normalizeProjectWorkspaceRoot = (workspaceRoot: string) =>\n      workspacePaths.normalizeWorkspaceRoot(workspaceRoot).pipe(\n        Effect.mapError(\n          (cause) =>\n            new OrchestrationDispatchCommandError({\n              message: cause.message,\n            }),\n        ),\n      );\n\n    const normalizeProjectWorkspaceRootForCreate = (\n      workspaceRoot: string,\n      createIfMissing: boolean | undefined,\n    ) =>\n      workspacePaths\n        .normalizeWorkspaceRoot(workspaceRoot, {\n          createIfMissing: createIfMissing === true,\n        })\n        .pipe(\n          Effect.mapError(\n            (cause) =>\n              new OrchestrationDispatchCommandError({\n                message: cause.message,\n              }),\n          ),\n        );\n\n    if (canonicalCommand.type === \"project.create\") {\n      return {\n        ...canonicalCommand,\n        workspaceRoot: yield* normalizeProjectWorkspaceRootForCreate(\n          canonicalCommand.workspaceRoot,\n          canonicalCommand.createWorkspaceRootIfMissing,\n        ),\n        createWorkspaceRootIfMissing: canonicalCommand.createWorkspaceRootIfMissing === true,\n      } satisfies OrchestrationCommand;\n    }\n\n    if (\n      canonicalCommand.type === \"project.meta.update\" &&\n      canonicalCommand.workspaceRoot !== undefined\n    ) {\n      return {\n        ...canonicalCommand,\n        workspaceRoot: yield* normalizeProjectWorkspaceRoot(canonicalCommand.workspaceRoot),\n      } satisfies OrchestrationCommand;\n    }\n\n    if (canonicalCommand.type !== \"thread.turn.start\") {\n      return canonicalCommand as OrchestrationCommand;\n    }\n\n    const normalizedAttachments = yield* Effect.forEach(\n      canonicalCommand.message.attachments,\n      (attachment) =>\n        Effect.gen(function* () {\n          const parsed = parseBase64DataUrl(attachment.dataUrl);\n          if (!parsed || !parsed.mimeType.startsWith(\"image/\")) {\n            return yield* new OrchestrationDispatchCommandError({\n              message: `Invalid image attachment payload for '${attachment.name}'.`,\n            });\n          }\n\n          const bytes = Buffer.from(parsed.base64, \"base64\");\n          if (bytes.byteLength === 0 || bytes.byteLength > PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) {\n            return yield* new OrchestrationDispatchCommandError({\n              message: `Image attachment '${attachment.name}' is empty or too large.`,\n            });\n          }\n\n          const attachmentId = createAttachmentId(canonicalCommand.threadId);\n          if (!attachmentId) {\n            return yield* new OrchestrationDispatchCommandError({\n              message: \"Failed to create a safe attachment id.\",\n            });\n          }\n\n          const persistedAttachment = {\n            type: \"image\" as const,\n            id: attachmentId,\n            name: attachment.name,\n            mimeType: parsed.mimeType.toLowerCase(),\n            sizeBytes: bytes.byteLength,\n          };\n\n          const attachmentPath = resolveAttachmentPath({\n            attachmentsDir: serverConfig.attachmentsDir,\n            attachment: persistedAttachment,\n          });\n          if (!attachmentPath) {\n            return yield* new OrchestrationDispatchCommandError({\n              message: `Failed to resolve persisted path for '${attachment.name}'.`,\n            });\n          }\n\n          yield* fileSystem.makeDirectory(path.dirname(attachmentPath), { recursive: true }).pipe(\n            Effect.mapError(\n              () =>\n                new OrchestrationDispatchCommandError({\n                  message: `Failed to create attachment directory for '${attachment.name}'.`,\n                }),\n            ),\n          );\n          yield* fileSystem.writeFile(attachmentPath, bytes).pipe(\n            Effect.mapError(\n              () =>\n                new OrchestrationDispatchCommandError({\n                  message: `Failed to persist attachment '${attachment.name}'.`,\n                }),\n            ),\n          );\n\n          return persistedAttachment;\n        }),\n      { concurrency: 1 },\n    );\n\n    return {\n      ...canonicalCommand,\n      message: {\n        ...canonicalCommand.message,\n        attachments: normalizedAttachments,\n      },\n    } satisfies OrchestrationCommand;\n  });",
    "checksum": "a6b4f3d074784de7397eed20ee1bfb7fa2de4eca5f62c5443b1962f1cdb5d6db"
  },
  "turn-atomic-batch": {
    "id": "turn-atomic-batch",
    "path": "apps/server/src/orchestration/decider.ts",
    "start": 926,
    "end": 1036,
    "language": "typescript",
    "label": "Existing-thread turn plans a two-to-four-event batch",
    "code": "    case \"thread.turn.start\": {\n      const targetThread = yield* requireThread({\n        readModel,\n        command,\n        threadId: command.threadId,\n      });\n      const sourceProposedPlan = command.sourceProposedPlan;\n      const sourceThread = sourceProposedPlan\n        ? yield* requireThread({\n            readModel,\n            command,\n            threadId: sourceProposedPlan.threadId,\n          })\n        : null;\n      const sourcePlan =\n        sourceProposedPlan && sourceThread\n          ? sourceThread.proposedPlans.find((entry) => entry.id === sourceProposedPlan.planId)\n          : null;\n      if (sourceProposedPlan && !sourcePlan) {\n        return yield* new OrchestrationCommandInvariantError({\n          commandType: command.type,\n          detail: `Proposed plan '${sourceProposedPlan.planId}' does not exist on thread '${sourceProposedPlan.threadId}'.`,\n        });\n      }\n      if (sourceThread && sourceThread.projectId !== targetThread.projectId) {\n        return yield* new OrchestrationCommandInvariantError({\n          commandType: command.type,\n          detail: `Proposed plan '${sourceProposedPlan?.planId}' belongs to thread '${sourceThread.id}' in a different project.`,\n        });\n      }\n      const userMessageEvent: Omit<OrchestrationEvent, \"sequence\"> = {\n        ...(yield* withEventBase({\n          aggregateKind: \"thread\",\n          aggregateId: command.threadId,\n          occurredAt: command.createdAt,\n          commandId: command.commandId,\n        })),\n        type: \"thread.message-sent\",\n        payload: {\n          threadId: command.threadId,\n          messageId: command.message.messageId,\n          role: \"user\",\n          text: command.message.text,\n          attachments: command.message.attachments,\n          turnId: null,\n          streaming: false,\n          createdAt: command.createdAt,\n          updatedAt: command.createdAt,\n        },\n      };\n      const turnStartRequestedEvent: Omit<OrchestrationEvent, \"sequence\"> = {\n        ...(yield* withEventBase({\n          aggregateKind: \"thread\",\n          aggregateId: command.threadId,\n          occurredAt: command.createdAt,\n          commandId: command.commandId,\n        })),\n        causationEventId: userMessageEvent.eventId,\n        type: \"thread.turn-start-requested\",\n        payload: {\n          threadId: command.threadId,\n          messageId: command.message.messageId,\n          ...(command.modelSelection !== undefined\n            ? { modelSelection: command.modelSelection }\n            : {}),\n          ...(command.titleSeed !== undefined ? { titleSeed: command.titleSeed } : {}),\n          runtimeMode: targetThread.runtimeMode,\n          interactionMode: targetThread.interactionMode,\n          ...(sourceProposedPlan !== undefined ? { sourceProposedPlan } : {}),\n          createdAt: command.createdAt,\n        },\n      };\n      // Real activity resets ANY override: it wakes an explicitly settled\n      // thread, and it clears a keep-active pin back to neutral so the\n      // thread can auto-settle again after this burst of work goes stale.\n      // A snooze clears the same way — sending a message to a snoozed\n      // thread is the user re-engaging, so the return ticket is spent.\n      const lifecycleResetEvents: Array<Omit<OrchestrationEvent, \"sequence\">> = [];\n      if (targetThread.settledOverride !== null) {\n        lifecycleResetEvents.push({\n          ...(yield* withEventBase({\n            aggregateKind: \"thread\",\n            aggregateId: command.threadId,\n            occurredAt: command.createdAt,\n            commandId: command.commandId,\n          })),\n          type: \"thread.unsettled\",\n          payload: {\n            threadId: command.threadId,\n            reason: \"activity\",\n            updatedAt: command.createdAt,\n          },\n        });\n      }\n      if (targetThread.snoozedUntil != null) {\n        lifecycleResetEvents.push({\n          ...(yield* withEventBase({\n            aggregateKind: \"thread\",\n            aggregateId: command.threadId,\n            occurredAt: command.createdAt,\n            commandId: command.commandId,\n          })),\n          type: \"thread.unsnoozed\",\n          payload: {\n            threadId: command.threadId,\n            reason: \"activity\",\n            updatedAt: command.createdAt,\n          },\n        });\n      }\n      return [...lifecycleResetEvents, userMessageEvent, turnStartRequestedEvent];",
    "checksum": "0d0fe115f9ae7b07e903de3cca6dfd815044b54aa8a56b75417acb4a17410c4d"
  },
  "engine-commit-publication": {
    "id": "engine-commit-publication",
    "path": "apps/server/src/orchestration/Layers/OrchestrationEngine.ts",
    "start": 197,
    "end": 259,
    "language": "typescript",
    "label": "SQL commit followed by in-memory fold and hot publication",
    "code": "        const committedCommand = yield* sql\n          .withTransaction(\n            Effect.gen(function* () {\n              const committedEvents: OrchestrationEvent[] = [];\n              let nextCommandReadModel = commandReadModel;\n\n              for (const nextEvent of eventBases) {\n                const savedEvent = yield* eventStore.append(nextEvent);\n                nextCommandReadModel = yield* projectEvent(nextCommandReadModel, savedEvent);\n                yield* projectionPipeline.projectEvent(savedEvent);\n                committedEvents.push(savedEvent);\n              }\n\n              const lastSavedEvent = committedEvents.at(-1) ?? null;\n              if (lastSavedEvent === null) {\n                return yield* new OrchestrationCommandInvariantError({\n                  commandType: envelope.command.type,\n                  detail: \"Command produced no events.\",\n                });\n              }\n\n              yield* commandReceiptRepository.upsert({\n                commandId: envelope.command.commandId,\n                aggregateKind: lastSavedEvent.aggregateKind,\n                aggregateId: lastSavedEvent.aggregateId,\n                acceptedAt: lastSavedEvent.occurredAt,\n                resultSequence: lastSavedEvent.sequence,\n                status: \"accepted\",\n                error: null,\n              });\n\n              return {\n                committedEvents,\n                lastSequence: lastSavedEvent.sequence,\n                nextCommandReadModel,\n              } as const;\n            }),\n          )\n          .pipe(\n            Effect.catchTag(\"SqlError\", (sqlError) =>\n              Effect.fail(\n                toPersistenceSqlError(\"OrchestrationEngine.processEnvelope:transaction\")(sqlError),\n              ),\n            ),\n          );\n\n        commandReadModel = committedCommand.nextCommandReadModel;\n        for (const [index, event] of committedCommand.committedEvents.entries()) {\n          yield* PubSub.publish(eventPubSub, event);\n          if (index === 0) {\n            yield* Metric.update(\n              Metric.withAttributes(\n                orchestrationCommandAckDuration,\n                metricAttributes({\n                  ...baseMetricAttributes,\n                  ackEventType: event.type,\n                }),\n              ),\n              Duration.millis(Math.max(0, (yield* Clock.currentTimeMillis) - envelope.startedAtMs)),\n            );\n          }\n        }\n        return { sequence: committedCommand.lastSequence };",
    "checksum": "24e00da0c432e501172e3847817fde311d8656b07e3b8261c657ecf6b4c35d4c"
  },
  "command-receipt-schema": {
    "id": "command-receipt-schema",
    "path": "apps/server/src/persistence/Services/OrchestrationCommandReceipts.ts",
    "start": 25,
    "end": 33,
    "language": "typescript",
    "label": "Durable command receipt fields",
    "code": "export const OrchestrationCommandReceipt = Schema.Struct({\n  commandId: CommandId,\n  aggregateKind: OrchestrationAggregateKind,\n  aggregateId: Schema.Union([ProjectId, ThreadId]),\n  acceptedAt: IsoDateTime,\n  resultSequence: NonNegativeInt,\n  status: OrchestrationCommandReceiptStatus,\n  error: Schema.NullOr(Schema.String),\n});",
    "checksum": "264f74e9b17b136921f154402d8dc87dd27cb86328043769f9293f1d8a8b451b"
  },
  "projection-transaction-cursor": {
    "id": "projection-transaction-cursor",
    "path": "apps/server/src/orchestration/Layers/ProjectionPipeline.ts",
    "start": 1609,
    "end": 1678,
    "language": "typescript",
    "label": "Ordered projectors, transactional cursor updates, and attachment side effects",
    "code": "    const projectors: ReadonlyArray<ProjectorDefinition> = [\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.projects,\n        apply: applyProjectsProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.threadMessages,\n        apply: applyThreadMessagesProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.threadProposedPlans,\n        apply: applyThreadProposedPlansProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.threadActivities,\n        apply: applyThreadActivitiesProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.threadSessions,\n        apply: applyThreadSessionsProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.threadTurns,\n        apply: applyThreadTurnsProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.checkpoints,\n        apply: applyCheckpointsProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.pendingApprovals,\n        apply: applyPendingApprovalsProjection,\n      },\n      {\n        name: ORCHESTRATION_PROJECTOR_NAMES.threads,\n        apply: applyThreadsProjection,\n      },\n    ];\n\n    const runProjectorForEvent = Effect.fn(\"runProjectorForEvent\")(function* (\n      projector: ProjectorDefinition,\n      event: OrchestrationEvent,\n    ) {\n      const attachmentSideEffects: AttachmentSideEffects = {\n        deletedThreadIds: new Set<string>(),\n        prunedThreadRelativePaths: new Map<string, Set<string>>(),\n      };\n\n      yield* sql.withTransaction(\n        projector.apply(event, attachmentSideEffects).pipe(\n          Effect.flatMap(() =>\n            projectionStateRepository.upsert({\n              projector: projector.name,\n              lastAppliedSequence: event.sequence,\n              updatedAt: event.occurredAt,\n            }),\n          ),\n        ),\n      );\n\n      yield* runAttachmentSideEffects(attachmentSideEffects).pipe(\n        Effect.catch((cause) =>\n          Effect.logWarning(\"failed to apply projected attachment side-effects\", {\n            projector: projector.name,\n            sequence: event.sequence,\n            eventType: event.type,\n            cause,\n          }),\n        ),\n      );",
    "checksum": "ec226c4bd720884378ba5cb08e9527043641bfaac002455052b75f36ee02daa0"
  },
  "snapshot-safe-watermark": {
    "id": "snapshot-safe-watermark",
    "path": "apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts",
    "start": 195,
    "end": 258,
    "language": "typescript",
    "label": "Snapshot watermark is the minimum required projector cursor",
    "code": "const REQUIRED_SNAPSHOT_PROJECTORS = [\n  ORCHESTRATION_PROJECTOR_NAMES.projects,\n  ORCHESTRATION_PROJECTOR_NAMES.threads,\n  ORCHESTRATION_PROJECTOR_NAMES.threadMessages,\n  ORCHESTRATION_PROJECTOR_NAMES.threadProposedPlans,\n  ORCHESTRATION_PROJECTOR_NAMES.threadActivities,\n  ORCHESTRATION_PROJECTOR_NAMES.threadSessions,\n  ORCHESTRATION_PROJECTOR_NAMES.checkpoints,\n] as const;\n\nfunction maxIso(left: string | null, right: string): string {\n  if (left === null) {\n    return right;\n  }\n  return left > right ? left : right;\n}\n\nfunction escapeLikePattern(value: string): string {\n  return value.replaceAll(\"!\", \"!!\").replaceAll(\"%\", \"!%\").replaceAll(\"_\", \"!_\");\n}\n\nfunction foldAsciiCase(value: string): string {\n  return value.replace(/[A-Z]/g, (character) => character.toLowerCase());\n}\n\nfunction buildSearchSnippet(text: string, query: string): string {\n  const normalizedText = text.replace(/\\s+/g, \" \").trim();\n  if (normalizedText.length <= 240) {\n    return normalizedText;\n  }\n\n  const normalizedQuery = foldAsciiCase(query.replace(/\\s+/g, \" \").trim());\n  const matchIndex = foldAsciiCase(normalizedText).indexOf(normalizedQuery);\n  const bodyLength = 236;\n  const idealStart = Math.max(0, matchIndex - 72);\n  const start = Math.min(idealStart, normalizedText.length - bodyLength);\n  const end = Math.min(normalizedText.length, start + bodyLength);\n  return `${start > 0 ? \"…\" : \"\"}${normalizedText.slice(start, end)}${\n    end < normalizedText.length ? \"…\" : \"\"\n  }`;\n}\n\nfunction computeSnapshotSequence(\n  stateRows: ReadonlyArray<Schema.Schema.Type<typeof ProjectionStateDbRowSchema>>,\n): number {\n  if (stateRows.length === 0) {\n    return 0;\n  }\n  const sequenceByProjector = new Map(\n    stateRows.map((row) => [row.projector, row.lastAppliedSequence] as const),\n  );\n\n  let minSequence = Number.POSITIVE_INFINITY;\n  for (const projector of REQUIRED_SNAPSHOT_PROJECTORS) {\n    const sequence = sequenceByProjector.get(projector);\n    if (sequence === undefined) {\n      return 0;\n    }\n    if (sequence < minSequence) {\n      minSequence = sequence;\n    }\n  }\n\n  return Number.isFinite(minSequence) ? minSequence : 0;",
    "checksum": "1e59d916d6fd2d68ce72a50afe86973454487d7b5b81d8215e632767ef82f3a4"
  },
  "provider-reactor-forked-send": {
    "id": "provider-reactor-forked-send",
    "path": "apps/server/src/orchestration/Layers/ProviderCommandReactor.ts",
    "start": 1060,
    "end": 1174,
    "language": "typescript",
    "label": "Volatile turn dedupe and forked provider send",
    "code": "  const processTurnStartRequested = Effect.fn(\"processTurnStartRequested\")(function* (\n    event: Extract<ProviderIntentEvent, { type: \"thread.turn-start-requested\" }>,\n  ) {\n    const key = turnStartKeyForEvent(event);\n    if (yield* hasHandledTurnStartRecently(key)) {\n      return;\n    }\n\n    const thread = yield* resolveThread(event.payload.threadId);\n    if (!thread) {\n      return;\n    }\n\n    const message = thread.messages.find((entry) => entry.id === event.payload.messageId);\n    if (!message || message.role !== \"user\") {\n      yield* appendProviderFailureActivity({\n        threadId: event.payload.threadId,\n        kind: \"provider.turn.start.failed\",\n        summary: \"Provider turn start failed\",\n        detail: `User message '${event.payload.messageId}' was not found for turn start request.`,\n        turnId: null,\n        createdAt: event.payload.createdAt,\n      });\n      return;\n    }\n\n    const isFirstUserMessageTurn =\n      thread.messages.filter((entry) => entry.role === \"user\").length === 1;\n    if (isFirstUserMessageTurn) {\n      const project = yield* resolveProject(thread.projectId);\n      const generationCwd =\n        resolveThreadWorkspaceCwd({\n          thread,\n          projects: project ? [project] : [],\n        }) ?? process.cwd();\n      const generationInput = {\n        messageText: message.text,\n        ...(message.attachments !== undefined ? { attachments: message.attachments } : {}),\n        ...(event.payload.titleSeed !== undefined ? { titleSeed: event.payload.titleSeed } : {}),\n      };\n\n      yield* maybeGenerateAndRenameWorktreeBranchForFirstTurn({\n        threadId: event.payload.threadId,\n        branch: thread.branch,\n        worktreePath: thread.worktreePath,\n        ...generationInput,\n      }).pipe(Effect.forkScoped);\n\n      if (canReplaceThreadTitle(thread.title, event.payload.titleSeed)) {\n        yield* maybeGenerateThreadTitleForFirstTurn({\n          threadId: event.payload.threadId,\n          cwd: generationCwd,\n          ...generationInput,\n        }).pipe(Effect.forkScoped);\n      }\n    }\n\n    const handleTurnStartFailure = (cause: Cause.Cause<unknown>) => {\n      if (Cause.hasInterruptsOnly(cause)) {\n        return Effect.void;\n      }\n      const detail = formatFailureDetail(cause);\n      return setThreadSessionErrorOnTurnStartFailure({\n        threadId: event.payload.threadId,\n        detail,\n        createdAt: event.payload.createdAt,\n      }).pipe(\n        Effect.flatMap(() =>\n          appendProviderFailureActivity({\n            threadId: event.payload.threadId,\n            kind: \"provider.turn.start.failed\",\n            summary: \"Provider turn start failed\",\n            detail,\n            turnId: null,\n            createdAt: event.payload.createdAt,\n          }),\n        ),\n        Effect.asVoid,\n      );\n    };\n\n    const recoverTurnStartFailure = (cause: Cause.Cause<unknown>) =>\n      handleTurnStartFailure(cause).pipe(\n        Effect.catchCause((recoveryCause) =>\n          Effect.logWarning(\"provider command reactor failed to recover turn start failure\", {\n            eventType: event.type,\n            threadId: event.payload.threadId,\n            cause: Cause.pretty(recoveryCause),\n            originalCause: Cause.pretty(cause),\n          }),\n        ),\n      );\n\n    const sendTurnRequest = yield* buildSendTurnRequestForThread({\n      threadId: event.payload.threadId,\n      messageText: message.text,\n      ...(message.attachments !== undefined ? { attachments: message.attachments } : {}),\n      ...(event.payload.modelSelection !== undefined\n        ? { modelSelection: event.payload.modelSelection }\n        : {}),\n      interactionMode: event.payload.interactionMode,\n      createdAt: event.payload.createdAt,\n    }).pipe(\n      Effect.map(Option.some),\n      Effect.catchCause((cause) => handleTurnStartFailure(cause).pipe(Effect.as(Option.none()))),\n    );\n\n    if (Option.isNone(sendTurnRequest)) {\n      return;\n    }\n\n    yield* providerService\n      .sendTurn(sendTurnRequest.value)\n      .pipe(Effect.catchCause(recoverTurnStartFailure), Effect.forkScoped);\n  });",
    "checksum": "e612e2a0295ab2afbf9d9b7a9d4c7da0578c4adf5b052b24892d929ec9995f00"
  },
  "sqlite-runtime-pragmas": {
    "id": "sqlite-runtime-pragmas",
    "path": "apps/server/src/persistence/Layers/Sqlite.ts",
    "start": 24,
    "end": 66,
    "language": "typescript",
    "label": "SQLite runtime selection, pragmas, migrations, and scoped layers",
    "code": "const makeRuntimeSqliteLayer = Effect.fn(\"makeRuntimeSqliteLayer\")(function* (\n  config: RuntimeSqliteLayerConfig,\n) {\n  const runtime = process.versions.bun !== undefined ? \"bun\" : \"node\";\n  const loader = defaultSqliteClientLoaders[runtime];\n  const clientModule = yield* Effect.promise<Loader>(loader);\n  return clientModule.layer(config);\n}, Layer.unwrap);\n\nconst setup = Layer.effectDiscard(\n  Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n    // CLI and server write from separate processes; wait rather than fail with SQLITE_BUSY.\n    yield* sql`PRAGMA busy_timeout = 5000;`;\n    yield* sql`PRAGMA foreign_keys = ON;`;\n    yield* sql`PRAGMA journal_mode = WAL;`;\n    yield* runMigrations();\n  }),\n);\n\nexport const makeSqlitePersistenceLive = Effect.fn(\"makeSqlitePersistenceLive\")(function* (\n  dbPath: string,\n) {\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  yield* fs.makeDirectory(path.dirname(dbPath), { recursive: true });\n\n  return Layer.provideMerge(\n    setup,\n    makeRuntimeSqliteLayer({\n      filename: dbPath,\n      spanAttributes: {\n        \"db.name\": path.basename(dbPath),\n        \"service.name\": \"t3-server\",\n      },\n    }),\n  );\n}, Layer.unwrap);\n\nexport const SqlitePersistenceMemory = Layer.provideMerge(\n  setup,\n  makeRuntimeSqliteLayer({ filename: \":memory:\" }),\n);",
    "checksum": "82fedbba97c179c80bcbcc9e8ae8dc674681b57716267f1b03717e76fcaa5ee3"
  },
  "provider-instance-identity-contract": {
    "id": "provider-instance-identity-contract",
    "path": "packages/contracts/src/providerInstance.ts",
    "start": 4,
    "end": 32,
    "language": "typescript",
    "label": "Driver kind and configured instance identity",
    "code": " * Splits the historical \"provider kind\" concept into two:\n *\n *   - `ProviderDriverKind` is the implementation kind selector (e.g. codex,\n *     claudeAgent, a fork's `ollama`, …). It picks which driver package\n *     handles the protocol, the probe, the adapter, and text generation.\n *\n *   - `ProviderInstanceId` is the routing key (a user-defined slug).\n *     Threads, sessions, runtime events, and persisted bindings reference\n *     instance ids — never driver kinds — so a user can configure multiple\n *     instances of the same driver (e.g. `codex_personal` + `codex_work`),\n *     each with independent driver-specific configuration.\n *\n * Forward/backward compatibility invariant\n * ----------------------------------------\n * `ProviderDriverKind` is intentionally an **open** branded slug, not a closed\n * literal union. The server hosts forks, ships in PRs that add drivers, and\n * users frequently roll between branches and forks. Any of those paths can\n * leave `ServerSettings`, persisted thread state, or session bindings\n * referencing a driver that the currently-running build does not know about.\n *\n * The rule: parsing any of those payloads must always succeed, and the\n * runtime is responsible for marking the unknown driver/instance as\n * \"unavailable\" rather than crashing. Built-in drivers shipped by the core\n * product happens to register in a given build is not part of the contract\n * layer. Driver availability is discovered through the runtime registry.\n *\n * Driver-specific configuration is similarly opaque at the contracts layer:\n * drivers live in (or will be extracted to) their own packages and own their\n * config schemas. The contracts package only knows the envelope.",
    "checksum": "c407854da6ce483f2fa76dd285ed7e16f5708176e172140e34c28cc8248e9176"
  },
  "provider-driver-instance-spi": {
    "id": "provider-driver-instance-spi",
    "path": "apps/server/src/provider/ProviderDriver.ts",
    "start": 55,
    "end": 117,
    "language": "typescript",
    "label": "Scoped provider driver and instance records",
    "code": "/**\n * One materialized provider instance. Held by the registry, looked up by\n * `instanceId`, torn down by closing the scope it was created in.\n *\n * The three \"shape\" fields are captured closures owned by this instance —\n * stopping one instance cannot affect another, and starting a second\n * instance of the same driver does not reach into the first instance's\n * state.\n */\nexport interface ProviderInstance {\n  readonly instanceId: ProviderInstanceId;\n  readonly driverKind: ProviderDriverKind;\n  readonly continuationIdentity: ProviderContinuationIdentity;\n  readonly displayName: string | undefined;\n  readonly accentColor?: string | undefined;\n  readonly enabled: boolean;\n  readonly snapshot: ServerProviderShape;\n  readonly adapter: ProviderAdapterShape<ProviderAdapterError>;\n  readonly textGeneration: TextGeneration.TextGeneration[\"Service\"];\n}\n\nexport interface ProviderContinuationIdentity {\n  readonly driverKind: ProviderDriverKind;\n  readonly continuationKey: string;\n}\n\nexport function defaultProviderContinuationIdentity(input: {\n  readonly driverKind: ProviderDriverKind;\n  readonly instanceId: ProviderInstanceId;\n}): ProviderContinuationIdentity {\n  return {\n    driverKind: input.driverKind,\n    continuationKey: `${input.driverKind}:instance:${input.instanceId}`,\n  };\n}\n\n/**\n * Inputs the registry passes to a driver's `create` function.\n *\n * `config` is the typed payload — already decoded by the registry through\n * `driver.configSchema`. Drivers never decode their own raw envelope.\n */\nexport interface ProviderDriverCreateInput<Config> {\n  readonly instanceId: ProviderInstanceId;\n  readonly displayName: string | undefined;\n  readonly accentColor?: string | undefined;\n  readonly environment: ProviderInstanceEnvironment;\n  readonly enabled: boolean;\n  readonly config: Config;\n}\n\n/**\n * Driver SPI — registered as a plain value, not a Layer.\n *\n * `Config` is whatever the driver decoded from\n * `ProviderInstanceConfig.config`. `R` is the union of infrastructure\n * services the driver depends on; the registry layer aggregates `R` across\n * all registered drivers and the runtime supplies them.\n *\n * `create` is responsible for *all* per-instance state — process handles,\n * pubsub topics, refs, file watchers — and must release them when its\n * scope closes. Two calls to `create` with different `instanceId` /\n * `config` MUST yield instances with no shared mutable state.",
    "checksum": "d6fe18a1ab845da33fc05cb2ef822ef1057706345468a8b485daa76abaa9fce6"
  },
  "provider-driver-instance-records": {
    "id": "provider-driver-instance-records",
    "path": "apps/server/src/provider/ProviderDriver.ts",
    "start": 4,
    "end": 20,
    "language": "typescript",
    "label": "Plain provider driver and instance record contracts",
    "code": " * `ProviderDriver` is a record, not a Context.Service. The thing it produces\n * (`ProviderInstance`) is also a record — three captured closures\n * (`snapshot`, `adapter`, `textGeneration`), an id, and a driver kind. There\n * are intentionally no per-driver Context tags because tags are\n * singleton-per-runtime and we need many instances of the same driver.\n *\n * The only Effect service involved is `ProviderInstanceRegistry`, which\n * owns the live `Map<InstanceId, ProviderInstance>` and is itself a\n * singleton.\n *\n * Driver factories are functions of `(typed config, env)` where:\n *   - `typed config` is decoded once by the registry via `configSchema`,\n *     so drivers never deal with raw `unknown`.\n *   - `env` flows through Effect's R channel. Each driver declares the\n *     subset of infrastructure services it needs (FileSystem,\n *     ChildProcessSpawner, …) on its `create` return type; the registry\n *     layer's R is the union of those, and the runtime layer satisfies it.",
    "checksum": "930d8e1e57ebe1e79b5e332f52c8b90908310361e4c752ca17ed828f405b7d22"
  },
  "codex-app-server-client-typed-stdio": {
    "id": "codex-app-server-client-typed-stdio",
    "path": "packages/effect-codex-app-server/src/client.ts",
    "start": 140,
    "end": 211,
    "language": "typescript",
    "label": "Typed Codex notifications, requests, and transport calls",
    "code": "  const dispatchNotification = (\n    notification: CodexProtocol.CodexAppServerIncomingNotification,\n  ): Effect.Effect<void, never> => {\n    const schema =\n      notification.method in CodexRpc.SERVER_NOTIFICATION_PARAMS\n        ? CodexRpc.SERVER_NOTIFICATION_PARAMS[\n            notification.method as CodexRpc.ServerNotificationMethod\n          ]\n        : undefined;\n    const handlers = notificationHandlers.get(notification.method) ?? [];\n\n    if (schema) {\n      return decodeNotificationPayload(notification.method, schema, notification.params).pipe(\n        Effect.flatMap((decoded) =>\n          Effect.forEach(handlers, (handler) => handler(decoded), { discard: true }),\n        ),\n        Effect.catch(() => Effect.void),\n      );\n    }\n\n    return unknownNotificationHandler\n      ? unknownNotificationHandler(notification.method, notification.params).pipe(\n          Effect.catch(() => Effect.void),\n        )\n      : Effect.void;\n  };\n\n  const dispatchRequest = (\n    request: CodexProtocol.CodexAppServerIncomingRequest,\n  ): Effect.Effect<unknown, CodexError.CodexAppServerError> => {\n    if (request.method in CodexRpc.SERVER_REQUEST_PARAMS) {\n      const method = request.method as CodexRpc.ServerRequestMethod;\n      const payloadSchema = getServerRequestParamSchema(method);\n      const responseSchema = getServerRequestResponseSchema(method);\n      const handler = requestHandlers.get(method);\n\n      return decodeOptionalPayload(method, payloadSchema, request.params).pipe(\n        Effect.flatMap((decoded) => runHandler(handler, decoded, method)),\n        Effect.flatMap((result) => encodeOptionalPayload(method, responseSchema, result)),\n      );\n    }\n\n    return unknownRequestHandler\n      ? unknownRequestHandler(request.method, request.params)\n      : Effect.fail(CodexError.CodexAppServerRequestError.methodNotFound(request.method));\n  };\n\n  const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({\n    stdio,\n    ...(terminationError ? { terminationError } : {}),\n    ...(options.logIncoming !== undefined ? { logIncoming: options.logIncoming } : {}),\n    ...(options.logOutgoing !== undefined ? { logOutgoing: options.logOutgoing } : {}),\n    ...(options.logger ? { logger: options.logger } : {}),\n    onNotification: dispatchNotification,\n    onRequest: dispatchRequest,\n  });\n\n  const request = <M extends CodexRpc.ClientRequestMethod>(\n    method: M,\n    payload: CodexRpc.ClientRequestParamsByMethod[M],\n  ): Effect.Effect<CodexRpc.ClientRequestResponsesByMethod[M], CodexError.CodexAppServerError> =>\n    encodeOptionalPayload(method, getClientRequestParamSchema(method), payload).pipe(\n      Effect.flatMap((encoded) => transport.request(method, encoded)),\n      Effect.flatMap(\n        (\n          raw,\n        ): Effect.Effect<\n          CodexRpc.ClientRequestResponsesByMethod[M],\n          CodexError.CodexAppServerError\n        > => decodeOptionalPayload(method, getClientRequestResponseSchema(method), raw),\n      ),\n    );",
    "checksum": "296b35c49fcafff9f8d6d65ab7403039c19f08f7c8e6f0a9350e22dfc01a1cf1"
  },
  "codex-adapter-session-runtime": {
    "id": "codex-adapter-session-runtime",
    "path": "apps/server/src/provider/Layers/CodexAdapter.ts",
    "start": 1642,
    "end": 1693,
    "language": "typescript",
    "label": "Codex session replacement and runtime configuration",
    "code": "  const startSession: CodexAdapterShape[\"startSession\"] = (input) =>\n    Effect.scoped(\n      Effect.gen(function* () {\n        if (input.provider !== undefined && input.provider !== PROVIDER) {\n          return yield* new ProviderAdapterValidationError({\n            provider: PROVIDER,\n            operation: \"startSession\",\n            issue: `Expected provider '${PROVIDER}' but received '${input.provider}'.`,\n          });\n        }\n\n        const existing = sessions.get(input.threadId);\n        if (existing && !existing.stopped) {\n          yield* Effect.suspend(() => stopSessionInternal(existing));\n        }\n\n        const serviceTier =\n          input.modelSelection?.instanceId === boundInstanceId\n            ? getCodexServiceTierOptionValue(input.modelSelection)\n            : undefined;\n        const mcpSession = McpProviderSession.readMcpProviderSession(input.threadId);\n        const runtimeInput: CodexSessionRuntimeOptions = {\n          threadId: input.threadId,\n          providerInstanceId: boundInstanceId,\n          cwd: input.cwd ?? process.cwd(),\n          binaryPath: codexConfig.binaryPath,\n          launchArgs: resolveCodexLaunchArgs(codexConfig.launchArgs, options?.environment),\n          ...(options?.environment ? { environment: options.environment } : {}),\n          ...(codexConfig.homePath ? { homePath: codexConfig.homePath } : {}),\n          ...(isCodexResumeCursorSchema(input.resumeCursor)\n            ? { resumeCursor: input.resumeCursor }\n            : {}),\n          runtimeMode: input.runtimeMode,\n          ...(input.modelSelection?.instanceId === boundInstanceId\n            ? { model: input.modelSelection.model }\n            : {}),\n          ...(serviceTier ? { serviceTier } : {}),\n          ...(mcpSession\n            ? {\n                environment: {\n                  ...(options?.environment ?? process.env),\n                  T3_MCP_BEARER_TOKEN: mcpSession.authorizationHeader.replace(/^Bearer\\s+/, \"\"),\n                },\n                appServerArgs: [\n                  \"-c\",\n                  `mcp_servers.t3-code.url=${mcpSession.endpoint}`,\n                  \"-c\",\n                  'mcp_servers.t3-code.bearer_token_env_var=\"T3_MCP_BEARER_TOKEN\"',\n                ],\n              }\n            : {}),\n        };",
    "checksum": "6dd08ac4e760401826162f8d3a0d739b58ed890361c817cb7b726329818dee33"
  },
  "codex-adapter-runtime-events": {
    "id": "codex-adapter-runtime-events",
    "path": "apps/server/src/provider/Layers/CodexAdapter.ts",
    "start": 1000,
    "end": 1084,
    "language": "typescript",
    "label": "Codex usage, turn, and plan event normalization",
    "code": "  if (event.method === \"thread/tokenUsage/updated\") {\n    const payload = readPayload(\n      EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification,\n      event.payload,\n    );\n    const normalizedUsage = payload ? normalizeCodexTokenUsage(payload.tokenUsage) : undefined;\n    if (!normalizedUsage) {\n      return [];\n    }\n    return [\n      {\n        type: \"thread.token-usage.updated\",\n        ...runtimeEventBase(event, canonicalThreadId),\n        payload: {\n          usage: normalizedUsage,\n        },\n      },\n    ];\n  }\n\n  if (event.method === \"turn/started\") {\n    const turnId = event.turnId;\n    if (!turnId) {\n      return [];\n    }\n    return [\n      {\n        ...runtimeEventBase(event, canonicalThreadId),\n        turnId,\n        type: \"turn.started\",\n        payload: {},\n      },\n    ];\n  }\n\n  if (event.method === \"turn/completed\") {\n    const payload = readPayload(EffectCodexSchema.V2TurnCompletedNotification, event.payload);\n    if (!payload) {\n      return [];\n    }\n    const errorMessage = trimText(payload.turn.error?.message);\n    return [\n      {\n        ...runtimeEventBase(event, canonicalThreadId),\n        type: \"turn.completed\",\n        payload: {\n          state: toTurnStatus(payload.turn.status),\n          ...(errorMessage ? { errorMessage } : {}),\n        },\n      },\n    ];\n  }\n\n  if (event.method === \"turn/aborted\") {\n    return [\n      {\n        ...runtimeEventBase(event, canonicalThreadId),\n        type: \"turn.aborted\",\n        payload: {\n          reason: event.message ?? \"Turn aborted\",\n        },\n      },\n    ];\n  }\n\n  if (event.method === \"turn/plan/updated\") {\n    const payload = readPayload(EffectCodexSchema.V2TurnPlanUpdatedNotification, event.payload);\n    if (!payload) {\n      return [];\n    }\n    return [\n      {\n        ...runtimeEventBase(event, canonicalThreadId),\n        type: \"turn.plan.updated\",\n        payload: {\n          ...(trimText(payload.explanation) ? { explanation: trimText(payload.explanation) } : {}),\n          plan: payload.plan.map((step) => ({\n            step: trimText(step.step) ?? \"step\",\n            status:\n              step.status === \"completed\" || step.status === \"inProgress\" ? step.status : \"pending\",\n          })),\n        },\n      },\n    ];\n  }",
    "checksum": "4b82fdd81df8d8a061c9f7f0b036c32d5f5bf061f9511189548f386a038f4d9f"
  },
  "claude-adapter-query-config": {
    "id": "claude-adapter-query-config",
    "path": "apps/server/src/provider/Layers/ClaudeAdapter.ts",
    "start": 4138,
    "end": 4196,
    "language": "typescript",
    "label": "Claude permission mapping and query option assembly",
    "code": "      const runtimeModeToPermission: Record<string, PermissionMode> = {\n        \"auto-accept-edits\": \"acceptEdits\",\n        auto: \"auto\",\n        \"full-access\": \"bypassPermissions\",\n      };\n      const permissionMode = runtimeModeToPermission[input.runtimeMode];\n      const settings = {\n        ...(typeof thinking === \"boolean\" ? { alwaysThinkingEnabled: thinking } : {}),\n        ...(fastMode ? { fastMode: true } : {}),\n        ...(ultracode ? { ultracode: true } : {}),\n      };\n      const mcpSession = McpProviderSession.readMcpProviderSession(input.threadId);\n      // The attachments dir grant lets the agent Read/copy pasted images at\n      // the paths ProviderService injects into the turn text, without an\n      // approval prompt. It is a leaf directory holding only attachment\n      // files; siblings like secrets/ and state.sqlite stay ungranted.\n      const additionalDirectories = [\n        ...(input.cwd ? [input.cwd] : []),\n        serverConfig.attachmentsDir,\n      ];\n      const queryOptions: ClaudeQueryOptions = {\n        ...(input.cwd ? { cwd: input.cwd } : {}),\n        ...(apiModelId ? { model: apiModelId } : {}),\n        pathToClaudeCodeExecutable: claudeBinaryPath,\n        systemPrompt: { type: \"preset\", preset: \"claude_code\" },\n        settingSources: [...CLAUDE_SETTING_SOURCES],\n        // `ultracode` is a Claude Code setting, not an API effort level. It is\n        // normalized to `xhigh` above and paired with `settings.ultracode`.\n        ...(effectiveEffort\n          ? {\n              effort: effectiveEffort as unknown as NonNullable<ClaudeQueryOptions[\"effort\"]>,\n            }\n          : {}),\n        ...(permissionMode ? { permissionMode } : {}),\n        ...(permissionMode === \"bypassPermissions\"\n          ? { allowDangerouslySkipPermissions: true }\n          : {}),\n        ...(Object.keys(settings).length > 0 ? { settings } : {}),\n        ...(existingResumeSessionId ? { resume: existingResumeSessionId } : {}),\n        ...(newSessionId ? { sessionId: newSessionId } : {}),\n        includePartialMessages: true,\n        canUseTool,\n        env: claudeEnvironment,\n        additionalDirectories,\n        ...(Object.keys(extraArgs).length > 0 ? { extraArgs } : {}),\n        ...(mcpSession\n          ? {\n              mcpServers: {\n                \"t3-code\": {\n                  type: \"http\",\n                  url: mcpSession.endpoint,\n                  headers: {\n                    Authorization: mcpSession.authorizationHeader,\n                  },\n                },\n              },\n            }\n          : {}),\n      };",
    "checksum": "0b8c0d482fc624fb131e748d735394497afa9d437867ad9c1bee9f2f2119de08"
  },
  "claude-query-invocation": {
    "id": "claude-query-invocation",
    "path": "apps/server/src/provider/Layers/ClaudeAdapter.ts",
    "start": 4223,
    "end": 4235,
    "language": "typescript",
    "label": "Claude SDK query invocation",
    "code": "      const queryRuntime = yield* Effect.try({\n        try: () =>\n          createQuery({\n            prompt,\n            options: queryOptions,\n          }),\n        catch: (cause) =>\n          new ProviderAdapterProcessError({\n            provider: PROVIDER,\n            threadId,\n            detail: \"Failed to start Claude runtime session.\",\n            cause,\n          }),",
    "checksum": "293fa0c20180cf51eb8c621ce2d48809cb91db55d182270896f857d245b8a7a1"
  },
  "claude-adapter-interaction-handlers": {
    "id": "claude-adapter-interaction-handlers",
    "path": "apps/server/src/provider/Layers/ClaudeAdapter.ts",
    "start": 4497,
    "end": 4529,
    "language": "typescript",
    "label": "Claude approval and structured-input deferreds",
    "code": "  const respondToRequest: ClaudeAdapterShape[\"respondToRequest\"] = Effect.fn(\"respondToRequest\")(\n    function* (threadId, requestId, decision) {\n      const context = yield* requireSession(threadId);\n      const pending = context.pendingApprovals.get(requestId);\n      if (!pending) {\n        return yield* new ProviderAdapterRequestError({\n          provider: PROVIDER,\n          method: \"item/requestApproval/decision\",\n          detail: `Unknown pending approval request: ${requestId}`,\n        });\n      }\n\n      context.pendingApprovals.delete(requestId);\n      yield* Deferred.succeed(pending.decision, decision);\n    },\n  );\n\n  const respondToUserInput: ClaudeAdapterShape[\"respondToUserInput\"] = Effect.fn(\n    \"respondToUserInput\",\n  )(function* (threadId, requestId, answers) {\n    const context = yield* requireSession(threadId);\n    const pending = context.pendingUserInputs.get(requestId);\n    if (!pending) {\n      return yield* new ProviderAdapterRequestError({\n        provider: PROVIDER,\n        method: \"item/tool/respondToUserInput\",\n        detail: `Unknown pending user-input request: ${requestId}`,\n      });\n    }\n\n    context.pendingUserInputs.delete(requestId);\n    yield* Deferred.succeed(pending.answers, answers);\n  });",
    "checksum": "e41de225714771b18fce1f2bcaff53bc79bfff542df321078c5ab4d1ff8086d2"
  },
  "acp-client-typed-surface": {
    "id": "acp-client-typed-surface",
    "path": "packages/effect-acp/src/client.ts",
    "start": 40,
    "end": 134,
    "language": "typescript",
    "label": "Typed ACP session command surface",
    "code": "  {\n    readonly raw: AcpClientRaw;\n    readonly agent: {\n      /**\n       * Initializes the ACP session and negotiates capabilities.\n       * @see https://agentclientprotocol.com/protocol/schema#initialize\n       */\n      readonly initialize: (\n        payload: AcpSchema.InitializeRequest,\n      ) => Effect.Effect<AcpSchema.InitializeResponse, AcpError.AcpError>;\n      /**\n       * Performs ACP authentication when the agent requires it.\n       * @see https://agentclientprotocol.com/protocol/schema#authenticate\n       */\n      readonly authenticate: (\n        payload: AcpSchema.AuthenticateRequest,\n      ) => Effect.Effect<AcpSchema.AuthenticateResponse, AcpError.AcpError>;\n      /**\n       * Logs out the current ACP identity.\n       * @see https://agentclientprotocol.com/protocol/schema#logout\n       */\n      readonly logout: (\n        payload: AcpSchema.LogoutRequest,\n      ) => Effect.Effect<AcpSchema.LogoutResponse, AcpError.AcpError>;\n      /**\n       * Starts a new ACP session.\n       * @see https://agentclientprotocol.com/protocol/schema#session/new\n       */\n      readonly createSession: (\n        payload: AcpSchema.NewSessionRequest,\n      ) => Effect.Effect<AcpSchema.NewSessionResponse, AcpError.AcpError>;\n      /**\n       * Loads a previously saved ACP session.\n       * @see https://agentclientprotocol.com/protocol/schema#session/load\n       */\n      readonly loadSession: (\n        payload: AcpSchema.LoadSessionRequest,\n      ) => Effect.Effect<AcpSchema.LoadSessionResponse, AcpError.AcpError>;\n      /**\n       * Lists available ACP sessions.\n       * @see https://agentclientprotocol.com/protocol/schema#session/list\n       */\n      readonly listSessions: (\n        payload: AcpSchema.ListSessionsRequest,\n      ) => Effect.Effect<AcpSchema.ListSessionsResponse, AcpError.AcpError>;\n      /**\n       * Forks an ACP session.\n       * @see https://agentclientprotocol.com/protocol/schema#session/fork\n       */\n      readonly forkSession: (\n        payload: AcpSchema.ForkSessionRequest,\n      ) => Effect.Effect<AcpSchema.ForkSessionResponse, AcpError.AcpError>;\n      /**\n       * Resumes an ACP session.\n       * @see https://agentclientprotocol.com/protocol/schema#session/resume\n       */\n      readonly resumeSession: (\n        payload: AcpSchema.ResumeSessionRequest,\n      ) => Effect.Effect<AcpSchema.ResumeSessionResponse, AcpError.AcpError>;\n      /**\n       * Closes an ACP session.\n       * @see https://agentclientprotocol.com/protocol/schema#session/close\n       */\n      readonly closeSession: (\n        payload: AcpSchema.CloseSessionRequest,\n      ) => Effect.Effect<AcpSchema.CloseSessionResponse, AcpError.AcpError>;\n      /**\n       * Selects the active model for a session.\n       * @see https://agentclientprotocol.com/protocol/schema#session/set_model\n       */\n      readonly setSessionModel: (\n        payload: AcpSchema.SetSessionModelRequest,\n      ) => Effect.Effect<AcpSchema.SetSessionModelResponse, AcpError.AcpError>;\n      /**\n       * Updates a session configuration option.\n       * @see https://agentclientprotocol.com/protocol/schema#session/set_config_option\n       */\n      readonly setSessionConfigOption: (\n        payload: AcpSchema.SetSessionConfigOptionRequest,\n      ) => Effect.Effect<AcpSchema.SetSessionConfigOptionResponse, AcpError.AcpError>;\n      /**\n       * Sends a prompt turn to the agent.\n       * @see https://agentclientprotocol.com/protocol/schema#session/prompt\n       */\n      readonly prompt: (\n        payload: AcpSchema.PromptRequest,\n      ) => Effect.Effect<AcpSchema.PromptResponse, AcpError.AcpError>;\n      /**\n       * Sends a real ACP `session/cancel` notification.\n       * @see https://agentclientprotocol.com/protocol/schema#session/cancel\n       */\n      readonly cancel: (\n        payload: AcpSchema.CancelNotification,\n      ) => Effect.Effect<void, AcpError.AcpError>;\n    };",
    "checksum": "7df29bfbf9bbea09d570a845e6123253b3cee19ee9af1f4837fbf6d050040856"
  },
  "cursor-session-mode-selection": {
    "id": "cursor-session-mode-selection",
    "path": "apps/server/src/provider/Layers/CursorAdapter.ts",
    "start": 217,
    "end": 294,
    "language": "typescript",
    "label": "Cursor negotiated mode and model selection",
    "code": "function resolveRequestedModeId(input: {\n  readonly interactionMode: ProviderInteractionMode | undefined;\n  readonly runtimeMode: RuntimeMode;\n  readonly modeState: AcpSessionModeState | undefined;\n}): string | undefined {\n  const modeState = input.modeState;\n  if (!modeState) {\n    return undefined;\n  }\n\n  if (input.interactionMode === \"plan\") {\n    return findModeByAliases(modeState.availableModes, ACP_PLAN_MODE_ALIASES)?.id;\n  }\n\n  if (input.runtimeMode === \"approval-required\") {\n    return (\n      findModeByAliases(modeState.availableModes, ACP_APPROVAL_MODE_ALIASES)?.id ??\n      findModeByAliases(modeState.availableModes, ACP_IMPLEMENT_MODE_ALIASES)?.id ??\n      modeState.availableModes.find((mode) => !isPlanMode(mode))?.id ??\n      modeState.currentModeId\n    );\n  }\n\n  return (\n    findModeByAliases(modeState.availableModes, ACP_IMPLEMENT_MODE_ALIASES)?.id ??\n    findModeByAliases(modeState.availableModes, ACP_APPROVAL_MODE_ALIASES)?.id ??\n    modeState.availableModes.find((mode) => !isPlanMode(mode))?.id ??\n    modeState.currentModeId\n  );\n}\n\nfunction applyRequestedSessionConfiguration<E>(input: {\n  readonly runtime: AcpSessionRuntime.AcpSessionRuntime[\"Service\"];\n  readonly runtimeMode: RuntimeMode;\n  readonly interactionMode: ProviderInteractionMode | undefined;\n  readonly modelSelection:\n    | {\n        readonly model: string;\n        readonly options?: ReadonlyArray<ProviderOptionSelection> | null | undefined;\n      }\n    | undefined;\n  readonly mapError: (context: {\n    readonly cause: import(\"effect-acp/errors\").AcpError;\n    readonly method: \"session/set_config_option\" | \"session/set_mode\";\n  }) => E;\n}): Effect.Effect<void, E> {\n  return Effect.gen(function* () {\n    if (input.modelSelection) {\n      yield* applyCursorAcpModelSelection({\n        runtime: input.runtime,\n        model: input.modelSelection.model,\n        selections: input.modelSelection.options,\n        mapError: ({ cause }) =>\n          input.mapError({\n            cause,\n            method: \"session/set_config_option\",\n          }),\n      });\n    }\n\n    const requestedModeId = resolveRequestedModeId({\n      interactionMode: input.interactionMode,\n      runtimeMode: input.runtimeMode,\n      modeState: yield* input.runtime.getModeState,\n    });\n    if (!requestedModeId) {\n      return;\n    }\n\n    yield* input.runtime.setMode(requestedModeId).pipe(\n      Effect.mapError((cause) =>\n        input.mapError({\n          cause,\n          method: \"session/set_mode\",\n        }),\n      ),\n    );\n  });",
    "checksum": "496d6f291b2b479eb2836b32aeafe501dcc9f66a5d207cb94adf592c9f4a6a78"
  },
  "grok-acp-runtime-support": {
    "id": "grok-acp-runtime-support",
    "path": "apps/server/src/provider/acp/GrokAcpSupport.ts",
    "start": 31,
    "end": 108,
    "language": "typescript",
    "label": "Grok ACP launch, authentication, and model selection",
    "code": "\nexport function buildGrokAcpSpawnInput(\n  grokSettings: GrokAcpRuntimeGrokSettings | null | undefined,\n  cwd: string,\n  environment?: NodeJS.ProcessEnv,\n): AcpSessionRuntime.AcpSpawnInput {\n  return {\n    command: grokSettings?.binaryPath || \"grok\",\n    args: [\"agent\", \"stdio\"],\n    cwd,\n    env: {\n      ...environment,\n      [GROK_OAUTH2_REFERRER_ENV]: T3_CODE_OAUTH_REFERRER,\n    },\n  };\n}\n\nfunction resolveGrokAuthMethodId(environment: NodeJS.ProcessEnv | undefined): string {\n  return environment?.[GROK_API_KEY_ENV]?.trim()\n    ? GROK_AUTH_METHOD_API_KEY\n    : GROK_AUTH_METHOD_CACHED_TOKEN;\n}\n\nexport const makeGrokAcpRuntime = (\n  input: GrokAcpRuntimeInput,\n): Effect.Effect<\n  AcpSessionRuntime.AcpSessionRuntime[\"Service\"],\n  EffectAcpErrors.AcpError,\n  Crypto.Crypto | Scope.Scope\n> =>\n  Effect.gen(function* () {\n    const acpContext = yield* Layer.build(\n      AcpSessionRuntime.layer({\n        ...input,\n        spawn: buildGrokAcpSpawnInput(input.grokSettings, input.cwd, input.environment),\n        authMethodId: resolveGrokAuthMethodId(input.environment),\n      }).pipe(\n        Layer.provide(\n          Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, input.childProcessSpawner),\n        ),\n      ),\n    );\n    const runtime = yield* Effect.service(AcpSessionRuntime.AcpSessionRuntime).pipe(\n      Effect.provide(acpContext),\n    );\n    return yield* makeXAiPromptCompletionRuntime(runtime);\n  });\n\nexport function resolveGrokAcpBaseModelId(model: string | null | undefined): string {\n  const trimmed = model?.trim();\n  const base = trimmed && trimmed.length > 0 ? trimmed : \"grok-build\";\n  return normalizeModelSlug(base, GROK_DRIVER_KIND) ?? \"grok-build\";\n}\n\nexport function currentGrokModelIdFromSessionSetup(\n  sessionSetupResult:\n    | EffectAcpSchema.LoadSessionResponse\n    | EffectAcpSchema.NewSessionResponse\n    | EffectAcpSchema.ResumeSessionResponse,\n): string | undefined {\n  return sessionSetupResult.models?.currentModelId?.trim() || undefined;\n}\n\nexport function applyGrokAcpModelSelection<E>(input: {\n  readonly runtime: Pick<AcpSessionRuntime.AcpSessionRuntime[\"Service\"], \"setSessionModel\">;\n  readonly currentModelId: string | undefined;\n  readonly requestedModelId: string | undefined;\n  readonly mapError: (cause: EffectAcpErrors.AcpError) => E;\n}): Effect.Effect<string | undefined, E> {\n  const shouldSwitchModel =\n    input.requestedModelId !== undefined && input.requestedModelId !== input.currentModelId;\n  if (!shouldSwitchModel) {\n    return Effect.succeed(input.currentModelId);\n  }\n  return input.runtime\n    .setSessionModel(input.requestedModelId)\n    .pipe(Effect.mapError(input.mapError), Effect.as(input.requestedModelId));\n}",
    "checksum": "d76d1518eb9e2c11e37e359f1d1324099034f92d77f9e6f5af7a3d167bcd168a"
  },
  "opencode-runtime-ownership": {
    "id": "opencode-runtime-ownership",
    "path": "apps/server/src/provider/opencodeRuntime.ts",
    "start": 140,
    "end": 177,
    "language": "typescript",
    "label": "Local and external OpenCode server ownership",
    "code": "export interface OpenCodeRuntimeShape {\n  /**\n   * Spawns a local OpenCode server process. Its lifetime is bound to the caller's\n   * `Scope.Scope` — the child is killed automatically when that scope closes.\n   * Consumers that want a long-lived server must create and hold a scope explicitly\n   * (see {@link Scope.make}) and close it when done.\n   */\n  readonly startOpenCodeServerProcess: (input: {\n    readonly binaryPath: string;\n    readonly environment?: NodeJS.ProcessEnv;\n    readonly port?: number;\n    readonly hostname?: string;\n    readonly timeoutMs?: number;\n  }) => Effect.Effect<OpenCodeServerProcess, OpenCodeRuntimeError, Scope.Scope>;\n  /**\n   * Returns a handle to either an externally-managed OpenCode server (when\n   * `serverUrl` is provided — no lifetime is attached to the caller's scope) or a\n   * freshly spawned local server whose lifetime is bound to the caller's scope.\n   */\n  readonly connectToOpenCodeServer: (input: {\n    readonly binaryPath: string;\n    readonly serverUrl?: string | null;\n    readonly environment?: NodeJS.ProcessEnv;\n    readonly port?: number;\n    readonly hostname?: string;\n    readonly timeoutMs?: number;\n  }) => Effect.Effect<OpenCodeServerConnection, OpenCodeRuntimeError, Scope.Scope>;\n  readonly runOpenCodeCommand: (input: {\n    readonly binaryPath: string;\n    readonly args: ReadonlyArray<string>;\n    readonly environment?: NodeJS.ProcessEnv;\n    readonly cwd?: string;\n  }) => Effect.Effect<OpenCodeCommandResult, OpenCodeRuntimeError>;\n  readonly createOpenCodeSdkClient: (input: {\n    readonly baseUrl: string;\n    readonly directory: string;\n    readonly serverPassword?: string;\n  }) => OpencodeClient;",
    "checksum": "846dada188ac95cfa4616580a5fa9aacefea446eb2542ea69ed44236f20b6dea"
  },
  "opencode-turn-and-revert": {
    "id": "opencode-turn-and-revert",
    "path": "apps/server/src/provider/Layers/OpenCodeAdapter.ts",
    "start": 1430,
    "end": 1509,
    "language": "typescript",
    "label": "OpenCode prompt and steering path",
    "code": "    const sendTurn: OpenCodeAdapterShape[\"sendTurn\"] = Effect.fn(\"sendTurn\")(function* (input) {\n      const context = yield* ensureSessionContext(sessions, input.threadId);\n      // A sendTurn while a turn is active is a steer: OpenCode queues the\n      // prompt into the busy session and the work continues as one turn, so\n      // the active turn id is reused instead of opening a new turn.\n      const steeringTurnId = context.activeTurnId;\n      const turnId = steeringTurnId ?? TurnId.make(`opencode-turn-${yield* randomUUIDv4}`);\n      const modelSelection =\n        input.modelSelection ??\n        (context.session.model\n          ? { instanceId: boundInstanceId, model: context.session.model }\n          : undefined);\n      if (modelSelection !== undefined && modelSelection.instanceId !== boundInstanceId) {\n        return yield* new ProviderAdapterValidationError({\n          provider: PROVIDER,\n          operation: \"sendTurn\",\n          issue: `OpenCode model selection is bound to instance '${modelSelection?.instanceId}', expected '${boundInstanceId}'.`,\n        });\n      }\n      const parsedModel = parseOpenCodeModelSlug(modelSelection?.model);\n      if (!parsedModel) {\n        return yield* new ProviderAdapterValidationError({\n          provider: PROVIDER,\n          operation: \"sendTurn\",\n          issue: \"OpenCode model selection must use the 'provider/model' format.\",\n        });\n      }\n\n      const text = input.input?.trim();\n      const fileParts = toOpenCodeFileParts({\n        attachments: input.attachments,\n        resolveAttachmentPath: (attachment) =>\n          resolveAttachmentPath({\n            attachmentsDir: serverConfig.attachmentsDir,\n            attachment,\n          }),\n      });\n      if ((!text || text.length === 0) && fileParts.length === 0) {\n        return yield* new ProviderAdapterValidationError({\n          provider: PROVIDER,\n          operation: \"sendTurn\",\n          issue: \"OpenCode turns require text input or at least one attachment.\",\n        });\n      }\n\n      const agent = getModelSelectionStringOptionValue(modelSelection, \"agent\");\n      const variant = getModelSelectionStringOptionValue(modelSelection, \"variant\");\n\n      context.activeTurnId = turnId;\n      context.activeAgent = agent ?? (input.interactionMode === \"plan\" ? \"plan\" : undefined);\n      context.activeVariant = variant;\n      yield* updateProviderSession(\n        context,\n        {\n          status: \"running\",\n          activeTurnId: turnId,\n          model: modelSelection?.model ?? context.session.model,\n        },\n        { clearLastError: true },\n      );\n\n      if (steeringTurnId === undefined) {\n        yield* emit({\n          ...(yield* buildEventBase({ threadId: input.threadId, turnId })),\n          type: \"turn.started\",\n          payload: {\n            model: modelSelection?.model ?? context.session.model,\n            ...(variant ? { effort: variant } : {}),\n          },\n        });\n      }\n\n      yield* runOpenCodeSdk(\"session.promptAsync\", () =>\n        context.client.session.promptAsync({\n          sessionID: context.openCodeSessionId,\n          model: parsedModel,\n          ...(context.activeAgent ? { agent: context.activeAgent } : {}),\n          ...(context.activeVariant ? { variant: context.activeVariant } : {}),\n          parts: [...(text ? [{ type: \"text\" as const, text }] : []), ...fileParts],\n        }),",
    "checksum": "bd23ad46a4ad8ad0613a82192a06a3329c10808cfda57391fd77f2ba14fcccf9"
  },
  "usage-live-contract": {
    "id": "usage-live-contract",
    "path": "packages/contracts/src/providerRuntime.ts",
    "start": 309,
    "end": 331,
    "language": "typescript",
    "label": "Live thread token-usage snapshot contract",
    "code": "export const ThreadTokenUsageSnapshot = Schema.Struct({\n  usedTokens: NonNegativeInt,\n  totalProcessedTokens: Schema.optional(NonNegativeInt),\n  maxTokens: Schema.optional(PositiveInt),\n  inputTokens: Schema.optional(NonNegativeInt),\n  cachedInputTokens: Schema.optional(NonNegativeInt),\n  outputTokens: Schema.optional(NonNegativeInt),\n  reasoningOutputTokens: Schema.optional(NonNegativeInt),\n  lastUsedTokens: Schema.optional(NonNegativeInt),\n  lastInputTokens: Schema.optional(NonNegativeInt),\n  lastCachedInputTokens: Schema.optional(NonNegativeInt),\n  lastOutputTokens: Schema.optional(NonNegativeInt),\n  lastReasoningOutputTokens: Schema.optional(NonNegativeInt),\n  toolUses: Schema.optional(NonNegativeInt),\n  durationMs: Schema.optional(NonNegativeInt),\n  compactsAutomatically: Schema.optional(Schema.Boolean),\n});\nexport type ThreadTokenUsageSnapshot = typeof ThreadTokenUsageSnapshot.Type;\n\nconst ThreadTokenUsageUpdatedPayload = Schema.Struct({\n  usage: ThreadTokenUsageSnapshot,\n});\nexport type ThreadTokenUsageUpdatedPayload = typeof ThreadTokenUsageUpdatedPayload.Type;",
    "checksum": "d63a433efcb36c6017efca4dfa4c29f8e8186b060316152534c0befba263d700"
  },
  "usage-codex-normalization": {
    "id": "usage-codex-normalization",
    "path": "apps/server/src/provider/Layers/CodexAdapter.ts",
    "start": 159,
    "end": 190,
    "language": "typescript",
    "label": "Codex live token-usage normalization",
    "code": "function normalizeCodexTokenUsage(\n  usage: EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification[\"tokenUsage\"],\n): ThreadTokenUsageSnapshot | undefined {\n  const totalProcessedTokens = usage.total.totalTokens;\n  const usedTokens = usage.last.totalTokens;\n  if (usedTokens === undefined || usedTokens <= 0) {\n    return undefined;\n  }\n\n  const maxTokens = usage.modelContextWindow ?? undefined;\n  const inputTokens = usage.last.inputTokens;\n  const cachedInputTokens = usage.last.cachedInputTokens;\n  const outputTokens = usage.last.outputTokens;\n  const reasoningOutputTokens = usage.last.reasoningOutputTokens;\n\n  return {\n    usedTokens,\n    ...(totalProcessedTokens !== undefined && totalProcessedTokens > usedTokens\n      ? { totalProcessedTokens }\n      : {}),\n    ...(maxTokens !== undefined ? { maxTokens } : {}),\n    ...(inputTokens !== undefined ? { inputTokens } : {}),\n    ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),\n    ...(outputTokens !== undefined ? { outputTokens } : {}),\n    ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),\n    ...(usedTokens !== undefined ? { lastUsedTokens: usedTokens } : {}),\n    ...(inputTokens !== undefined ? { lastInputTokens: inputTokens } : {}),\n    ...(cachedInputTokens !== undefined ? { lastCachedInputTokens: cachedInputTokens } : {}),\n    ...(outputTokens !== undefined ? { lastOutputTokens: outputTokens } : {}),\n    ...(reasoningOutputTokens !== undefined\n      ? { lastReasoningOutputTokens: reasoningOutputTokens }\n      : {}),",
    "checksum": "fec887f108f8d86e020a989334ff325a8b42f40bb30b26f61e69fe87041df522"
  },
  "usage-codex-emission": {
    "id": "usage-codex-emission",
    "path": "apps/server/src/provider/Layers/CodexAdapter.ts",
    "start": 1000,
    "end": 1018,
    "language": "typescript",
    "label": "Codex live usage event emission",
    "code": "  if (event.method === \"thread/tokenUsage/updated\") {\n    const payload = readPayload(\n      EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification,\n      event.payload,\n    );\n    const normalizedUsage = payload ? normalizeCodexTokenUsage(payload.tokenUsage) : undefined;\n    if (!normalizedUsage) {\n      return [];\n    }\n    return [\n      {\n        type: \"thread.token-usage.updated\",\n        ...runtimeEventBase(event, canonicalThreadId),\n        payload: {\n          usage: normalizedUsage,\n        },\n      },\n    ];\n  }",
    "checksum": "b5443e4a9d8358ced1bc548a51227ab8796667482f262f5ebc6513cda5220cf1"
  },
  "usage-claude-emission": {
    "id": "usage-claude-emission",
    "path": "apps/server/src/provider/Layers/ClaudeAdapter.ts",
    "start": 2051,
    "end": 2088,
    "language": "typescript",
    "label": "Claude live usage event emission",
    "code": "  const emitThreadTokenUsage = Effect.fn(\"emitThreadTokenUsage\")(function* (\n    context: ClaudeSessionContext,\n    usage: ThreadTokenUsageSnapshot | undefined,\n    options?: {\n      readonly rawMethod?: string;\n      readonly rawPayload?: unknown;\n    },\n  ) {\n    if (!usage) {\n      return;\n    }\n\n    context.lastKnownTokenUsage = usage;\n    context.lastKnownTotalProcessedTokens =\n      usage.totalProcessedTokens ?? context.lastKnownTotalProcessedTokens;\n\n    const turnState = context.turnState;\n    const stamp = yield* makeEventStamp();\n    yield* offerRuntimeEvent({\n      type: \"thread.token-usage.updated\",\n      eventId: stamp.eventId,\n      provider: PROVIDER,\n      createdAt: stamp.createdAt,\n      threadId: context.session.threadId,\n      ...(turnState ? { turnId: turnState.turnId } : {}),\n      payload: {\n        usage,\n      },\n      providerRefs: nativeProviderRefs(context),\n      ...(options?.rawMethod || options?.rawPayload\n        ? {\n            raw: {\n              source: \"claude.sdk.message\" as const,\n              ...(options.rawMethod ? { method: options.rawMethod } : {}),\n              payload: options.rawPayload,\n            },\n          }\n        : {}),",
    "checksum": "1358344a9ecfbb8fb89639a941e39879abdeb0f8da803ccfa6e9b66cb69478f1"
  },
  "usage-live-activity": {
    "id": "usage-live-activity",
    "path": "apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts",
    "start": 766,
    "end": 784,
    "language": "typescript",
    "label": "Live usage becomes context-window activity",
    "code": "    case \"thread.token-usage.updated\": {\n      const payload = buildContextWindowActivityPayload(event);\n      if (!payload) {\n        return [];\n      }\n\n      return [\n        {\n          id: event.eventId,\n          createdAt: event.createdAt,\n          tone: \"info\",\n          kind: \"context-window.updated\",\n          summary: \"Context window updated\",\n          payload,\n          turnId: toTurnId(event.turnId) ?? null,\n          ...maybeSequence,\n        },\n      ];\n    }",
    "checksum": "32de8fdc5bf965dcd67f6e3ebef7b896b6605e8c2a5d2d0a5544a915dccf9c1e"
  },
  "usage-web-context-meter": {
    "id": "usage-web-context-meter",
    "path": "apps/web/src/lib/contextWindow.ts",
    "start": 50,
    "end": 96,
    "language": "typescript",
    "label": "Latest valid context-window snapshot derivation",
    "code": "export function deriveLatestContextWindowSnapshot(\n  activities: ReadonlyArray<OrchestrationThreadActivity>,\n): ContextWindowSnapshot | null {\n  for (let index = activities.length - 1; index >= 0; index -= 1) {\n    const activity = activities[index];\n    if (!activity || activity.kind !== \"context-window.updated\") {\n      continue;\n    }\n\n    const payload = asRecord(activity.payload);\n    const usedTokens = asFiniteNumber(payload?.usedTokens);\n    if (usedTokens === null || usedTokens < 0) {\n      continue;\n    }\n\n    const maxTokens = asFiniteNumber(payload?.maxTokens);\n    const usedPercentage =\n      maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;\n    const remainingTokens =\n      maxTokens !== null ? Math.max(0, Math.round(maxTokens - usedTokens)) : null;\n    const remainingPercentage = usedPercentage !== null ? Math.max(0, 100 - usedPercentage) : null;\n\n    return {\n      usedTokens,\n      totalProcessedTokens: asFiniteNumber(payload?.totalProcessedTokens),\n      maxTokens,\n      remainingTokens,\n      usedPercentage,\n      remainingPercentage,\n      inputTokens: asFiniteNumber(payload?.inputTokens),\n      cachedInputTokens: asFiniteNumber(payload?.cachedInputTokens),\n      outputTokens: asFiniteNumber(payload?.outputTokens),\n      reasoningOutputTokens: asFiniteNumber(payload?.reasoningOutputTokens),\n      lastUsedTokens: asFiniteNumber(payload?.lastUsedTokens),\n      lastInputTokens: asFiniteNumber(payload?.lastInputTokens),\n      lastCachedInputTokens: asFiniteNumber(payload?.lastCachedInputTokens),\n      lastOutputTokens: asFiniteNumber(payload?.lastOutputTokens),\n      lastReasoningOutputTokens: asFiniteNumber(payload?.lastReasoningOutputTokens),\n      toolUses: asFiniteNumber(payload?.toolUses),\n      durationMs: asFiniteNumber(payload?.durationMs),\n      compactsAutomatically: asBoolean(payload?.compactsAutomatically) ?? false,\n      updatedAt: activity.createdAt,\n    };\n  }\n\n  return null;\n}",
    "checksum": "f414738aaad3b6f8526e5760a436944757fefe35662bb9ce36fe9375f1c0c35b"
  },
  "usage-summary-contract": {
    "id": "usage-summary-contract",
    "path": "packages/contracts/src/usage.ts",
    "start": 1,
    "end": 101,
    "language": "typescript",
    "label": "Historical usage version, providers, tokens, and cost buckets",
    "code": "/**\n * Usage reporting contract.\n *\n * Each environment scans the provider CLIs' own on-disk session transcripts\n * (`~/.claude/projects/**\\/*.jsonl`, `~/.codex/sessions/**\\/*.jsonl`) rather than\n * relying on T3 Code's own orchestration projections, so usage stays complete\n * even for turns that were never driven through T3 Code. This mirrors the\n * approach `ccusage` takes.\n *\n * Environments return pre-aggregated `(day, hourStart?, provider, model)`\n * buckets. Raw transcript records never cross the wire.\n *\n * @module usage\n */\nimport * as Schema from \"effect/Schema\";\n\nimport { NonNegativeInt, TrimmedNonEmptyString } from \"./baseSchemas.ts\";\n\n/**\n * Bumped whenever the shape of {@link UsageSummary} changes incompatibly. The\n * client renders partial coverage when an environment reports an older version\n * rather than failing the whole page.\n */\nexport const USAGE_CONTRACT_VERSION = 4 as const;\n\nexport const UsageProviderKind = Schema.Literals([\"claude\", \"codex\"]);\nexport type UsageProviderKind = typeof UsageProviderKind.Type;\n\n/**\n * A calendar day in the reporting time zone, formatted `YYYY-MM-DD`.\n *\n * Days are bucketed server-side so that a turn always lands on the day the user\n * experienced it, not the UTC day.\n */\nconst USAGE_DAY_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\n\nexport const UsageDay = TrimmedNonEmptyString.check(Schema.isPattern(USAGE_DAY_PATTERN)).pipe(\n  Schema.brand(\"UsageDay\"),\n);\nexport type UsageDay = typeof UsageDay.Type;\n\nexport const UsageResolution = Schema.Literals([\"day\", \"hour\"]);\nexport type UsageResolution = typeof UsageResolution.Type;\n\n/**\n * Why a bucket's cost is what it is.\n *\n * - `providerReported` - the transcript carried an explicit cost figure.\n * - `modelPriced` - we matched the model against the LiteLLM rate table.\n * - `unpriced` - tokens are known, rates are not. Counted in totals, excluded\n *   from cost.\n */\nexport const UsageCostSource = Schema.Literals([\"providerReported\", \"modelPriced\", \"unpriced\"]);\nexport type UsageCostSource = typeof UsageCostSource.Type;\n\n/**\n * Token counts for a bucket.\n *\n * `cachedInputTokens` and `cacheCreationTokens` are disjoint from\n * `uncachedInputTokens`; summing all three gives total input. `reasoningTokens`\n * is a *subset* of `outputTokens` (Codex reports it that way, and Anthropic\n * folds thinking into output), so it must never be added on top.\n */\nexport const UsageTokenTotals = Schema.Struct({\n  uncachedInputTokens: NonNegativeInt,\n  cachedInputTokens: NonNegativeInt,\n  cacheCreationTokens: NonNegativeInt,\n  outputTokens: NonNegativeInt,\n  reasoningTokens: NonNegativeInt,\n});\nexport type UsageTokenTotals = typeof UsageTokenTotals.Type;\n\n/**\n * One `(day, hourStart?, provider, model)` cell. `hourStart` is the UTC start\n * instant of a rolling bucket and is present only for hourly requests.\n *\n * `costUsd` is the raw API-equivalent cost of these tokens. It is not money\n * spent: subscription plans bill separately. `unpricedRecords` counts records\n * whose tokens are included in the token totals but which contributed nothing\n * to `costUsd`.\n */\nexport const UsageBucket = Schema.Struct({\n  day: UsageDay,\n  hourStart: Schema.optional(TrimmedNonEmptyString),\n  provider: UsageProviderKind,\n  model: TrimmedNonEmptyString,\n  totals: UsageTokenTotals,\n  costUsd: Schema.Number,\n  /**\n   * What the cached input would have cost at full input rates minus what it\n   * actually cost. Requires the rate table, so it is computed alongside cost\n   * rather than derived on the client.\n   */\n  cacheSavingsUsd: Schema.Number,\n  costSource: UsageCostSource,\n  /** Distinct assistant responses, after de-duplication. */\n  records: NonNegativeInt,\n  unpricedRecords: NonNegativeInt,\n  /** Distinct transcript sessions that contributed to this cell. */\n  sessions: NonNegativeInt,\n});",
    "checksum": "f93dd8ada5db38b9c283d950acc7da22def26fa5c8ae2352aca8ab2aa31b3040"
  },
  "usage-home-discovery": {
    "id": "usage-home-discovery",
    "path": "apps/server/src/usage/UsageService.ts",
    "start": 187,
    "end": 225,
    "language": "typescript",
    "label": "Claude and Codex transcript home resolution",
    "code": "  /**\n   * Claude's config dir is the home itself when overridden, but a default\n   * install nests transcripts under `~/.claude/projects`. Probe both.\n   */\n  const resolveClaudeTranscriptDir = (homePath: string) =>\n    Effect.gen(function* () {\n      const nested = path.join(homePath, \".claude\", \"projects\");\n      const nestedExists = yield* fileSystem\n        .exists(nested)\n        .pipe(Effect.catchCause(() => Effect.succeed(false)));\n      return nestedExists ? nested : path.join(homePath, \"projects\");\n    });\n\n  /** Resolves the transcript directory for each provider. */\n  const resolveTranscriptDirs = Effect.fn(\"UsageService.resolveTranscriptDirs\")(function* () {\n    // A settings failure must surface as an error: swallowing it here would\n    // present \"zero usage from every provider\" as a valid answer.\n    const settings = yield* settingsService.getSettings.pipe(\n      Effect.catchCause(\n        (cause) =>\n          new UsageReadError({\n            reason: \"scanFailed\",\n            // Bounded description; the squashed failure travels as the cause.\n            // Squashed, not the Cause tree: a full tree in a Defect field is\n            // the unbounded wire payload the bounded detail exists to avoid.\n            detail: \"Server settings could not be read.\",\n            cause: Cause.squash(cause),\n          }),\n      ),\n    );\n\n    const claudeHome = yield* resolveClaudeHomePath(settings.providers.claudeAgent);\n    const claudeDir = yield* resolveClaudeTranscriptDir(claudeHome);\n    const codexLayout = yield* resolveCodexHomeLayout(settings.providers.codex);\n\n    return [\n      { provider: \"claude\" as const, dir: claudeDir },\n      { provider: \"codex\" as const, dir: path.join(codexLayout.sharedHomePath, \"sessions\") },\n    ];",
    "checksum": "d6526ea3f89bb7c8877e0d60c06a6f36809be5b51834b133045a40debecabafd"
  },
  "usage-transcript-parsers": {
    "id": "usage-transcript-parsers",
    "path": "apps/server/src/usage/usageTranscripts.ts",
    "start": 78,
    "end": 137,
    "language": "typescript",
    "label": "Claude transcript usage normalization",
    "code": "/**\n * Parses one line of a Claude Code transcript.\n *\n * T3 Code writes one record per assistant *content block*, and every one of\n * those records repeats the same complete `usage` object for the parent\n * message. Summing them overcounts by roughly 2.4x on a real workload, so the\n * caller must drop repeats by `dedupeKey` and keep the first.\n */\nexport function parseClaudeLine(line: string): UsageRecord | null {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(line);\n  } catch {\n    return null;\n  }\n  if (typeof parsed !== \"object\" || parsed === null) return null;\n\n  const record = parsed as Record<string, unknown>;\n  if (record[\"type\"] !== \"assistant\") return null;\n\n  const message = record[\"message\"];\n  if (typeof message !== \"object\" || message === null) return null;\n  const messageRecord = message as Record<string, unknown>;\n\n  const usage = messageRecord[\"usage\"];\n  if (typeof usage !== \"object\" || usage === null) return null;\n  const usageRecord = usage as Record<string, unknown>;\n\n  const timestampMs = parseTimestampMs(record[\"timestamp\"]);\n  if (timestampMs === null) return null;\n\n  const model = typeof messageRecord[\"model\"] === \"string\" ? messageRecord[\"model\"] : \"\";\n  if (model.length === 0) return null;\n\n  const messageId = typeof messageRecord[\"id\"] === \"string\" ? messageRecord[\"id\"] : null;\n  const requestId = typeof record[\"requestId\"] === \"string\" ? record[\"requestId\"] : null;\n  // Matches ccusage: prefer the message/request pair, fall back to whichever\n  // half exists. Records with neither cannot be de-duplicated.\n  const dedupeKey =\n    messageId === null && requestId === null ? null : `${messageId ?? \"\"}:${requestId ?? \"\"}`;\n\n  const cost = record[\"costUSD\"];\n\n  return {\n    provider: \"claude\",\n    timestampMs,\n    model,\n    sessionId: typeof record[\"sessionId\"] === \"string\" ? record[\"sessionId\"] : \"\",\n    totals: {\n      uncachedInputTokens: int(usageRecord[\"input_tokens\"]),\n      cachedInputTokens: int(usageRecord[\"cache_read_input_tokens\"]),\n      cacheCreationTokens: int(usageRecord[\"cache_creation_input_tokens\"]),\n      outputTokens: int(usageRecord[\"output_tokens\"]),\n      // Anthropic folds thinking tokens into output and does not break them out.\n      reasoningTokens: 0,\n    },\n    reportedCostUsd: typeof cost === \"number\" && Number.isFinite(cost) ? cost : null,\n    dedupeKey,\n  };\n}",
    "checksum": "98addede4c92886630a8f69b8ec46e776ac775bbb00896814ba7a17e244c4531"
  },
  "usage-dedup-buckets": {
    "id": "usage-dedup-buckets",
    "path": "apps/server/src/usage/usageAggregation.ts",
    "start": 109,
    "end": 178,
    "language": "typescript",
    "label": "Global deduplication, bounds, bucketing, and pricing fold",
    "code": "  /**\n   * Folds one record in. Returns whether it actually contributed, so callers\n   * can derive per-window facts (distinct sessions, for one) from the records\n   * that landed rather than everything the mtime prefilter happened to admit.\n   */\n  add(record: UsageRecord): boolean {\n    if (record.dedupeKey !== null) {\n      if (this.#seen.has(record.dedupeKey)) {\n        this.#duplicatesDropped += 1;\n        return false;\n      }\n      this.#seen.add(record.dedupeKey);\n    }\n\n    if (\n      this.#hourlyWindow !== null &&\n      (record.timestampMs < this.#hourlyWindow.sinceTimeMs ||\n        record.timestampMs >= this.#hourlyWindow.untilTimeMs)\n    ) {\n      this.#outOfWindow += 1;\n      return false;\n    }\n\n    const day = this.#toDay(record.timestampMs);\n    if (\n      this.#hourlyWindow === null &&\n      (day < this.#options.sinceDay || day > this.#options.untilDay)\n    ) {\n      this.#outOfWindow += 1;\n      return false;\n    }\n\n    const hourStart =\n      this.#hourlyWindow === null\n        ? \"\"\n        : new Date(\n            this.#hourlyWindow.sinceTimeMs +\n              Math.floor((record.timestampMs - this.#hourlyWindow.sinceTimeMs) / HOUR_MS) * HOUR_MS,\n          ).toISOString();\n    const key = `${day}\\u0000${hourStart}\\u0000${record.provider}\\u0000${record.model}`;\n    let bucket = this.#buckets.get(key);\n    if (bucket === undefined) {\n      bucket = {\n        totals: EMPTY_TOTALS,\n        costUsd: 0,\n        cacheSavingsUsd: 0,\n        records: 0,\n        unpricedRecords: 0,\n        providerReportedRecords: 0,\n        sessions: new Set<string>(),\n      };\n      this.#buckets.set(key, bucket);\n    }\n\n    const priced = priceUsage(\n      this.#options.rates,\n      record.model,\n      record.totals,\n      record.reportedCostUsd,\n    );\n\n    bucket.totals = addTotals(bucket.totals, record.totals);\n    bucket.costUsd += priced.costUsd;\n    bucket.cacheSavingsUsd += cacheSavingsUsd(this.#options.rates, record.model, record.totals);\n    bucket.records += 1;\n    if (priced.costSource === \"unpriced\") bucket.unpricedRecords += 1;\n    if (priced.costSource === \"providerReported\") bucket.providerReportedRecords += 1;\n    if (record.sessionId.length > 0) bucket.sessions.add(record.sessionId);\n    return true;\n  }",
    "checksum": "ca4bb237d353ca5cbf384f3e91c0d802c24e1764b19871add182ac894cc19677"
  },
  "usage-pricing-cache": {
    "id": "usage-pricing-cache",
    "path": "apps/server/src/usage/usagePricing.ts",
    "start": 85,
    "end": 148,
    "language": "typescript",
    "label": "Historical usage rate lookup and pricing arithmetic",
    "code": "/**\n * Models we never price, regardless of the table.\n *\n * `<synthetic>` marks locally generated messages that were never billed. Bare\n * family names (\"opus\", \"sonnet\") are genuinely ambiguous across generations,\n * so we report them as unpriced instead of guessing a generation.\n */\nconst UNPRICEABLE_MODELS = new Set([\n  \"<synthetic>\",\n  \"synthetic\",\n  \"opus\",\n  \"sonnet\",\n  \"haiku\",\n  \"fable\",\n]);\n\nexport function lookupRate(table: RateTable, model: string): ModelRate | null {\n  const normalized = normalizeModelName(model);\n  if (normalized.length === 0 || UNPRICEABLE_MODELS.has(normalized)) return null;\n  return table.get(normalized) ?? null;\n}\n\nexport interface PricedUsage {\n  readonly costUsd: number;\n  readonly costSource: UsageCostSource;\n}\n\n/**\n * Prices a bucket's tokens.\n *\n * `reasoningTokens` is intentionally not charged separately: it is already\n * counted inside `outputTokens`.\n */\nexport function priceUsage(\n  table: RateTable,\n  model: string,\n  totals: UsageTokenTotals,\n  reportedCostUsd: number | null,\n): PricedUsage {\n  if (reportedCostUsd !== null && Number.isFinite(reportedCostUsd)) {\n    return { costUsd: reportedCostUsd, costSource: \"providerReported\" };\n  }\n\n  const rate = lookupRate(table, model);\n  if (rate === null) return { costUsd: 0, costSource: \"unpriced\" };\n\n  const costUsd =\n    totals.uncachedInputTokens * rate.inputCostPerToken +\n    totals.cachedInputTokens * rate.cacheReadCostPerToken +\n    totals.cacheCreationTokens * rate.cacheCreationCostPerToken +\n    totals.outputTokens * rate.outputCostPerToken;\n\n  return { costUsd, costSource: \"modelPriced\" };\n}\n\n/**\n * What the cached input would have cost at full input rates, minus what it\n * actually cost. Drives the \"cache savings\" figure.\n */\nexport function cacheSavingsUsd(table: RateTable, model: string, totals: UsageTokenTotals): number {\n  const rate = lookupRate(table, model);\n  if (rate === null) return 0;\n  return totals.cachedInputTokens * (rate.inputCostPerToken - rate.cacheReadCostPerToken);\n}",
    "checksum": "c1d6f1e6a20765222fbbd5c94a90766711a846430088f37c1242011fd9ec1518"
  },
  "usage-rpc-contract": {
    "id": "usage-rpc-contract",
    "path": "packages/contracts/src/rpc.ts",
    "start": 260,
    "end": 284,
    "language": "typescript",
    "label": "Typed usage summary RPC",
    "code": "  previewAutomationFocusHost: \"previewAutomation.focusHost\",\n\n  // Server meta\n  serverProbe: \"server.probe\",\n  serverGetConfig: \"server.getConfig\",\n  serverRefreshProviders: \"server.refreshProviders\",\n  serverUpdateProvider: \"server.updateProvider\",\n  serverUpdateServer: \"server.updateServer\",\n  serverUpdateServerWithProgress: \"server.updateServerWithProgress\",\n  serverUpsertKeybinding: \"server.upsertKeybinding\",\n  serverRemoveKeybinding: \"server.removeKeybinding\",\n  serverGetSettings: \"server.getSettings\",\n  serverUpdateSettings: \"server.updateSettings\",\n  serverDiscoverSourceControl: \"server.discoverSourceControl\",\n  serverGetTraceDiagnostics: \"server.getTraceDiagnostics\",\n  serverGetProcessDiagnostics: \"server.getProcessDiagnostics\",\n  serverGetProcessResourceHistory: \"server.getProcessResourceHistory\",\n  serverGetResourceTelemetryHistory: \"server.getResourceTelemetryHistory\",\n  serverRetryResourceTelemetry: \"server.retryResourceTelemetry\",\n  serverSignalProcess: \"server.signalProcess\",\n  serverReportClientActivity: \"server.reportClientActivity\",\n  serverReportHostPowerState: \"server.reportHostPowerState\",\n  serverGetBackgroundPolicy: \"server.getBackgroundPolicy\",\n  serverGetUsageSummary: \"server.getUsageSummary\",\n",
    "checksum": "a9bdb475c42adc730d43788b4336aa36b6c0de90e60fc9dcd2139b1f929e9ea6"
  },
  "usage-environment-merge": {
    "id": "usage-environment-merge",
    "path": "packages/shared/src/usageMerge.ts",
    "start": 102,
    "end": 163,
    "language": "typescript",
    "label": "Deterministic physical-source ownership across environments",
    "code": "/**\n * Decides which environment owns each physical transcript directory.\n *\n * Several environments on one machine (worktree servers, for instance) resolve\n * the same provider home and would otherwise double count every token. The\n * first environment in a stable order claims a fingerprint; the rest have that\n * provider's buckets dropped. Environments are sorted by id so the winner does\n * not change between renders.\n */\nfunction claimSources(environments: readonly EnvironmentUsage[]): {\n  readonly ownerByFingerprint: ReadonlyMap<string, EnvironmentId>;\n  readonly duplicates: readonly string[];\n} {\n  const ownerByFingerprint = new Map<string, EnvironmentId>();\n  const duplicates: string[] = [];\n\n  const ordered = [...environments].sort((a, b) => a.environmentId.localeCompare(b.environmentId));\n\n  for (const environment of ordered) {\n    for (const source of environment.summary.sources) {\n      if (source.status === \"missing\") continue;\n      const key = fingerprintKey(source.fingerprint);\n      if (ownerByFingerprint.has(key)) {\n        duplicates.push(`${environment.label}: ${source.fingerprint.resolvedHomePath}`);\n        continue;\n      }\n      ownerByFingerprint.set(key, environment.environmentId);\n    }\n  }\n\n  return { ownerByFingerprint, duplicates };\n}\n\n/** Sources this environment owns after fingerprint claims, plus their buckets. */\nfunction ownedContribution(\n  environment: EnvironmentUsage,\n  ownerByFingerprint: ReadonlyMap<string, EnvironmentId>,\n): {\n  readonly buckets: readonly UsageBucket[];\n  readonly sessionsByProvider: ReadonlyMap<UsageProviderKind, number>;\n} {\n  const ownedProviders = new Set<UsageProviderKind>();\n  const sessionsByProvider = new Map<UsageProviderKind, number>();\n  for (const source of environment.summary.sources) {\n    if (source.status === \"missing\") continue;\n    const key = fingerprintKey(source.fingerprint);\n    if (ownerByFingerprint.get(key) === environment.environmentId) {\n      const provider = source.fingerprint.provider;\n      ownedProviders.add(provider);\n      // Distinct within a directory. Summing per-bucket session counts instead\n      // would count a session once per day and model it spans.\n      sessionsByProvider.set(\n        provider,\n        (sessionsByProvider.get(provider) ?? 0) + source.distinctSessions,\n      );\n    }\n  }\n  return {\n    buckets: environment.summary.buckets.filter((bucket) => ownedProviders.has(bucket.provider)),\n    sessionsByProvider,\n  };\n}",
    "checksum": "2ef3c27f0875e553cc334289b2ffa24682b812e8a15f401be76eb06240ccfb98"
  },
  "usage-reader-failure-policy": {
    "id": "usage-reader-failure-policy",
    "path": "apps/server/src/usage/usageTranscriptReader.ts",
    "start": 92,
    "end": 140,
    "language": "typescript",
    "label": "Streaming transcript read and null-on-read-failure policy",
    "code": "/**\n * Streams one transcript and returns the usage records it contains, or `null`\n * when the file could not be read.\n *\n * The distinction matters to the caller's cache: a genuinely empty transcript\n * is a stable fact worth memoising, while a transient read failure memoised\n * under the same `(size, mtime)` key would silently drop that file's usage\n * until the file next changes.\n *\n * Codex carries the active model on `turn_context` lines that hold no usage of\n * their own, so those still have to pass through the reducer to keep model\n * attribution correct.\n */\nexport async function readTranscriptRecords(\n  filePath: string,\n  provider: UsageProviderKind,\n): Promise<readonly UsageRecord[] | null> {\n  const records: UsageRecord[] = [];\n  const codexState = initialCodexScanState();\n\n  try {\n    const lines = NodeReadline.createInterface({\n      input: NodeFS.createReadStream(filePath, { encoding: \"utf8\" }),\n      crlfDelay: Infinity,\n    });\n\n    for await (const line of lines) {\n      if (provider === \"codex\") {\n        if (\n          !mightCarryUsage(line, provider) &&\n          !line.includes('\"turn_context\"') &&\n          !line.includes('\"session_meta\"')\n        ) {\n          continue;\n        }\n        const record = parseCodexLine(line, codexState);\n        if (record !== null) records.push(record);\n        continue;\n      }\n\n      if (!mightCarryUsage(line, provider)) continue;\n      const record = parseClaudeLine(line);\n      if (record !== null) records.push(record);\n    }\n  } catch {\n    return null;\n  }\n\n  return records;",
    "checksum": "a4603871e61cae2e5575a2df75f84ff9f5684262b1cb59e638f3009e66fdfa58"
  },
  "usage-source-status": {
    "id": "usage-source-status",
    "path": "apps/server/src/usage/UsageService.ts",
    "start": 352,
    "end": 408,
    "language": "typescript",
    "label": "Current historical source status and session accounting",
    "code": "    const sources: UsageSource[] = [];\n    const livePaths = new Set<string>();\n    const walkedRoots: string[] = [];\n\n    for (const { provider, dir } of dirs) {\n      const volumeId = yield* Effect.promise(() => readDirectoryVolumeId(dir));\n      const exists = yield* fileSystem\n        .exists(dir)\n        .pipe(Effect.catchCause(() => Effect.succeed(false)));\n\n      if (!exists) {\n        sources.push({\n          fingerprint: { hostId, provider, resolvedHomePath: dir, volumeId },\n          status: \"missing\",\n          scannedFiles: 0,\n          skippedFiles: 0,\n          malformedRecords: 0,\n          distinctSessions: 0,\n          message: \"No transcript directory on this environment.\",\n        });\n        continue;\n      }\n\n      walkedRoots.push(dir);\n      const files = yield* Effect.promise(() => listTranscriptFiles(dir, windowStartMs));\n      let scannedFiles = 0;\n      let skippedFiles = 0;\n      // Distinct per directory. Buckets carry per-cell session counts, but a\n      // session spans days and models, so clients total this figure instead.\n      const sessionIds = new Set<string>();\n\n      for (const file of files) {\n        livePaths.add(file.path);\n        const records = yield* readFileRecords(file.path, file.size, file.mtimeMs, provider);\n        if (records.length === 0) {\n          skippedFiles += 1;\n          continue;\n        }\n        scannedFiles += 1;\n        for (const record of records) {\n          // Only sessions that contributed in-window count: the mtime slack\n          // admits boundary files whose records fall outside the range.\n          if (aggregator.add(record) && record.sessionId.length > 0) {\n            sessionIds.add(record.sessionId);\n          }\n        }\n      }\n\n      sources.push({\n        fingerprint: { hostId, provider, resolvedHomePath: dir, volumeId },\n        status: \"ok\",\n        scannedFiles,\n        skippedFiles,\n        malformedRecords: 0,\n        distinctSessions: sessionIds.size,\n        message: null,\n      });",
    "checksum": "619a5fb4c66a09b2bf6abed238f22779341b997262bc48736bd927aa19f042f1"
  },
  "project-root-normalization": {
    "id": "project-root-normalization",
    "path": "apps/server/src/workspace/WorkspacePaths.ts",
    "start": 161,
    "end": 200,
    "language": "typescript",
    "label": "Workspace-root resolution, validation, and opt-in creation",
    "code": "  const normalizeWorkspaceRoot: WorkspacePaths[\"Service\"][\"normalizeWorkspaceRoot\"] = Effect.fn(\n    \"WorkspacePaths.normalizeWorkspaceRoot\",\n  )(function* (workspaceRoot, options) {\n    const normalizedWorkspaceRoot = path.resolve(expandHomePath(workspaceRoot.trim(), path));\n    let workspaceStat = yield* statWorkspaceRoot(\n      workspaceRoot,\n      normalizedWorkspaceRoot,\n      \"validate-existing\",\n    );\n    if (!workspaceStat && options?.createIfMissing) {\n      yield* fileSystem.makeDirectory(normalizedWorkspaceRoot, { recursive: true }).pipe(\n        Effect.mapError(\n          (cause) =>\n            new WorkspaceRootCreateFailedError({\n              workspaceRoot,\n              normalizedWorkspaceRoot,\n              cause,\n            }),\n        ),\n      );\n      workspaceStat = yield* statWorkspaceRoot(\n        workspaceRoot,\n        normalizedWorkspaceRoot,\n        \"verify-created\",\n      );\n    }\n    if (!workspaceStat) {\n      return yield* new WorkspaceRootNotExistsError({\n        workspaceRoot,\n        normalizedWorkspaceRoot,\n      });\n    }\n    if (workspaceStat.type !== \"Directory\") {\n      return yield* new WorkspaceRootNotDirectoryError({\n        workspaceRoot,\n        normalizedWorkspaceRoot,\n      });\n    }\n    return normalizedWorkspaceRoot;\n  });",
    "checksum": "dc1befa9f427fd48c5c9988360c52a9532a82d89a2e243b0dee2c25f2794fc12"
  },
  "project-create-normalization": {
    "id": "project-create-normalization",
    "path": "apps/server/src/orchestration/Normalizer.ts",
    "start": 55,
    "end": 90,
    "language": "typescript",
    "label": "Project creation normalization before dispatch",
    "code": "    const normalizeProjectWorkspaceRoot = (workspaceRoot: string) =>\n      workspacePaths.normalizeWorkspaceRoot(workspaceRoot).pipe(\n        Effect.mapError(\n          (cause) =>\n            new OrchestrationDispatchCommandError({\n              message: cause.message,\n            }),\n        ),\n      );\n\n    const normalizeProjectWorkspaceRootForCreate = (\n      workspaceRoot: string,\n      createIfMissing: boolean | undefined,\n    ) =>\n      workspacePaths\n        .normalizeWorkspaceRoot(workspaceRoot, {\n          createIfMissing: createIfMissing === true,\n        })\n        .pipe(\n          Effect.mapError(\n            (cause) =>\n              new OrchestrationDispatchCommandError({\n                message: cause.message,\n              }),\n          ),\n        );\n\n    if (canonicalCommand.type === \"project.create\") {\n      return {\n        ...canonicalCommand,\n        workspaceRoot: yield* normalizeProjectWorkspaceRootForCreate(\n          canonicalCommand.workspaceRoot,\n          canonicalCommand.createWorkspaceRootIfMissing,\n        ),\n        createWorkspaceRootIfMissing: canonicalCommand.createWorkspaceRootIfMissing === true,\n      } satisfies OrchestrationCommand;",
    "checksum": "6b0a20d1e9548a92779defd07120ed3e684de23de08d6de2f159a36edf6b1f57"
  },
  "project-root-uniqueness": {
    "id": "project-root-uniqueness",
    "path": "apps/server/src/orchestration/commandInvariants.ts",
    "start": 75,
    "end": 97,
    "language": "typescript",
    "label": "Active project workspace-root uniqueness invariant",
    "code": "export function requireActiveProjectWorkspaceRootAbsent(input: {\n  readonly readModel: OrchestrationReadModel;\n  readonly command: OrchestrationCommand;\n  readonly workspaceRoot: string;\n  readonly exceptProjectId?: ProjectId;\n}): Effect.Effect<void, OrchestrationCommandInvariantError> {\n  const normalizedWorkspaceRoot = normalizeProjectPathForComparison(input.workspaceRoot);\n  const existingProject = input.readModel.projects.find(\n    (project) =>\n      project.deletedAt === null &&\n      normalizeProjectPathForComparison(project.workspaceRoot) === normalizedWorkspaceRoot &&\n      project.id !== input.exceptProjectId,\n  );\n  if (existingProject === undefined) {\n    return Effect.void;\n  }\n  return Effect.fail(\n    invariantError(\n      input.command.type,\n      `Active project '${existingProject.id}' already exists for workspace root '${normalizedWorkspaceRoot}'.`,\n    ),\n  );\n}",
    "checksum": "deb6be62e500f8c6488c70dc0a2563c7f313722d5a4dc04e4c5e9aab21b4c134"
  },
  "project-t3-file-schema": {
    "id": "project-t3-file-schema",
    "path": "packages/contracts/src/t3ProjectFile.ts",
    "start": 7,
    "end": 94,
    "language": "typescript",
    "label": "Checked-in t3.json project configuration contract",
    "code": "/** File name of the checked-in T3 project file, resolved at the workspace root. */\nexport const T3_PROJECT_FILE_NAME = \"t3.json\";\n\n/** Public URL of the published JSON Schema for {@link T3ProjectFile}. */\nexport const T3_PROJECT_FILE_SCHEMA_URL = \"https://t3.codes/schema/t3.json\";\n\nconst T3_PROJECT_FILE_PATH_MAX_LENGTH = 512;\nconst T3_PROJECT_FILE_MAX_SCRIPTS = 50;\n\n// Annotations go on the encoded (string) side so they survive into the\n// published JSON Schema; decoding still trims and re-validates non-emptiness.\nconst trimmedNonEmpty = (annotations: { readonly description: string }, maxLength?: number) => {\n  const annotated = Schema.String.annotate(annotations);\n  const encoded =\n    maxLength === undefined\n      ? annotated.check(Schema.isNonEmpty())\n      : annotated.check(Schema.isNonEmpty(), Schema.isMaxLength(maxLength));\n  return encoded.pipe(Schema.decodeTo(encoded, SchemaTransformation.trim()));\n};\n\nexport const T3ProjectFileScript = Schema.Struct({\n  name: trimmedNonEmpty({\n    description: \"Display name for the script, shown in the T3 Code scripts menu.\",\n  }),\n  command: trimmedNonEmpty({\n    description: \"Shell command executed in a T3 Code terminal at the project root.\",\n  }),\n  icon: Schema.optionalKey(\n    ProjectScriptIcon.annotate({\n      description: 'Icon shown next to the script in the scripts menu. Defaults to \"play\".',\n    }),\n  ),\n  runOnWorktreeCreate: Schema.optionalKey(\n    Schema.Boolean.annotate({\n      description:\n        \"When true, the script runs automatically after a worktree is created for a new thread.\",\n    }),\n  ),\n  previewUrl: Schema.optionalKey(\n    trimmedNonEmpty({\n      description:\n        \"URL opened in the in-app browser preview when this script runs. Only honored on the desktop build.\",\n    }),\n  ),\n  autoOpenPreview: Schema.optionalKey(\n    Schema.Boolean.annotate({\n      description:\n        \"When true, automatically open the preview panel at `previewUrl` the moment the script starts.\",\n    }),\n  ),\n}).annotate({\n  description: \"A project script that team members can import into T3 Code.\",\n});\nexport type T3ProjectFileScript = typeof T3ProjectFileScript.Type;\n\nexport const T3ProjectFile = Schema.Struct({\n  $schema: Schema.optionalKey(\n    Schema.String.annotate({\n      description: `URL of the JSON Schema for this file, typically \"${T3_PROJECT_FILE_SCHEMA_URL}\".`,\n    }),\n  ),\n  iconPath: Schema.optionalKey(\n    trimmedNonEmpty(\n      {\n        description:\n          'Workspace-relative path to the project icon (e.g. \"assets/logo.svg\"). Checked before T3 Code\\'s built-in icon locations.',\n      },\n      T3_PROJECT_FILE_PATH_MAX_LENGTH,\n    ),\n  ),\n  defaultThreadEnvMode: Schema.optionalKey(\n    ThreadEnvMode.annotate({\n      description:\n        'Where new threads start for this repository: \"worktree\" for a fresh git worktree, \"local\" for the current checkout. A per-project setting in T3 Code overrides this; when neither is set, the global default applies.',\n    }),\n  ),\n  scripts: Schema.optionalKey(\n    Schema.Array(T3ProjectFileScript)\n      .annotate({\n        description: \"Project scripts shared with everyone who opens this repository in T3 Code.\",\n      })\n      .check(Schema.isMaxLength(T3_PROJECT_FILE_MAX_SCRIPTS)),\n  ),\n}).annotate({\n  title: \"T3 project file\",\n  description:\n    \"Checked-in project configuration for T3 Code (t3.json at the repository root). See https://t3.codes for documentation.\",\n});",
    "checksum": "9b60c876a679d515b8a414916f3f37d5b8e502a68d55df9d21ee476d8cb4e379"
  },
  "project-t3-file-loader": {
    "id": "project-t3-file-loader",
    "path": "apps/server/src/project/T3ProjectFileLoader.ts",
    "start": 42,
    "end": 105,
    "language": "typescript",
    "label": "Best-effort t3.json loading and validation",
    "code": "    /**\n     * Load and decode `t3.json` at the workspace root.\n     *\n     * Never fails: missing, unreadable, or invalid files resolve to\n     * `Option.none` (invalid files are logged as warnings).\n     */\n    readonly load: (workspaceRoot: string) => Effect.Effect<Option.Option<T3ProjectFile>>;\n  }\n>()(\"t3/project/T3ProjectFileLoader\") {}\n\nconst logT3ProjectFileLoadError = (error: T3ProjectFileLoadError) =>\n  Effect.logWarning(error).pipe(\n    Effect.annotateLogs({\n      operation: error.operation,\n      workspaceRoot: error.workspaceRoot,\n      filePath: error.filePath,\n      errorTag: error._tag,\n    }),\n  );\n\nexport const make = Effect.gen(function* () {\n  const fileSystem = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n\n  const load: T3ProjectFileLoader[\"Service\"][\"load\"] = Effect.fn(\"T3ProjectFileLoader.load\")(\n    function* (workspaceRoot) {\n      const filePath = path.join(workspaceRoot, T3_PROJECT_FILE_NAME);\n      const raw = yield* fileSystem.readFileString(filePath).pipe(\n        Effect.map(Option.some),\n        Effect.catchTags({\n          PlatformError: (error) =>\n            error.reason._tag === \"NotFound\"\n              ? Effect.succeed(Option.none<string>())\n              : logT3ProjectFileLoadError(\n                  new T3ProjectFileLoadError({\n                    operation: \"read\",\n                    workspaceRoot,\n                    filePath,\n                    cause: error,\n                  }),\n                ).pipe(Effect.as(Option.none<string>())),\n        }),\n      );\n      if (Option.isNone(raw)) {\n        return Option.none<T3ProjectFile>();\n      }\n      return yield* decodeT3ProjectFileJson(raw.value).pipe(\n        Effect.map(Option.some),\n        Effect.catchTags({\n          SchemaError: (error) =>\n            logT3ProjectFileLoadError(\n              new T3ProjectFileLoadError({\n                operation: \"decode\",\n                workspaceRoot,\n                filePath,\n                cause: error,\n              }),\n            ).pipe(Effect.as(Option.none<T3ProjectFile>())),\n        }),\n      );\n    },\n  );\n\n  return T3ProjectFileLoader.of({ load });",
    "checksum": "1a2c82901fba9d86213563abdee2569b7f48283533b7c7cc23b5bfd46b7df753"
  },
  "project-t3-file-loader-tests": {
    "id": "project-t3-file-loader-tests",
    "path": "apps/server/src/project/T3ProjectFileLoader.test.ts",
    "start": 29,
    "end": 88,
    "language": "typescript",
    "label": "t3.json JSONC, missing-file, and invalid-input tests",
    "code": "it.layer(TestLayer)(\"T3ProjectFileLoader\", (it) => {\n  describe(\"load\", () => {\n    it.effect(\"loads and decodes a valid t3.json\", () =>\n      Effect.gen(function* () {\n        const loader = yield* T3ProjectFileLoader.T3ProjectFileLoader;\n        const cwd = yield* makeTempDir;\n        yield* writeProjectFile(\n          cwd,\n          `{\n            // JSONC is tolerated\n            \"iconPath\": \"assets/logo.svg\",\n            \"scripts\": [{ \"name\": \"Dev\", \"command\": \"pnpm dev\" }],\n          }`,\n        );\n\n        const loaded = yield* loader.load(cwd);\n\n        expect(Option.isSome(loaded)).toBe(true);\n        if (Option.isSome(loaded)) {\n          expect(loaded.value.iconPath).toBe(\"assets/logo.svg\");\n          expect(loaded.value.scripts).toEqual([{ name: \"Dev\", command: \"pnpm dev\" }]);\n        }\n      }),\n    );\n\n    it.effect(\"returns none when t3.json is missing\", () =>\n      Effect.gen(function* () {\n        const loader = yield* T3ProjectFileLoader.T3ProjectFileLoader;\n        const cwd = yield* makeTempDir;\n\n        const loaded = yield* loader.load(cwd);\n\n        expect(Option.isNone(loaded)).toBe(true);\n      }),\n    );\n\n    it.effect(\"returns none for malformed JSON without failing\", () =>\n      Effect.gen(function* () {\n        const loader = yield* T3ProjectFileLoader.T3ProjectFileLoader;\n        const cwd = yield* makeTempDir;\n        yield* writeProjectFile(cwd, \"{ not json\");\n\n        const loaded = yield* loader.load(cwd);\n\n        expect(Option.isNone(loaded)).toBe(true);\n      }),\n    );\n\n    it.effect(\"returns none for schema-invalid files without failing\", () =>\n      Effect.gen(function* () {\n        const loader = yield* T3ProjectFileLoader.T3ProjectFileLoader;\n        const cwd = yield* makeTempDir;\n        yield* writeProjectFile(cwd, '{ \"scripts\": [{ \"name\": \"Dev\" }] }');\n\n        const loaded = yield* loader.load(cwd);\n\n        expect(Option.isNone(loaded)).toBe(true);\n      }),\n    );\n  });",
    "checksum": "e86ba3069d84308153516d912b05407d54ea3630b7ad2b1a21efb1fe37fb344f"
  },
  "project-thread-env-precedence": {
    "id": "project-thread-env-precedence",
    "path": "packages/shared/src/threadEnvMode.ts",
    "start": 3,
    "end": 35,
    "language": "typescript",
    "label": "Project, t3.json, and global thread-environment precedence",
    "code": "/**\n * Canonical priority order for a project's default thread env mode:\n * per-project setting > checked-in t3.json > global server setting.\n *\n * An explicit composer pick outranks all of these; callers apply it before\n * consulting the defaults. Web resolves the sources imperatively at draft\n * creation, mobile reactively — both must route through this function so the\n * platforms cannot disagree on the order.\n */\nexport function resolveDefaultThreadEnvMode(sources: {\n  readonly projectSetting: ThreadEnvMode | null | undefined;\n  readonly projectFile: ThreadEnvMode | null | undefined;\n  readonly globalDefault: ThreadEnvMode;\n}): ThreadEnvMode {\n  return sources.projectSetting ?? sources.projectFile ?? sources.globalDefault;\n}\n\n/**\n * True once the resolved default can no longer change: an explicit pick or a\n * source that outranks t3.json decided, or the file read settled. While\n * false, nothing may persist the provisional default (for example into a\n * draft's workspace selection) — it could differ from the final value.\n */\nexport function isDefaultThreadEnvModeSettled(sources: {\n  readonly explicitMode: ThreadEnvMode | undefined;\n  readonly projectSetting: ThreadEnvMode | null | undefined;\n  readonly projectFilePending: boolean;\n}): boolean {\n  return (\n    sources.explicitMode !== undefined ||\n    sources.projectSetting != null ||\n    !sources.projectFilePending\n  );",
    "checksum": "f92aec71fc3a12aa186ad667b7a2e1adb8ac4e560f6f6376511e4b0765ee7851"
  },
  "project-settings-inherited-default": {
    "id": "project-settings-inherited-default",
    "path": "apps/web/src/components/settings/ProjectSettingsPanel.tsx",
    "start": 475,
    "end": 482,
    "language": "tsx",
    "label": "Inherited project environment default in web settings",
    "code": "  const t3File = useT3ProjectFileState(\n    selectedCheckout.environmentId,\n    selectedCheckout.workspaceRoot,\n  );\n  // What the \"Default\" option resolves to while no override is set: the\n  // repo's t3.json value when present, otherwise the global setting.\n  const inheritedEnvMode = t3File.file?.defaultThreadEnvMode ?? settings.defaultThreadEnvMode;\n  const inheritedEnvModeSource = t3File.file?.defaultThreadEnvMode != null ? \"t3.json\" : \"global\";",
    "checksum": "7ab6370096f28cd8e0175e8d2a40f3e7e4e29a087f725975228b5ffdff9f68a2"
  },
  "project-settings-project-override": {
    "id": "project-settings-project-override",
    "path": "apps/web/src/components/settings/ProjectSettingsPanel.tsx",
    "start": 866,
    "end": 905,
    "language": "tsx",
    "label": "Project environment override controls",
    "code": "          <SettingsRow\n            title=\"Workspace\"\n            description=\"Where new threads in this project start. Overrides t3.json and the global default; applies to every checkout in this group.\"\n            resetAction={\n              storedEnvMode !== null ? (\n                <SettingResetButton\n                  label=\"project workspace default\"\n                  onClick={() => setDefaultThreadEnvMode(null)}\n                />\n              ) : null\n            }\n            control={\n              <Select\n                value={storedEnvMode ?? \"inherit\"}\n                onValueChange={(value) => {\n                  if (value === \"worktree\" || value === \"local\") {\n                    setDefaultThreadEnvMode(value);\n                  } else if (value === \"inherit\") {\n                    setDefaultThreadEnvMode(null);\n                  }\n                }}\n              >\n                <SelectTrigger aria-label=\"New-thread workspace\">\n                  <SelectValue>\n                    {storedEnvMode === null\n                      ? group.memberProjects.length > 1\n                        ? \"Default (per checkout)\"\n                        : `Default (${resolveEnvModeLabel(inheritedEnvMode).toLowerCase()})`\n                      : resolveEnvModeLabel(storedEnvMode)}\n                  </SelectValue>\n                </SelectTrigger>\n                <SelectPopup align=\"end\" alignItemWithTrigger={false}>\n                  <SelectItem value=\"inherit\">\n                    {group.memberProjects.length > 1\n                      ? \"Default (each checkout's t3.json or global setting)\"\n                      : `Default (${inheritedEnvModeSource}: ${resolveEnvModeLabel(inheritedEnvMode).toLowerCase()})`}\n                  </SelectItem>\n                  <SelectItem value=\"worktree\">{resolveEnvModeLabel(\"worktree\")}</SelectItem>\n                  <SelectItem value=\"local\">{resolveEnvModeLabel(\"local\")}</SelectItem>\n                </SelectPopup>",
    "checksum": "8bfa93d2fed3d5a4362c1c30abedf00d2d1811052808a02f9ec63ed3338c8d35"
  },
  "project-repository-identity": {
    "id": "project-repository-identity",
    "path": "apps/server/src/project/RepositoryIdentityResolver.ts",
    "start": 48,
    "end": 166,
    "language": "typescript",
    "label": "Best-effort Git remote repository identity resolution",
    "code": "function pickPrimaryRemote(\n  remotes: ReadonlyMap<string, string>,\n): { readonly remoteName: string; readonly remoteUrl: string } | null {\n  for (const preferredRemoteName of [\"upstream\", \"origin\"] as const) {\n    const remoteUrl = remotes.get(preferredRemoteName);\n    if (remoteUrl) {\n      return { remoteName: preferredRemoteName, remoteUrl };\n    }\n  }\n\n  const [remoteName, remoteUrl] =\n    [...remotes.entries()].toSorted(([left], [right]) => left.localeCompare(right))[0] ?? [];\n  return remoteName && remoteUrl ? { remoteName, remoteUrl } : null;\n}\n\nfunction buildRepositoryIdentity(input: {\n  readonly remoteName: string;\n  readonly remoteUrl: string;\n  readonly rootPath: string;\n}): RepositoryIdentity {\n  const canonicalKey = normalizeGitRemoteUrl(input.remoteUrl);\n  const sourceControlProvider = detectSourceControlProviderFromGitRemoteUrl(input.remoteUrl);\n  const repositoryPath = canonicalKey.split(\"/\").slice(1).join(\"/\");\n  const repositoryPathSegments = repositoryPath.split(\"/\").filter((segment) => segment.length > 0);\n  const [owner] = repositoryPathSegments;\n  const repositoryName = repositoryPathSegments.at(-1);\n\n  return {\n    canonicalKey,\n    locator: {\n      source: \"git-remote\",\n      remoteName: input.remoteName,\n      remoteUrl: input.remoteUrl,\n    },\n    rootPath: input.rootPath,\n    ...(repositoryPath ? { displayName: repositoryPath } : {}),\n    ...(sourceControlProvider ? { provider: sourceControlProvider.kind } : {}),\n    ...(owner ? { owner } : {}),\n    ...(repositoryName ? { name: repositoryName } : {}),\n  };\n}\n\nconst resolveRepositoryIdentityCacheKey = Effect.fn(\"RepositoryIdentityResolver.resolveCacheKey\")(\n  function* (cwd: string) {\n    const processRunner = yield* ProcessRunner.ProcessRunner;\n    let cacheKey = cwd;\n\n    // git is a real executable on every platform — no cmd.exe shell mode, which\n    // would split paths containing spaces during cmd's re-tokenization.\n    const topLevelResult = yield* processRunner\n      .run({\n        command: \"git\",\n        args: [\"-C\", cwd, \"rev-parse\", \"--show-toplevel\"],\n        timeoutBehavior: \"timedOutResult\",\n      })\n      .pipe(Effect.option);\n    if (topLevelResult._tag === \"None\" || topLevelResult.value.code !== 0) {\n      return cacheKey;\n    }\n\n    const candidate = topLevelResult.value.stdout.trim();\n    if (candidate.length > 0) {\n      cacheKey = candidate;\n    }\n\n    return cacheKey;\n  },\n);\n\nconst resolveRepositoryIdentityFromCacheKey = Effect.fn(\n  \"RepositoryIdentityResolver.resolveFromCacheKey\",\n)(function* (\n  cacheKey: string,\n): Effect.fn.Return<RepositoryIdentity | null, never, ProcessRunner.ProcessRunner> {\n  const processRunner = yield* ProcessRunner.ProcessRunner;\n  const remoteResult = yield* processRunner\n    .run({\n      command: \"git\",\n      args: [\"-C\", cacheKey, \"remote\", \"-v\"],\n      timeoutBehavior: \"timedOutResult\",\n    })\n    .pipe(Effect.option);\n  if (remoteResult._tag === \"None\" || remoteResult.value.code !== 0) {\n    return null;\n  }\n\n  const remote = pickPrimaryRemote(parseRemoteFetchUrls(remoteResult.value.stdout));\n  return remote ? buildRepositoryIdentity({ ...remote, rootPath: cacheKey }) : null;\n});\n\nexport const make = Effect.fn(\"RepositoryIdentityResolver.make\")(function* (\n  options: RepositoryIdentityResolverOptions = {},\n) {\n  const processRunner = yield* ProcessRunner.ProcessRunner;\n\n  const repositoryIdentityCache = yield* Cache.makeWith<string, RepositoryIdentity | null>(\n    (cacheKey) =>\n      resolveRepositoryIdentityFromCacheKey(cacheKey).pipe(\n        Effect.provideService(ProcessRunner.ProcessRunner, processRunner),\n      ),\n    {\n      capacity: options.cacheCapacity ?? DEFAULT_REPOSITORY_IDENTITY_CACHE_CAPACITY,\n      timeToLive: Exit.match({\n        onSuccess: (value) =>\n          value === null\n            ? (options.negativeCacheTtl ?? DEFAULT_NEGATIVE_CACHE_TTL)\n            : (options.positiveCacheTtl ?? DEFAULT_POSITIVE_CACHE_TTL),\n        onFailure: () => Duration.zero,\n      }),\n    },\n  );\n\n  const resolve: RepositoryIdentityResolver[\"Service\"][\"resolve\"] = Effect.fn(\n    \"RepositoryIdentityResolver.resolve\",\n  )(function* (cwd) {\n    const cacheKey = yield* resolveRepositoryIdentityCacheKey(cwd).pipe(\n      Effect.provideService(ProcessRunner.ProcessRunner, processRunner),\n    );\n    return yield* Cache.get(repositoryIdentityCache, cacheKey);",
    "checksum": "4a4f8be0eeff3ff2856b99be1dc3e109597f73ef9dfb6c89fb54aef34a4f6fff"
  },
  "project-identity-read-projection": {
    "id": "project-identity-read-projection",
    "path": "apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts",
    "start": 313,
    "end": 388,
    "language": "typescript",
    "label": "Snapshot-time repository identity enrichment",
    "code": "function mapProjectShellRow(\n  row: Schema.Schema.Type<typeof ProjectionProjectDbRowSchema>,\n  repositoryIdentity: OrchestrationProject[\"repositoryIdentity\"],\n): OrchestrationProjectShell {\n  return {\n    id: row.projectId,\n    title: row.title,\n    workspaceRoot: row.workspaceRoot,\n    repositoryIdentity,\n    defaultModelSelection: row.defaultModelSelection,\n    defaultThreadEnvMode: row.defaultThreadEnvMode,\n    faviconPath: row.faviconPath ?? null,\n    scripts: row.scripts,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n\nfunction mapProposedPlanRow(\n  row: Schema.Schema.Type<typeof ProjectionThreadProposedPlanDbRowSchema>,\n): OrchestrationProposedPlan {\n  return {\n    id: row.planId,\n    turnId: row.turnId,\n    planMarkdown: row.planMarkdown,\n    implementedAt: row.implementedAt,\n    implementationThreadId: row.implementationThreadId,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n\nfunction toPersistenceSqlOrDecodeError(sqlOperation: string, decodeOperation: string) {\n  return (cause: unknown): ProjectionRepositoryError =>\n    Schema.isSchemaError(cause)\n      ? toPersistenceDecodeError(decodeOperation)(cause)\n      : toPersistenceSqlError(sqlOperation)(cause);\n}\n\nconst makeProjectionSnapshotQuery = Effect.gen(function* () {\n  const threadBackgroundLiveness = yield* ThreadBackgroundLivenessService;\n  const threadPlanProgress = yield* ThreadPlanProgressService;\n  const sql = yield* SqlClient.SqlClient;\n  const repositoryIdentityResolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver;\n  const repositoryIdentityResolutionConcurrency = 4;\n  const resolveRepositoryIdentitiesForProjects = Effect.fn(\n    \"ProjectionSnapshotQuery.resolveRepositoryIdentitiesForProjects\",\n  )(function* (\n    projectRows: ReadonlyArray<Schema.Schema.Type<typeof ProjectionProjectDbRowSchema>>,\n    options?: {\n      readonly includeDeleted?: boolean;\n    },\n  ) {\n    const filteredProjectRows =\n      options?.includeDeleted === true\n        ? projectRows\n        : projectRows.filter((row) => row.deletedAt === null);\n    const uniqueWorkspaceRoots = [...new Set(filteredProjectRows.map((row) => row.workspaceRoot))];\n    const repositoryIdentityByWorkspaceRoot = new Map(\n      yield* Effect.forEach(\n        uniqueWorkspaceRoots,\n        (workspaceRoot) =>\n          repositoryIdentityResolver\n            .resolve(workspaceRoot)\n            .pipe(Effect.map((identity) => [workspaceRoot, identity] as const)),\n        { concurrency: repositoryIdentityResolutionConcurrency },\n      ),\n    );\n\n    return new Map(\n      filteredProjectRows.map((row) => [\n        row.projectId,\n        repositoryIdentityByWorkspaceRoot.get(row.workspaceRoot) ?? null,\n      ]),\n    );\n  });",
    "checksum": "7d141cd37e227fc76fc88c9537c8bb8dd65842f91b9e2ec7fdec540a2913c122"
  },
  "project-durable-projection": {
    "id": "project-durable-projection",
    "path": "apps/server/src/orchestration/decider.ts",
    "start": 227,
    "end": 298,
    "language": "typescript",
    "label": "Project creation and metadata event decisions",
    "code": "    case \"project.create\": {\n      yield* requireProjectAbsent({\n        readModel,\n        command,\n        projectId: command.projectId,\n      });\n      yield* requireActiveProjectWorkspaceRootAbsent({\n        readModel,\n        command,\n        workspaceRoot: command.workspaceRoot,\n        exceptProjectId: command.projectId,\n      });\n\n      return {\n        ...(yield* withEventBase({\n          aggregateKind: \"project\",\n          aggregateId: command.projectId,\n          occurredAt: command.createdAt,\n          commandId: command.commandId,\n        })),\n        type: \"project.created\",\n        payload: {\n          projectId: command.projectId,\n          title: command.title,\n          workspaceRoot: command.workspaceRoot,\n          defaultModelSelection: command.defaultModelSelection ?? null,\n          faviconPath: null,\n          scripts: [],\n          createdAt: command.createdAt,\n          updatedAt: command.createdAt,\n        },\n      };\n    }\n\n    case \"project.meta.update\": {\n      yield* requireProject({\n        readModel,\n        command,\n        projectId: command.projectId,\n      });\n      if (command.workspaceRoot !== undefined) {\n        yield* requireActiveProjectWorkspaceRootAbsent({\n          readModel,\n          command,\n          workspaceRoot: command.workspaceRoot,\n          exceptProjectId: command.projectId,\n        });\n      }\n      const occurredAt = yield* nowIso;\n      return {\n        ...(yield* withEventBase({\n          aggregateKind: \"project\",\n          aggregateId: command.projectId,\n          occurredAt,\n          commandId: command.commandId,\n        })),\n        type: \"project.meta-updated\",\n        payload: {\n          projectId: command.projectId,\n          ...(command.title !== undefined ? { title: command.title } : {}),\n          ...(command.workspaceRoot !== undefined ? { workspaceRoot: command.workspaceRoot } : {}),\n          ...(command.defaultModelSelection !== undefined\n            ? { defaultModelSelection: command.defaultModelSelection }\n            : {}),\n          ...(command.defaultThreadEnvMode !== undefined\n            ? { defaultThreadEnvMode: command.defaultThreadEnvMode }\n            : {}),\n          ...(command.faviconPath !== undefined ? { faviconPath: command.faviconPath } : {}),\n          ...(command.scripts !== undefined ? { scripts: command.scripts } : {}),\n          updatedAt: occurredAt,\n        },\n      };",
    "checksum": "e788184b10630834970883f5f18d9c6b555e7ecc2993eaedf944acaf4afddf0b"
  },
  "project-projector": {
    "id": "project-projector",
    "path": "apps/server/src/orchestration/projector.ts",
    "start": 207,
    "end": 263,
    "language": "typescript",
    "label": "Durable project read-model projection",
    "code": "  switch (event.type) {\n    case \"project.created\":\n      return decodeForEvent(ProjectCreatedPayload, event.payload, event.type, \"payload\").pipe(\n        Effect.map((payload) => {\n          const existing = nextBase.projects.find((entry) => entry.id === payload.projectId);\n          const nextProject = {\n            id: payload.projectId,\n            title: payload.title,\n            workspaceRoot: payload.workspaceRoot,\n            defaultModelSelection: payload.defaultModelSelection,\n            defaultThreadEnvMode: null,\n            faviconPath: payload.faviconPath ?? null,\n            scripts: payload.scripts,\n            createdAt: payload.createdAt,\n            updatedAt: payload.updatedAt,\n            deletedAt: null,\n          };\n\n          return {\n            ...nextBase,\n            projects: existing\n              ? nextBase.projects.map((entry) =>\n                  entry.id === payload.projectId ? nextProject : entry,\n                )\n              : [...nextBase.projects, nextProject],\n          };\n        }),\n      );\n\n    case \"project.meta-updated\":\n      return decodeForEvent(ProjectMetaUpdatedPayload, event.payload, event.type, \"payload\").pipe(\n        Effect.map((payload) => ({\n          ...nextBase,\n          projects: nextBase.projects.map((project) =>\n            project.id === payload.projectId\n              ? {\n                  ...project,\n                  ...(payload.title !== undefined ? { title: payload.title } : {}),\n                  ...(payload.workspaceRoot !== undefined\n                    ? { workspaceRoot: payload.workspaceRoot }\n                    : {}),\n                  ...(payload.defaultModelSelection !== undefined\n                    ? { defaultModelSelection: payload.defaultModelSelection }\n                    : {}),\n                  ...(payload.defaultThreadEnvMode !== undefined\n                    ? { defaultThreadEnvMode: payload.defaultThreadEnvMode }\n                    : {}),\n                  ...(payload.faviconPath !== undefined\n                    ? { faviconPath: payload.faviconPath }\n                    : {}),\n                  ...(payload.scripts !== undefined ? { scripts: payload.scripts } : {}),\n                  updatedAt: payload.updatedAt,\n                }\n              : project,\n          ),\n        })),\n      );",
    "checksum": "729a2f33d9502369b95c9f126893ba31605baac1c1ae7f5ecfabadb71399f48e"
  },
  "project-logical-grouping": {
    "id": "project-logical-grouping",
    "path": "packages/client-runtime/src/state/projectGrouping.ts",
    "start": 67,
    "end": 140,
    "language": "typescript",
    "label": "Client-side physical and logical project grouping",
    "code": "export function derivePhysicalProjectKeyFromPath(environmentId: string, cwd: string): string {\n  return `${environmentId}:${normalizeProjectPathForComparison(cwd)}`;\n}\n\nexport function derivePhysicalProjectKey(\n  project: Pick<EnvironmentProject, \"environmentId\" | \"workspaceRoot\">,\n): string {\n  return derivePhysicalProjectKeyFromPath(project.environmentId, project.workspaceRoot);\n}\n\nexport function deriveProjectGroupingOverrideKey(\n  project: Pick<EnvironmentProject, \"environmentId\" | \"workspaceRoot\">,\n): string {\n  return derivePhysicalProjectKey(project);\n}\n\nexport function getProjectOrderKey(\n  project: Pick<EnvironmentProject, \"environmentId\" | \"workspaceRoot\">,\n): string {\n  return derivePhysicalProjectKey(project);\n}\n\nexport function resolveProjectGroupingMode(\n  project: Pick<EnvironmentProject, \"environmentId\" | \"workspaceRoot\">,\n  settings: ProjectGroupingSettings,\n): SidebarProjectGroupingMode {\n  return (\n    settings.sidebarProjectGroupingOverrides?.[deriveProjectGroupingOverrideKey(project)] ??\n    settings.sidebarProjectGroupingMode\n  );\n}\n\nfunction deriveRepositoryScopedKey(\n  project: Pick<EnvironmentProject, \"workspaceRoot\" | \"repositoryIdentity\">,\n  groupingMode: SidebarProjectGroupingMode,\n): string | null {\n  const canonicalKey = project.repositoryIdentity?.canonicalKey;\n  if (!canonicalKey) {\n    return null;\n  }\n\n  if (groupingMode === \"repository\") {\n    return canonicalKey;\n  }\n\n  const relativeProjectPath = deriveRepositoryRelativeProjectPath(project);\n  if (relativeProjectPath === null) {\n    return canonicalKey;\n  }\n\n  return relativeProjectPath.length === 0\n    ? canonicalKey\n    : `${canonicalKey}::${relativeProjectPath}`;\n}\n\nexport function deriveLogicalProjectKey(\n  project: Pick<\n    EnvironmentProject,\n    \"environmentId\" | \"id\" | \"workspaceRoot\" | \"repositoryIdentity\"\n  >,\n  options?: {\n    readonly groupingMode?: SidebarProjectGroupingMode;\n  },\n): string {\n  const groupingMode = options?.groupingMode ?? \"repository\";\n  if (groupingMode === \"separate\") {\n    return derivePhysicalProjectKey(project);\n  }\n\n  return (\n    deriveRepositoryScopedKey(project, groupingMode) ??\n    derivePhysicalProjectKey(project) ??\n    scopedProjectKey(scopeProjectRef(project.environmentId, project.id))\n  );",
    "checksum": "5dba3332ba0509524b5efd5bf70acdb14f099330583ae7878ae53a7bde32ed95"
  },
  "project-environment-label": {
    "id": "project-environment-label",
    "path": "apps/web/src/sidebarProjectGrouping.ts",
    "start": 53,
    "end": 115,
    "language": "typescript",
    "label": "Environment labels retained in grouped sidebar projects",
    "code": "export function buildSidebarProjectSnapshots(input: {\n  projects: ReadonlyArray<Project>;\n  settings: ProjectGroupingSettings;\n  primaryEnvironmentId: EnvironmentId | null;\n  resolveEnvironmentLabel: (environmentId: EnvironmentId) => string | null;\n  // Returns true when an env id maps to a desktopLocal saved-env\n  // record (today: the WSL backend). Defaults to \"false for every\n  // env\" so callers that don't care about the distinction get the\n  // legacy behavior.\n  isDesktopLocalEnvironment?: (environmentId: EnvironmentId) => boolean;\n}): SidebarProjectSnapshot[] {\n  return buildProjectGroups({\n    projects: input.projects,\n    settings: input.settings,\n    preferredEnvironmentId: input.primaryEnvironmentId,\n  }).map((group): SidebarProjectSnapshot => {\n    const members = group.members.map(\n      ({ physicalProjectKey, project }): SidebarProjectGroupMember => ({\n        ...project,\n        physicalProjectKey,\n        environmentLabel: input.resolveEnvironmentLabel(project.environmentId),\n      }),\n    );\n    const representative =\n      members.find(\n        (member) =>\n          member.environmentId === group.representative.environmentId &&\n          member.id === group.representative.id,\n      ) ?? members[0]!;\n\n    const hasLocal =\n      input.primaryEnvironmentId !== null &&\n      members.some((member) => member.environmentId === input.primaryEnvironmentId);\n    const hasRemote =\n      input.primaryEnvironmentId !== null\n        ? members.some((member) => member.environmentId !== input.primaryEnvironmentId)\n        : false;\n    const remoteMembers = members.filter(\n      (member) =>\n        input.primaryEnvironmentId !== null && member.environmentId !== input.primaryEnvironmentId,\n    );\n    const remoteEnvironmentLabels = remoteMembers\n      .flatMap((member) => (member.environmentLabel ? [member.environmentLabel] : []))\n      .filter((label, index, labels) => labels.indexOf(label) === index);\n    const isDesktopLocal = input.isDesktopLocalEnvironment ?? (() => false);\n    const allRemoteMembersAreDesktopLocal =\n      remoteMembers.length > 0 &&\n      remoteMembers.every((member) => isDesktopLocal(member.environmentId));\n\n    return {\n      ...representative,\n      projectKey: group.key,\n      displayName: group.label,\n      groupedProjectCount: members.length,\n      environmentPresence:\n        hasLocal && hasRemote ? \"mixed\" : hasRemote ? \"remote-only\" : \"local-only\",\n      allRemoteMembersAreDesktopLocal,\n      memberProjects: members,\n      memberProjectRefs: group.memberProjectRefs,\n      remoteEnvironmentLabels,\n    };\n  });\n}",
    "checksum": "991d462dd85ddad3333fca1606c7beac65a41aa4b90282ba4794991ef9e2fb6e"
  },
  "project-setup-script-selection": {
    "id": "project-setup-script-selection",
    "path": "packages/shared/src/projectScripts.ts",
    "start": 11,
    "end": 37,
    "language": "typescript",
    "label": "Worktree setup-script selection and environment construction",
    "code": "export function projectScriptCwd(input: {\n  project: {\n    cwd: string;\n  };\n  worktreePath?: string | null;\n}): string {\n  return input.worktreePath ?? input.project.cwd;\n}\n\nexport function projectScriptRuntimeEnv(\n  input: ProjectScriptRuntimeEnvInput,\n): Record<string, string> {\n  const env: Record<string, string> = {\n    T3CODE_PROJECT_ROOT: input.project.cwd,\n  };\n  if (input.worktreePath) {\n    env.T3CODE_WORKTREE_PATH = input.worktreePath;\n  }\n  if (input.extraEnv) {\n    return { ...env, ...input.extraEnv };\n  }\n  return env;\n}\n\nexport function setupProjectScript(scripts: readonly ProjectScript[]): ProjectScript | null {\n  return scripts.find((script) => script.runOnWorktreeCreate) ?? null;\n}",
    "checksum": "78e76784914a8a10cc610f1b31943af278b003d98790ddffe5243b8ddeb8f7d8"
  },
  "project-setup-script-runner": {
    "id": "project-setup-script-runner",
    "path": "apps/server/src/project/ProjectSetupScriptRunner.ts",
    "start": 123,
    "end": 183,
    "language": "typescript",
    "label": "Setup script launched in the linked worktree terminal",
    "code": "    if (!project) {\n      return yield* new ProjectSetupScriptProjectNotFoundError(errorContext);\n    }\n\n    const script = setupProjectScript(project.scripts);\n    if (!script) {\n      return {\n        status: \"no-script\",\n      } as const;\n    }\n\n    const terminalId = input.preferredTerminalId ?? `setup-${script.id}`;\n    const cwd = input.worktreePath;\n    const env = projectScriptRuntimeEnv({\n      project: { cwd: project.workspaceRoot },\n      worktreePath: input.worktreePath,\n    });\n\n    yield* terminalManager\n      .open({\n        threadId: input.threadId,\n        terminalId,\n        cwd,\n        worktreePath: input.worktreePath,\n        env,\n      })\n      .pipe(\n        Effect.mapError(\n          (cause) =>\n            new ProjectSetupScriptOperationError({\n              ...errorContext,\n              operation: \"openTerminal\",\n              cause,\n            }),\n        ),\n      );\n    yield* terminalManager\n      .write({\n        threadId: input.threadId,\n        terminalId,\n        data: `${script.command}\\r`,\n      })\n      .pipe(\n        Effect.mapError(\n          (cause) =>\n            new ProjectSetupScriptOperationError({\n              ...errorContext,\n              operation: \"writeCommand\",\n              cause,\n            }),\n        ),\n      );\n\n    return {\n      status: \"started\",\n      scriptId: script.id,\n      scriptName: script.name,\n      terminalId,\n      cwd,\n    } as const;\n  });",
    "checksum": "cff81f3c6730404adcbbfda69be3407b3d365eda8730a8f780e36b80a0fe2395"
  },
  "worktree-non-git-fallback": {
    "id": "worktree-non-git-fallback",
    "path": "apps/web/src/components/ChatView.logic.ts",
    "start": 322,
    "end": 327,
    "language": "typescript",
    "label": "Non-Git projects fall back from worktree to local mode",
    "code": "export function resolveSendEnvMode(input: {\n  requestedEnvMode: DraftThreadEnvMode;\n  isGitRepo: boolean;\n}): DraftThreadEnvMode {\n  return input.isGitRepo ? input.requestedEnvMode : \"local\";\n}",
    "checksum": "f7e6d7316e8bb7115262ee669771235b851a046fb5943c03ae99edc63a2d8cbd"
  },
  "worktree-ref-occupancy": {
    "id": "worktree-ref-occupancy",
    "path": "apps/server/src/vcs/GitVcsDriverCore.ts",
    "start": 2463,
    "end": 2559,
    "language": "typescript",
    "label": "Git worktree listing decorates occupied branch references",
    "code": "  const readGitRefsSnapshot = Effect.fn(\"readGitRefsSnapshot\")(function* (gitCommonDir: string) {\n    const fetchCwd =\n      path.basename(gitCommonDir) === \".git\" ? path.dirname(gitCommonDir) : gitCommonDir;\n    const gitDirArgs = [\"--git-dir\", gitCommonDir] as const;\n    const [refsResult, defaultRefResult, worktreeListResult, remoteNamesResult] = yield* Effect.all(\n      [\n        executeGitWithStableDiagnostics(\n          \"GitVcsDriver.listRefs.snapshotRefs\",\n          fetchCwd,\n          [\n            ...gitDirArgs,\n            \"for-each-ref\",\n            \"--format=%(refname)%09%(committerdate:unix)%09%(symref)\",\n            \"refs/heads\",\n            \"refs/remotes\",\n          ],\n          {\n            timeoutMs: 30_000,\n            maxOutputBytes: 16 * 1024 * 1024,\n            fallbackErrorDetail: \"Git ref snapshot enumeration failed.\",\n          },\n        ),\n        executeGit(\n          \"GitVcsDriver.listRefs.defaultRef\",\n          fetchCwd,\n          [...gitDirArgs, \"symbolic-ref\", \"refs/remotes/origin/HEAD\"],\n          {\n            timeoutMs: 5_000,\n            allowNonZeroExit: true,\n          },\n        ),\n        executeGit(\n          \"GitVcsDriver.listRefs.worktreeList\",\n          fetchCwd,\n          [...gitDirArgs, \"worktree\", \"list\", \"--porcelain\", \"-z\"],\n          {\n            timeoutMs: 30_000,\n            allowNonZeroExit: true,\n            maxOutputBytes: 16 * 1024 * 1024,\n          },\n        ),\n        executeGit(\"GitVcsDriver.listRefs.remoteNames\", fetchCwd, [...gitDirArgs, \"remote\"], {\n          timeoutMs: 5_000,\n          allowNonZeroExit: true,\n        }),\n      ],\n      { concurrency: 2 },\n    );\n\n    const remoteNames =\n      remoteNamesResult.exitCode === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];\n    if (remoteNamesResult.exitCode !== 0 && remoteNamesResult.stderr.trim().length > 0) {\n      yield* Effect.logWarning(\n        `GitVcsDriver.listRefs: remote name lookup returned code ${remoteNamesResult.exitCode} for ${gitCommonDir}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,\n      );\n    }\n    const defaultBranch =\n      defaultRefResult.exitCode === 0\n        ? defaultRefResult.stdout.trim().replace(/^refs\\/remotes\\/origin\\//, \"\")\n        : null;\n    const parsedWorktreeEntries =\n      worktreeListResult.exitCode === 0\n        ? [...parseWorktreeBranchPaths(worktreeListResult.stdout)].map(\n            ([branchName, worktreePath]) =>\n              [branchName, path.normalize(path.resolve(worktreePath))] as const,\n          )\n        : [];\n    const existingWorktreeEntries = yield* Effect.filter(\n      parsedWorktreeEntries,\n      ([, worktreePath]) =>\n        fileSystem.stat(worktreePath).pipe(\n          Effect.as(true),\n          Effect.orElseSucceed(() => false),\n        ),\n      { concurrency: 16 },\n    );\n    const worktreeMap = new Map(existingWorktreeEntries);\n    const localBranches: Array<{ readonly ref: VcsRef; readonly lastCommit: number }> = [];\n    const remoteBranches: Array<{ readonly ref: VcsRef; readonly lastCommit: number }> = [];\n\n    for (const line of refsResult.stdout.split(\"\\n\")) {\n      if (line.length === 0) continue;\n      const [fullRefName, lastCommitRaw, symbolicTarget] = line.split(\"\\t\");\n      if (!fullRefName || symbolicTarget) continue;\n      const parsedLastCommit = Number.parseInt(lastCommitRaw ?? \"0\", 10);\n      const lastCommit = Number.isFinite(parsedLastCommit) ? parsedLastCommit : 0;\n\n      if (fullRefName.startsWith(\"refs/heads/\")) {\n        const name = fullRefName.slice(\"refs/heads/\".length);\n        localBranches.push({\n          ref: {\n            name,\n            current: false,\n            isRemote: false,\n            isDefault: name === defaultBranch,\n            worktreePath: worktreeMap.get(name) ?? null,\n          },",
    "checksum": "0d568abc710d939aac21b967910cb9bd479b61ebd13ad26bcbc87c919cac7743"
  },
  "worktree-create-remove-contract": {
    "id": "worktree-create-remove-contract",
    "path": "packages/contracts/src/git.ts",
    "start": 124,
    "end": 165,
    "language": "typescript",
    "label": "Worktree creation and removal RPC inputs",
    "code": "export const VcsListRefsInput = Schema.Struct({\n  cwd: TrimmedNonEmptyStringSchema,\n  query: Schema.optional(TrimmedNonEmptyStringSchema.check(Schema.isMaxLength(256))),\n  cursor: Schema.optional(NonNegativeInt),\n  includeMatchingRemoteRefs: Schema.optional(Schema.Boolean),\n  refKind: Schema.optional(Schema.Literals([\"all\", \"local\", \"remote\"])),\n  refresh: Schema.optional(Schema.Boolean),\n  limit: Schema.optional(\n    PositiveInt.check(Schema.isLessThanOrEqualTo(GIT_LIST_BRANCHES_MAX_LIMIT)),\n  ),\n});\nexport type VcsListRefsInput = typeof VcsListRefsInput.Type;\n\nexport const VcsCreateWorktreeInput = Schema.Struct({\n  cwd: TrimmedNonEmptyStringSchema,\n  refName: TrimmedNonEmptyStringSchema,\n  newRefName: Schema.optional(TrimmedNonEmptyStringSchema),\n  baseRefName: Schema.optional(TrimmedNonEmptyStringSchema),\n  path: Schema.NullOr(TrimmedNonEmptyStringSchema),\n});\nexport type VcsCreateWorktreeInput = typeof VcsCreateWorktreeInput.Type;\n\nexport const GitPullRequestRefInput = Schema.Struct({\n  cwd: TrimmedNonEmptyStringSchema,\n  reference: GitPullRequestReference,\n});\nexport type GitPullRequestRefInput = typeof GitPullRequestRefInput.Type;\n\nexport const GitPreparePullRequestThreadInput = Schema.Struct({\n  cwd: TrimmedNonEmptyStringSchema,\n  reference: GitPullRequestReference,\n  mode: GitPreparePullRequestThreadMode,\n  threadId: Schema.optional(ThreadId),\n});\nexport type GitPreparePullRequestThreadInput = typeof GitPreparePullRequestThreadInput.Type;\n\nexport const VcsRemoveWorktreeInput = Schema.Struct({\n  cwd: TrimmedNonEmptyStringSchema,\n  path: TrimmedNonEmptyStringSchema,\n  force: Schema.optional(Schema.Boolean),\n});\nexport type VcsRemoveWorktreeInput = typeof VcsRemoveWorktreeInput.Type;",
    "checksum": "38f837fcc1bd73ea692ff819c248771f4eba476d0336357698d09ffdfa20bad2"
  },
  "worktree-result-contract": {
    "id": "worktree-result-contract",
    "path": "packages/contracts/src/git.ts",
    "start": 264,
    "end": 294,
    "language": "typescript",
    "label": "Worktree and pull-request preparation results",
    "code": "export const VcsListRefsResult = Schema.Struct({\n  refs: Schema.Array(VcsRef),\n  isRepo: Schema.Boolean,\n  hasPrimaryRemote: Schema.Boolean,\n  nextCursor: NonNegativeInt.pipe(Schema.NullOr),\n  totalCount: NonNegativeInt,\n});\nexport type VcsListRefsResult = typeof VcsListRefsResult.Type;\n\nexport const VcsCreateWorktreeResult = Schema.Struct({\n  worktree: VcsWorktree,\n});\nexport type VcsCreateWorktreeResult = typeof VcsCreateWorktreeResult.Type;\n\nexport const GitResolvePullRequestResult = Schema.Struct({\n  pullRequest: GitResolvedPullRequest,\n});\nexport type GitResolvePullRequestResult = typeof GitResolvePullRequestResult.Type;\n\nexport const GitPreparePullRequestThreadResult = Schema.Struct({\n  pullRequest: GitResolvedPullRequest,\n  branch: TrimmedNonEmptyStringSchema,\n  worktreePath: TrimmedNonEmptyStringSchema.pipe(Schema.NullOr),\n  /**\n   * False when the checkout could not be brought to the pull request head — a reused worktree\n   * holding local commits or uncommitted changes keeps its own state, so the code being handed\n   * over is older than the pull request.\n   */\n  isOnPullRequestHead: Schema.Boolean,\n});\nexport type GitPreparePullRequestThreadResult = typeof GitPreparePullRequestThreadResult.Type;",
    "checksum": "be9e1709dcb7b1c171e5a679852c15f2b5e16949f1bde705f05f5d01086a63ee"
  },
  "worktree-bootstrap-path": {
    "id": "worktree-bootstrap-path",
    "path": "apps/server/src/ws.ts",
    "start": 979,
    "end": 1022,
    "language": "typescript",
    "label": "Origin-aware worktree bootstrap saga",
    "code": "            if (bootstrap?.prepareWorktree) {\n              let worktreeBaseRef = bootstrap.prepareWorktree.baseBranch;\n              // \"Start from origin\" is a stored default; repos without an\n              // origin remote fall back to the local base branch instead of\n              // failing the whole bootstrap on `git fetch origin`.\n              const startFromOrigin =\n                bootstrap.prepareWorktree.startFromOrigin === true &&\n                (yield* gitWorkflow.remoteExists({\n                  cwd: bootstrap.prepareWorktree.projectCwd,\n                  remoteName: \"origin\",\n                }));\n              if (startFromOrigin) {\n                yield* gitWorkflow.fetchRemote({\n                  cwd: bootstrap.prepareWorktree.projectCwd,\n                  remoteName: \"origin\",\n                });\n                const resolvedRemoteBase = yield* gitWorkflow.resolveRemoteTrackingCommit({\n                  cwd: bootstrap.prepareWorktree.projectCwd,\n                  refName: bootstrap.prepareWorktree.baseBranch,\n                  fallbackRemoteName: \"origin\",\n                });\n                worktreeBaseRef = resolvedRemoteBase.commitSha;\n              }\n              const worktree = yield* gitWorkflow.createWorktree({\n                cwd: bootstrap.prepareWorktree.projectCwd,\n                refName: worktreeBaseRef,\n                newRefName: bootstrap.prepareWorktree.branch,\n                baseRefName: bootstrap.prepareWorktree.baseBranch,\n                path: null,\n              });\n              targetWorktreePath = worktree.worktree.path;\n              yield* dispatchFromClient({\n                type: \"thread.meta.update\",\n                commandId: yield* serverCommandId(\"bootstrap-thread-meta-update\"),\n                threadId: command.threadId,\n                branch: worktree.worktree.refName,\n                worktreePath: targetWorktreePath,\n              });\n              yield* refreshGitStatus(targetWorktreePath);\n            }\n\n            yield* runSetupProgram();\n\n            return yield* dispatchFromClient(finalTurnStartCommand);",
    "checksum": "d243bf017c0fece3cfeca6fcec59f80633bae6e4358beecd85c6afdff52e31c1"
  },
  "worktree-origin-base-test": {
    "id": "worktree-origin-base-test",
    "path": "apps/server/src/vcs/GitVcsDriverCore.test.ts",
    "start": 1505,
    "end": 1565,
    "language": "typescript",
    "label": "Remote base reference worktree creation test",
    "code": "    it.effect(\"creates a worktree from the latest fetched remote commit\", () =>\n      Effect.gen(function* () {\n        const cwd = yield* makeTmpDir();\n        const remote = yield* makeTmpDir(\"git-remote-\");\n        const peer = yield* makeTmpDir(\"git-peer-\");\n        const { initialBranch } = yield* initRepoWithCommit(cwd);\n        yield* git(remote, [\"init\", \"--bare\"]);\n        yield* git(cwd, [\"remote\", \"add\", \"origin\", remote]);\n        yield* git(cwd, [\"push\", \"-u\", \"origin\", initialBranch]);\n        yield* git(remote, [\"symbolic-ref\", \"HEAD\", `refs/heads/${initialBranch}`]);\n        const beforeFetch = yield* git(cwd, [\"rev-parse\", `refs/remotes/origin/${initialBranch}`]);\n\n        yield* git(peer, [\"clone\", remote, \".\"]);\n        yield* git(peer, [\"config\", \"user.email\", \"test@test.com\"]);\n        yield* git(peer, [\"config\", \"user.name\", \"Test\"]);\n        yield* writeTextFile(peer, \"remote-change.txt\", \"remote\\n\");\n        yield* git(peer, [\"add\", \"remote-change.txt\"]);\n        yield* git(peer, [\"commit\", \"-m\", \"remote change\"]);\n        yield* git(peer, [\"push\", \"origin\", initialBranch]);\n        const remoteHead = yield* git(peer, [\"rev-parse\", \"HEAD\"]);\n        assert.notEqual(beforeFetch, remoteHead);\n\n        const driver = yield* GitVcsDriver.GitVcsDriver;\n        yield* driver.fetchRemote({ cwd, remoteName: \"origin\" });\n\n        const resolvedBase = yield* driver.resolveRemoteTrackingCommit({\n          cwd,\n          refName: initialBranch,\n          fallbackRemoteName: \"origin\",\n        });\n        const explicitlyResolvedBase = yield* driver.resolveRemoteTrackingCommit({\n          cwd,\n          refName: `origin/${initialBranch}`,\n          fallbackRemoteName: \"origin\",\n        });\n\n        assert.deepEqual(resolvedBase, {\n          commitSha: remoteHead,\n          remoteRefName: `origin/${initialBranch}`,\n        });\n        assert.deepEqual(explicitlyResolvedBase, resolvedBase);\n        assert.equal(yield* git(cwd, [\"rev-parse\", initialBranch]), beforeFetch);\n\n        const pathService = yield* Path.Path;\n        const worktreePath = pathService.join(\n          yield* makeTmpDir(\"git-fetched-worktrees-\"),\n          \"fetched-origin\",\n        );\n        yield* driver.createWorktree({\n          cwd,\n          path: worktreePath,\n          refName: resolvedBase.commitSha,\n          newRefName: \"t3code/fetched-origin\",\n          baseRefName: resolvedBase.remoteRefName,\n        });\n\n        assert.equal(yield* git(worktreePath, [\"rev-parse\", \"HEAD\"]), remoteHead);\n        assert.equal(\n          yield* driver.readConfigValue(worktreePath, \"branch.t3code/fetched-origin.gh-merge-base\"),\n          initialBranch,\n        );",
    "checksum": "3079485524aec02260b358299da023b6dda92f6b257cd7abe203530cca242022"
  },
  "worktree-create-command": {
    "id": "worktree-create-command",
    "path": "apps/server/src/vcs/GitVcsDriverCore.ts",
    "start": 2763,
    "end": 2799,
    "language": "typescript",
    "label": "Git worktree add command and default linked path",
    "code": "  const createWorktree: GitVcsDriver.GitVcsDriver[\"Service\"][\"createWorktree\"] = Effect.fn(\n    \"createWorktree\",\n  )(function* (input) {\n    const targetBranch = input.newRefName ?? input.refName;\n    const sanitizedBranch = targetBranch.replace(/\\//g, \"-\");\n    const repoName = path.basename(input.cwd);\n    const worktreePath = input.path ?? path.join(worktreesDir, repoName, sanitizedBranch);\n    const args = input.newRefName\n      ? [\"worktree\", \"add\", \"-b\", input.newRefName, worktreePath, input.refName]\n      : [\"worktree\", \"add\", worktreePath, input.refName];\n\n    yield* executeGit(\"GitVcsDriver.createWorktree\", input.cwd, args, {\n      fallbackErrorDetail: \"git worktree add failed\",\n      timeoutMs: WORKTREE_ADD_TIMEOUT_MS,\n    });\n\n    if (input.newRefName && input.baseRefName) {\n      const remoteNames = yield* listRemoteNames(input.cwd).pipe(Effect.orElseSucceed(() => []));\n      const parsedBaseRef = parseRemoteRefWithRemoteNames(\n        input.baseRefName,\n        remoteNames.toSorted((left, right) => right.length - left.length),\n      );\n      const baseBranch = parsedBaseRef?.branchName ?? input.baseRefName;\n      yield* runGit(\"GitVcsDriver.createWorktree.configureBaseRef\", input.cwd, [\n        \"config\",\n        `branch.${input.newRefName}.gh-merge-base`,\n        baseBranch,\n      ]);\n    }\n\n    return {\n      worktree: {\n        path: worktreePath,\n        refName: targetBranch,\n      },\n    };\n  });",
    "checksum": "4c15353dd8e82554c229e870a3625673d90574db5b6c7ae4396b332f837f61c3"
  },
  "worktree-setup-runner": {
    "id": "worktree-setup-runner",
    "path": "apps/server/src/project/ProjectSetupScriptRunner.ts",
    "start": 123,
    "end": 183,
    "language": "typescript",
    "label": "Post-creation setup script runner",
    "code": "    if (!project) {\n      return yield* new ProjectSetupScriptProjectNotFoundError(errorContext);\n    }\n\n    const script = setupProjectScript(project.scripts);\n    if (!script) {\n      return {\n        status: \"no-script\",\n      } as const;\n    }\n\n    const terminalId = input.preferredTerminalId ?? `setup-${script.id}`;\n    const cwd = input.worktreePath;\n    const env = projectScriptRuntimeEnv({\n      project: { cwd: project.workspaceRoot },\n      worktreePath: input.worktreePath,\n    });\n\n    yield* terminalManager\n      .open({\n        threadId: input.threadId,\n        terminalId,\n        cwd,\n        worktreePath: input.worktreePath,\n        env,\n      })\n      .pipe(\n        Effect.mapError(\n          (cause) =>\n            new ProjectSetupScriptOperationError({\n              ...errorContext,\n              operation: \"openTerminal\",\n              cause,\n            }),\n        ),\n      );\n    yield* terminalManager\n      .write({\n        threadId: input.threadId,\n        terminalId,\n        data: `${script.command}\\r`,\n      })\n      .pipe(\n        Effect.mapError(\n          (cause) =>\n            new ProjectSetupScriptOperationError({\n              ...errorContext,\n              operation: \"writeCommand\",\n              cause,\n            }),\n        ),\n      );\n\n    return {\n      status: \"started\",\n      scriptId: script.id,\n      scriptName: script.name,\n      terminalId,\n      cwd,\n    } as const;\n  });",
    "checksum": "cff81f3c6730404adcbbfda69be3407b3d365eda8730a8f780e36b80a0fe2395"
  },
  "worktree-setup-test": {
    "id": "worktree-setup-test",
    "path": "apps/server/src/project/ProjectSetupScriptRunner.test.ts",
    "start": 93,
    "end": 152,
    "language": "typescript",
    "label": "Setup terminal cwd and environment test",
    "code": "  it.effect(\n    \"opens the deterministic setup terminal with worktree env and writes the command\",\n    () => {\n      const open = vi.fn(() =>\n        Effect.succeed({\n          threadId: \"thread-1\",\n          terminalId: \"setup-setup\",\n          cwd: \"/repo/worktrees/a\",\n          worktreePath: \"/repo/worktrees/a\",\n          status: \"running\" as const,\n          pid: 123,\n          history: \"\",\n          exitCode: null,\n          exitSignal: null,\n          label: \"setup-setup\",\n          updatedAt: \"2026-01-01T00:00:00.000Z\",\n        }),\n      );\n      const write = vi.fn(() => Effect.void);\n      const project = makeProject([\n        {\n          id: \"setup\",\n          name: \"Setup\",\n          command: \"bun install\",\n          icon: \"configure\",\n          runOnWorktreeCreate: true,\n        },\n      ]);\n\n      return Effect.gen(function* () {\n        const runner = yield* ProjectSetupScriptRunner.ProjectSetupScriptRunner;\n        const result = yield* runner.runForThread({\n          threadId: \"thread-1\",\n          projectCwd: \"/repo/project\",\n          worktreePath: \"/repo/worktrees/a\",\n        });\n\n        expect(result).toEqual({\n          status: \"started\",\n          scriptId: \"setup\",\n          scriptName: \"Setup\",\n          terminalId: \"setup-setup\",\n          cwd: \"/repo/worktrees/a\",\n        });\n        expect(open).toHaveBeenCalledWith({\n          threadId: \"thread-1\",\n          terminalId: \"setup-setup\",\n          cwd: \"/repo/worktrees/a\",\n          worktreePath: \"/repo/worktrees/a\",\n          env: {\n            T3CODE_PROJECT_ROOT: \"/repo/project\",\n            T3CODE_WORKTREE_PATH: \"/repo/worktrees/a\",\n          },\n        });\n        expect(write).toHaveBeenCalledWith({\n          threadId: \"thread-1\",\n          terminalId: \"setup-setup\",\n          data: \"bun install\\r\",\n        });\n      }).pipe(Effect.provide(testLayer(project, { open, write })));",
    "checksum": "97cc43e347199b1d18b1a9e4c57bc8933996c2e29b4db41a3d8b700fbf69ffaf"
  },
  "worktree-remove-command": {
    "id": "worktree-remove-command",
    "path": "apps/server/src/vcs/GitVcsDriverCore.ts",
    "start": 2982,
    "end": 2994,
    "language": "typescript",
    "label": "Git worktree removal command",
    "code": "  const removeWorktree: GitVcsDriver.GitVcsDriver[\"Service\"][\"removeWorktree\"] = Effect.fn(\n    \"removeWorktree\",\n  )(function* (input) {\n    const args = [\"worktree\", \"remove\"];\n    if (input.force) {\n      args.push(\"--force\");\n    }\n    args.push(input.path);\n    yield* executeGit(\"GitVcsDriver.removeWorktree\", input.cwd, args, {\n      timeoutMs: 15_000,\n      fallbackErrorDetail: \"git worktree remove failed\",\n    });\n  });",
    "checksum": "af8c3225d2530ef3532d7840a4f688233911c75f8750cb1287777d8a7b4dbf98"
  },
  "worktree-create-remove-test": {
    "id": "worktree-create-remove-test",
    "path": "apps/server/src/vcs/GitVcsDriverCore.test.ts",
    "start": 1377,
    "end": 1403,
    "language": "typescript",
    "label": "Worktree create and remove integration test",
    "code": "    it.effect(\"creates and removes a worktree for a new refName\", () =>\n      Effect.gen(function* () {\n        const cwd = yield* makeTmpDir();\n        const { initialBranch } = yield* initRepoWithCommit(cwd);\n        const pathService = yield* Path.Path;\n        const worktreePath = pathService.join(\n          yield* makeTmpDir(\"git-worktrees-\"),\n          \"feature-worktree\",\n        );\n        const driver = yield* GitVcsDriver.GitVcsDriver;\n\n        const created = yield* driver.createWorktree({\n          cwd,\n          path: worktreePath,\n          refName: initialBranch,\n          newRefName: \"feature/worktree\",\n        });\n\n        assert.equal(created.worktree.path, worktreePath);\n        assert.equal(created.worktree.refName, \"feature/worktree\");\n        assert.equal(yield* git(worktreePath, [\"branch\", \"--show-current\"]), \"feature/worktree\");\n\n        yield* driver.removeWorktree({ cwd, path: worktreePath });\n        const fileSystem = yield* FileSystem.FileSystem;\n        assert.equal(yield* fileSystem.exists(worktreePath), false);\n      }),\n    );",
    "checksum": "7a00307d552baf90ff2b75e89cf5b2578a924b5f13fef6b4784fbf9f03a92160"
  },
  "worktree-bootstrap-failure-cleanup": {
    "id": "worktree-bootstrap-failure-cleanup",
    "path": "apps/server/src/ws.ts",
    "start": 1025,
    "end": 1053,
    "language": "typescript",
    "label": "Bootstrap failure compensation for a newly created thread",
    "code": "          return yield* bootstrapProgram.pipe(\n            Effect.catchCause((cause) => {\n              const dispatchError = toBootstrapDispatchCommandCauseError(cause);\n              if (Cause.hasInterruptsOnly(cause)) {\n                return Effect.fail(dispatchError);\n              }\n              return Effect.uninterruptible(cleanupCreatedThread()).pipe(\n                Effect.matchCauseEffect({\n                  onFailure: (cleanupCause) =>\n                    Effect.logWarning(\"bootstrap thread cleanup failed\", {\n                      threadId: command.threadId,\n                      detail: Cause.pretty(cleanupCause),\n                    }).pipe(Effect.flatMap(() => Effect.fail(dispatchError))),\n                  onSuccess: (threadDeleted) =>\n                    Effect.fail(\n                      threadDeleted\n                        ? new OrchestrationDispatchCommandError({\n                            message: dispatchError.message,\n                            ...(dispatchError.cause !== undefined\n                              ? { cause: dispatchError.cause }\n                              : {}),\n                            bootstrapThreadDisposition: \"deleted\",\n                          })\n                        : dispatchError,\n                    ),\n                }),\n              );\n            }),\n          );",
    "checksum": "d2c16f4de66195ff88ab5b79da7e0944fd287f3bc58ca2743d12e972a780cd57"
  },
  "turn-lifecycle-start-decider": {
    "id": "turn-lifecycle-start-decider",
    "path": "apps/server/src/orchestration/decider.ts",
    "start": 926,
    "end": 1036,
    "language": "typescript",
    "label": "Turn start intent and atomic lifecycle-reset event batch",
    "code": "    case \"thread.turn.start\": {\n      const targetThread = yield* requireThread({\n        readModel,\n        command,\n        threadId: command.threadId,\n      });\n      const sourceProposedPlan = command.sourceProposedPlan;\n      const sourceThread = sourceProposedPlan\n        ? yield* requireThread({\n            readModel,\n            command,\n            threadId: sourceProposedPlan.threadId,\n          })\n        : null;\n      const sourcePlan =\n        sourceProposedPlan && sourceThread\n          ? sourceThread.proposedPlans.find((entry) => entry.id === sourceProposedPlan.planId)\n          : null;\n      if (sourceProposedPlan && !sourcePlan) {\n        return yield* new OrchestrationCommandInvariantError({\n          commandType: command.type,\n          detail: `Proposed plan '${sourceProposedPlan.planId}' does not exist on thread '${sourceProposedPlan.threadId}'.`,\n        });\n      }\n      if (sourceThread && sourceThread.projectId !== targetThread.projectId) {\n        return yield* new OrchestrationCommandInvariantError({\n          commandType: command.type,\n          detail: `Proposed plan '${sourceProposedPlan?.planId}' belongs to thread '${sourceThread.id}' in a different project.`,\n        });\n      }\n      const userMessageEvent: Omit<OrchestrationEvent, \"sequence\"> = {\n        ...(yield* withEventBase({\n          aggregateKind: \"thread\",\n          aggregateId: command.threadId,\n          occurredAt: command.createdAt,\n          commandId: command.commandId,\n        })),\n        type: \"thread.message-sent\",\n        payload: {\n          threadId: command.threadId,\n          messageId: command.message.messageId,\n          role: \"user\",\n          text: command.message.text,\n          attachments: command.message.attachments,\n          turnId: null,\n          streaming: false,\n          createdAt: command.createdAt,\n          updatedAt: command.createdAt,\n        },\n      };\n      const turnStartRequestedEvent: Omit<OrchestrationEvent, \"sequence\"> = {\n        ...(yield* withEventBase({\n          aggregateKind: \"thread\",\n          aggregateId: command.threadId,\n          occurredAt: command.createdAt,\n          commandId: command.commandId,\n        })),\n        causationEventId: userMessageEvent.eventId,\n        type: \"thread.turn-start-requested\",\n        payload: {\n          threadId: command.threadId,\n          messageId: command.message.messageId,\n          ...(command.modelSelection !== undefined\n            ? { modelSelection: command.modelSelection }\n            : {}),\n          ...(command.titleSeed !== undefined ? { titleSeed: command.titleSeed } : {}),\n          runtimeMode: targetThread.runtimeMode,\n          interactionMode: targetThread.interactionMode,\n          ...(sourceProposedPlan !== undefined ? { sourceProposedPlan } : {}),\n          createdAt: command.createdAt,\n        },\n      };\n      // Real activity resets ANY override: it wakes an explicitly settled\n      // thread, and it clears a keep-active pin back to neutral so the\n      // thread can auto-settle again after this burst of work goes stale.\n      // A snooze clears the same way — sending a message to a snoozed\n      // thread is the user re-engaging, so the return ticket is spent.\n      const lifecycleResetEvents: Array<Omit<OrchestrationEvent, \"sequence\">> = [];\n      if (targetThread.settledOverride !== null) {\n        lifecycleResetEvents.push({\n          ...(yield* withEventBase({\n            aggregateKind: \"thread\",\n            aggregateId: command.threadId,\n            occurredAt: command.createdAt,\n            commandId: command.commandId,\n          })),\n          type: \"thread.unsettled\",\n          payload: {\n            threadId: command.threadId,\n            reason: \"activity\",\n            updatedAt: command.createdAt,\n          },\n        });\n      }\n      if (targetThread.snoozedUntil != null) {\n        lifecycleResetEvents.push({\n          ...(yield* withEventBase({\n            aggregateKind: \"thread\",\n            aggregateId: command.threadId,\n            occurredAt: command.createdAt,\n            commandId: command.commandId,\n          })),\n          type: \"thread.unsnoozed\",\n          payload: {\n            threadId: command.threadId,\n            reason: \"activity\",\n            updatedAt: command.createdAt,\n          },\n        });\n      }\n      return [...lifecycleResetEvents, userMessageEvent, turnStartRequestedEvent];",
    "checksum": "0d0fe115f9ae7b07e903de3cca6dfd815044b54aa8a56b75417acb4a17410c4d"
  },
  "turn-lifecycle-command-reactor": {
    "id": "turn-lifecycle-command-reactor",
    "path": "apps/server/src/orchestration/Layers/ProviderCommandReactor.ts",
    "start": 1060,
    "end": 1174,
    "language": "typescript",
    "label": "Committed turn intent forwarded to the provider",
    "code": "  const processTurnStartRequested = Effect.fn(\"processTurnStartRequested\")(function* (\n    event: Extract<ProviderIntentEvent, { type: \"thread.turn-start-requested\" }>,\n  ) {\n    const key = turnStartKeyForEvent(event);\n    if (yield* hasHandledTurnStartRecently(key)) {\n      return;\n    }\n\n    const thread = yield* resolveThread(event.payload.threadId);\n    if (!thread) {\n      return;\n    }\n\n    const message = thread.messages.find((entry) => entry.id === event.payload.messageId);\n    if (!message || message.role !== \"user\") {\n      yield* appendProviderFailureActivity({\n        threadId: event.payload.threadId,\n        kind: \"provider.turn.start.failed\",\n        summary: \"Provider turn start failed\",\n        detail: `User message '${event.payload.messageId}' was not found for turn start request.`,\n        turnId: null,\n        createdAt: event.payload.createdAt,\n      });\n      return;\n    }\n\n    const isFirstUserMessageTurn =\n      thread.messages.filter((entry) => entry.role === \"user\").length === 1;\n    if (isFirstUserMessageTurn) {\n      const project = yield* resolveProject(thread.projectId);\n      const generationCwd =\n        resolveThreadWorkspaceCwd({\n          thread,\n          projects: project ? [project] : [],\n        }) ?? process.cwd();\n      const generationInput = {\n        messageText: message.text,\n        ...(message.attachments !== undefined ? { attachments: message.attachments } : {}),\n        ...(event.payload.titleSeed !== undefined ? { titleSeed: event.payload.titleSeed } : {}),\n      };\n\n      yield* maybeGenerateAndRenameWorktreeBranchForFirstTurn({\n        threadId: event.payload.threadId,\n        branch: thread.branch,\n        worktreePath: thread.worktreePath,\n        ...generationInput,\n      }).pipe(Effect.forkScoped);\n\n      if (canReplaceThreadTitle(thread.title, event.payload.titleSeed)) {\n        yield* maybeGenerateThreadTitleForFirstTurn({\n          threadId: event.payload.threadId,\n          cwd: generationCwd,\n          ...generationInput,\n        }).pipe(Effect.forkScoped);\n      }\n    }\n\n    const handleTurnStartFailure = (cause: Cause.Cause<unknown>) => {\n      if (Cause.hasInterruptsOnly(cause)) {\n        return Effect.void;\n      }\n      const detail = formatFailureDetail(cause);\n      return setThreadSessionErrorOnTurnStartFailure({\n        threadId: event.payload.threadId,\n        detail,\n        createdAt: event.payload.createdAt,\n      }).pipe(\n        Effect.flatMap(() =>\n          appendProviderFailureActivity({\n            threadId: event.payload.threadId,\n            kind: \"provider.turn.start.failed\",\n            summary: \"Provider turn start failed\",\n            detail,\n            turnId: null,\n            createdAt: event.payload.createdAt,\n          }),\n        ),\n        Effect.asVoid,\n      );\n    };\n\n    const recoverTurnStartFailure = (cause: Cause.Cause<unknown>) =>\n      handleTurnStartFailure(cause).pipe(\n        Effect.catchCause((recoveryCause) =>\n          Effect.logWarning(\"provider command reactor failed to recover turn start failure\", {\n            eventType: event.type,\n            threadId: event.payload.threadId,\n            cause: Cause.pretty(recoveryCause),\n            originalCause: Cause.pretty(cause),\n          }),\n        ),\n      );\n\n    const sendTurnRequest = yield* buildSendTurnRequestForThread({\n      threadId: event.payload.threadId,\n      messageText: message.text,\n      ...(message.attachments !== undefined ? { attachments: message.attachments } : {}),\n      ...(event.payload.modelSelection !== undefined\n        ? { modelSelection: event.payload.modelSelection }\n        : {}),\n      interactionMode: event.payload.interactionMode,\n      createdAt: event.payload.createdAt,\n    }).pipe(\n      Effect.map(Option.some),\n      Effect.catchCause((cause) => handleTurnStartFailure(cause).pipe(Effect.as(Option.none()))),\n    );\n\n    if (Option.isNone(sendTurnRequest)) {\n      return;\n    }\n\n    yield* providerService\n      .sendTurn(sendTurnRequest.value)\n      .pipe(Effect.catchCause(recoverTurnStartFailure), Effect.forkScoped);\n  });",
    "checksum": "e612e2a0295ab2afbf9d9b7a9d4c7da0578c4adf5b052b24892d929ec9995f00"
  },
  "turn-lifecycle-runtime-correlation": {
    "id": "turn-lifecycle-runtime-correlation",
    "path": "apps/server/src/provider/Layers/ProviderService.ts",
    "start": 195,
    "end": 213,
    "language": "typescript",
    "label": "Provider runtime event identity validation",
    "code": "const correlateRuntimeEventWithInstance = (\n  source: {\n    readonly instanceId: ProviderInstanceId;\n    readonly provider: ProviderDriverKind;\n  },\n  event: ProviderRuntimeEvent,\n): ProviderRuntimeEvent => {\n  if (event.provider !== source.provider) {\n    throw new Error(\n      `ProviderService.streamEvents: provider instance '${source.instanceId}' is backed by driver '${source.provider}' but emitted driver '${event.provider}'.`,\n    );\n  }\n  if (event.providerInstanceId !== undefined && event.providerInstanceId !== source.instanceId) {\n    throw new Error(\n      `ProviderService.streamEvents: provider instance '${source.instanceId}' emitted event for instance '${event.providerInstanceId}'.`,\n    );\n  }\n  return { ...event, providerInstanceId: source.instanceId };\n};",
    "checksum": "43acc45594b4f0975e8a79e5f7a2dd9f0ce5233962b23cbf441038991a1f3082"
  },
  "turn-lifecycle-runtime-guards": {
    "id": "turn-lifecycle-runtime-guards",
    "path": "apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts",
    "start": 1505,
    "end": 1656,
    "language": "typescript",
    "label": "Runtime lifecycle correlation and durable session folding",
    "code": "      const now = event.createdAt;\n      const eventTurnId = toTurnId(event.turnId);\n      const activeTurnId = thread.session?.activeTurnId ?? null;\n      const pendingTurnStart = yield* projectionTurnRepository.getPendingTurnStartByThreadId({\n        threadId: thread.id,\n      });\n      const hasPendingTurnStart =\n        Option.isSome(pendingTurnStart) && thread.session?.status === \"starting\";\n\n      const conflictsWithActiveTurn =\n        activeTurnId !== null && eventTurnId !== undefined && !sameId(activeTurnId, eventTurnId);\n      const missingTurnForActiveTurn = activeTurnId !== null && eventTurnId === undefined;\n\n      // A turn.started that conflicts with the active turn is legitimate when\n      // the server itself has a turn start pending for this thread AND the\n      // provider session already tracks the event's turn as its active turn:\n      // steering a running turn makes some providers (e.g. opencode) open a\n      // new turn without ever completing the superseded one. A stale\n      // turn.started for some other turn id still gets rejected.\n      const conflictingTurnStartIsPendingTurnStart =\n        event.type === \"turn.started\" && conflictsWithActiveTurn\n          ? sameId(yield* getExpectedProviderTurnIdForThread(thread.id), eventTurnId) &&\n            Option.isSome(pendingTurnStart)\n          : false;\n\n      const shouldApplyThreadLifecycle = (() => {\n        if (!STRICT_PROVIDER_LIFECYCLE_GUARD) {\n          return true;\n        }\n        switch (event.type) {\n          case \"session.exited\":\n            return true;\n          case \"session.started\":\n          case \"thread.started\":\n            return true;\n          case \"turn.started\":\n            return !conflictsWithActiveTurn || conflictingTurnStartIsPendingTurnStart;\n          case \"turn.completed\":\n            if (conflictsWithActiveTurn || missingTurnForActiveTurn) {\n              return false;\n            }\n            // Only the active turn may close the lifecycle state.\n            if (activeTurnId !== null && eventTurnId !== undefined) {\n              return sameId(activeTurnId, eventTurnId);\n            }\n            // No active turn tracked: accept only completions that name their\n            // turn (covers a real completion whose turn.started was lost). An\n            // untargeted completion cannot prove it belongs to any turn this\n            // thread ran — the known emitter was the Claude resume handshake\n            // (system/init + result(num_turns: 0)), which is not a turn at\n            // all — and applying it here stomps the \"starting\" lifecycle\n            // state while a turn start is pending.\n            return eventTurnId !== undefined;\n          default:\n            return true;\n        }\n      })();\n      const acceptedTurnStartedSourcePlan =\n        event.type === \"turn.started\" && shouldApplyThreadLifecycle\n          ? yield* getSourceProposedPlanReferenceForAcceptedTurnStart(thread.id, eventTurnId)\n          : null;\n\n      if (\n        event.type === \"session.started\" ||\n        event.type === \"session.state.changed\" ||\n        event.type === \"session.exited\" ||\n        event.type === \"thread.started\" ||\n        event.type === \"turn.started\" ||\n        event.type === \"turn.completed\"\n      ) {\n        const status = (() => {\n          switch (event.type) {\n            case \"session.state.changed\": {\n              const runtimeStatus = orchestrationSessionStatusFromRuntimeState(event.payload.state);\n              return hasPendingTurnStart && runtimeStatus === \"ready\" ? \"starting\" : runtimeStatus;\n            }\n            case \"turn.started\":\n              return \"running\";\n            case \"session.exited\":\n              return \"stopped\";\n            case \"turn.completed\":\n              return normalizeRuntimeTurnState(event.payload.state) === \"failed\"\n                ? \"error\"\n                : \"ready\";\n            case \"session.started\":\n            case \"thread.started\":\n              // Provider thread/session start notifications can arrive during an\n              // active or pending turn; preserve that lifecycle state.\n              return activeTurnId !== null ? \"running\" : hasPendingTurnStart ? \"starting\" : \"ready\";\n          }\n        })();\n        const nextActiveTurnId =\n          event.type === \"turn.started\"\n            ? (eventTurnId ?? null)\n            : event.type === \"turn.completed\" || event.type === \"session.exited\"\n              ? null\n              : event.type === \"session.state.changed\" &&\n                  !sessionStatusAllowsActiveTurn(\n                    orchestrationSessionStatusFromRuntimeState(event.payload.state),\n                  )\n                ? null\n                : activeTurnId;\n        const lastError =\n          event.type === \"session.state.changed\" && event.payload.state === \"error\"\n            ? (event.payload.reason ?? thread.session?.lastError ?? \"Provider session error\")\n            : event.type === \"turn.completed\" &&\n                normalizeRuntimeTurnState(event.payload.state) === \"failed\"\n              ? (event.payload.errorMessage ?? thread.session?.lastError ?? \"Turn failed\")\n              : status === \"ready\"\n                ? null\n                : (thread.session?.lastError ?? null);\n\n        if (shouldApplyThreadLifecycle) {\n          if (event.type === \"turn.started\" && acceptedTurnStartedSourcePlan !== null) {\n            yield* markSourceProposedPlanImplemented(\n              acceptedTurnStartedSourcePlan.sourceThreadId,\n              acceptedTurnStartedSourcePlan.sourcePlanId,\n              thread.id,\n              now,\n            ).pipe(\n              Effect.catchCause((cause) =>\n                Effect.logWarning(\n                  \"provider runtime ingestion failed to mark source proposed plan\",\n                  {\n                    eventId: event.eventId,\n                    eventType: event.type,\n                    cause: Cause.pretty(cause),\n                  },\n                ),\n              ),\n            );\n          }\n\n          yield* orchestrationEngine.dispatch({\n            type: \"thread.session.set\",\n            commandId: yield* providerCommandId(event, \"thread-session-set\"),\n            threadId: thread.id,\n            session: {\n              threadId: thread.id,\n              status,\n              providerName: event.provider,\n              ...(event.providerInstanceId !== undefined\n                ? { providerInstanceId: event.providerInstanceId }\n                : {}),\n              runtimeMode: thread.session?.runtimeMode ?? \"full-access\",\n              activeTurnId: nextActiveTurnId,\n              lastError,\n              updatedAt: now,\n            },\n            createdAt: now,\n          });\n        }",
    "checksum": "c7bc77bba03bd67251974ffa4e634dad8af26720466ddde046f4be45c4110947"
  },
  "turn-lifecycle-buffering": {
    "id": "turn-lifecycle-buffering",
    "path": "apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts",
    "start": 1659,
    "end": 1750,
    "language": "typescript",
    "label": "Buffered assistant delivery and pause-boundary flush",
    "code": "      const assistantDelta =\n        event.type === \"content.delta\" && event.payload.streamKind === \"assistant_text\"\n          ? event.payload.delta\n          : undefined;\n      const proposedPlanDelta =\n        event.type === \"turn.proposed.delta\" ? event.payload.delta : undefined;\n\n      if (assistantDelta && assistantDelta.length > 0) {\n        const turnId = toTurnId(event.turnId);\n        const assistantMessageId = yield* getOrCreateAssistantMessageId({\n          threadId: thread.id,\n          event,\n          ...(turnId ? { turnId } : {}),\n        });\n        if (turnId) {\n          yield* rememberAssistantMessageId(thread.id, turnId, assistantMessageId);\n        }\n\n        const assistantDeliveryMode: AssistantDeliveryMode = yield* Effect.map(\n          serverSettingsService.getSettings,\n          (settings) => (settings.enableLegacyTokenStreaming ? \"streaming\" : \"buffered\"),\n        );\n        if (assistantDeliveryMode === \"buffered\") {\n          const spillChunk = yield* appendBufferedAssistantText(assistantMessageId, assistantDelta);\n          if (spillChunk.length > 0) {\n            yield* orchestrationEngine.dispatch({\n              type: \"thread.message.assistant.delta\",\n              commandId: yield* providerCommandId(event, \"assistant-delta-buffer-spill\"),\n              threadId: thread.id,\n              messageId: assistantMessageId,\n              delta: spillChunk,\n              ...(turnId ? { turnId } : {}),\n              createdAt: now,\n            });\n          }\n        } else {\n          yield* orchestrationEngine.dispatch({\n            type: \"thread.message.assistant.delta\",\n            commandId: yield* providerCommandId(event, \"assistant-delta\"),\n            threadId: thread.id,\n            messageId: assistantMessageId,\n            delta: assistantDelta,\n            ...(turnId ? { turnId } : {}),\n            createdAt: now,\n          });\n        }\n      }\n\n      const pauseForUserTurnId =\n        event.type === \"request.opened\" || event.type === \"user-input.requested\"\n          ? toTurnId(event.turnId)\n          : undefined;\n      if (pauseForUserTurnId) {\n        const detailedThread = yield* getLoadedThreadDetail();\n        const assistantDeliveryMode: AssistantDeliveryMode = yield* Effect.map(\n          serverSettingsService.getSettings,\n          (settings) => (settings.enableLegacyTokenStreaming ? \"streaming\" : \"buffered\"),\n        );\n        const flushedMessageIds =\n          assistantDeliveryMode === \"buffered\"\n            ? yield* flushBufferedAssistantMessagesForTurn({\n                event,\n                threadId: thread.id,\n                turnId: pauseForUserTurnId,\n                createdAt: now,\n                commandTag:\n                  event.type === \"request.opened\"\n                    ? \"assistant-delta-flush-on-request-opened\"\n                    : \"assistant-delta-flush-on-user-input-requested\",\n              })\n            : new Set<MessageId>();\n        yield* finalizeActiveAssistantSegmentForTurn({\n          event,\n          threadId: thread.id,\n          turnId: pauseForUserTurnId,\n          createdAt: now,\n          commandTag:\n            event.type === \"request.opened\"\n              ? \"assistant-complete-on-request-opened\"\n              : \"assistant-complete-on-user-input-requested\",\n          finalDeltaCommandTag:\n            event.type === \"request.opened\"\n              ? \"assistant-delta-finalize-on-request-opened\"\n              : \"assistant-delta-finalize-on-user-input-requested\",\n          hasProjectedMessage:\n            detailedThread !== null &&\n            hasAssistantMessageForTurn(detailedThread.messages, pauseForUserTurnId, {\n              streamingOnly: true,\n            }),\n          flushedMessageIds,\n        });\n      }",
    "checksum": "e91fb7e11d5c75dc5a834b75c111d8805a0342d7807a62d1977cd0542a51508c"
  },
  "turn-lifecycle-interrupt": {
    "id": "turn-lifecycle-interrupt",
    "path": "apps/server/src/orchestration/decider.ts",
    "start": 1039,
    "end": 1058,
    "language": "typescript",
    "label": "Durable turn interrupt intent",
    "code": "    case \"thread.turn.interrupt\": {\n      yield* requireThread({\n        readModel,\n        command,\n        threadId: command.threadId,\n      });\n      return {\n        ...(yield* withEventBase({\n          aggregateKind: \"thread\",\n          aggregateId: command.threadId,\n          occurredAt: command.createdAt,\n          commandId: command.commandId,\n        })),\n        type: \"thread.turn-interrupt-requested\",\n        payload: {\n          threadId: command.threadId,\n          ...(command.turnId !== undefined ? { turnId: command.turnId } : {}),\n          createdAt: command.createdAt,\n        },\n      };",
    "checksum": "78ab7a9c85d8c101f2136c38a88c3cef91b00adf35fb3731e56f8537cced4278"
  },
  "turn-lifecycle-checkpoint-completion": {
    "id": "turn-lifecycle-checkpoint-completion",
    "path": "apps/server/src/orchestration/Layers/CheckpointReactor.ts",
    "start": 356,
    "end": 458,
    "language": "typescript",
    "label": "Post-turn checkpoint capture and placeholder replacement",
    "code": "    function* (event: Extract<ProviderRuntimeEvent, { type: \"turn.completed\" }>) {\n      const turnId = toTurnId(event.turnId);\n      if (!turnId) {\n        return;\n      }\n\n      const thread = yield* resolveThreadDetail(event.threadId);\n      if (!thread) {\n        return;\n      }\n\n      // When a primary turn is active, only that turn may produce completion checkpoints.\n      if (thread.session?.activeTurnId && !sameId(thread.session.activeTurnId, turnId)) {\n        return;\n      }\n\n      // Only skip if a real (non-placeholder) checkpoint already exists for this turn.\n      // ProviderRuntimeIngestion may insert placeholder entries with status \"missing\"\n      // before this reactor runs; those must not prevent real git capture.\n      if (\n        thread.checkpoints.some(\n          (checkpoint) => checkpoint.turnId === turnId && checkpoint.status !== \"missing\",\n        )\n      ) {\n        return;\n      }\n\n      const projects = yield* resolveThreadProjects(thread.projectId);\n      const checkpointCwd = yield* resolveCheckpointCwd({\n        threadId: thread.id,\n        thread,\n        projects,\n        preferSessionRuntime: true,\n      });\n      if (!checkpointCwd) {\n        return;\n      }\n\n      // If a placeholder checkpoint exists for this turn, reuse its turn count\n      // instead of incrementing past it.\n      const existingPlaceholder = thread.checkpoints.find(\n        (checkpoint) => checkpoint.turnId === turnId && checkpoint.status === \"missing\",\n      );\n      const currentTurnCount = thread.checkpoints.reduce(\n        (maxTurnCount, checkpoint) => Math.max(maxTurnCount, checkpoint.checkpointTurnCount),\n        0,\n      );\n      const nextTurnCount = existingPlaceholder\n        ? existingPlaceholder.checkpointTurnCount\n        : currentTurnCount + 1;\n\n      yield* captureAndDispatchCheckpoint({\n        threadId: thread.id,\n        turnId,\n        thread,\n        cwd: checkpointCwd,\n        turnCount: nextTurnCount,\n        status: checkpointStatusFromRuntime(event.payload.state),\n        assistantMessageId: undefined,\n        createdAt: event.createdAt,\n      });\n    },\n  );\n\n  // Captures a real git checkpoint when a placeholder checkpoint (status \"missing\")\n  // is detected via a domain event. This replaces the placeholder with a real\n  // git-ref-based checkpoint.\n  //\n  // ProviderRuntimeIngestion creates placeholder checkpoints on turn.diff.updated\n  // events from the Codex runtime. This handler fires when the corresponding\n  // domain event arrives, allowing the reactor to capture the actual filesystem\n  // state into a git ref and dispatch a replacement checkpoint.\n  const captureCheckpointFromPlaceholder = Effect.fn(\"captureCheckpointFromPlaceholder\")(function* (\n    event: Extract<OrchestrationEvent, { type: \"thread.turn-diff-completed\" }>,\n  ) {\n    const { threadId, turnId, checkpointTurnCount, status } = event.payload;\n\n    // Only replace placeholders; skip events from our own real captures.\n    if (status !== \"missing\") {\n      return;\n    }\n\n    const thread = yield* resolveThreadDetail(threadId);\n    if (!thread) {\n      yield* Effect.logWarning(\"checkpoint capture from placeholder skipped: thread not found\", {\n        threadId,\n      });\n      return;\n    }\n\n    // If a real checkpoint already exists for this turn, skip.\n    if (\n      thread.checkpoints.some(\n        (checkpoint) => checkpoint.turnId === turnId && checkpoint.status !== \"missing\",\n      )\n    ) {\n      yield* Effect.logDebug(\n        \"checkpoint capture from placeholder skipped: real checkpoint already exists\",\n        { threadId, turnId },\n      );\n      return;\n    }\n",
    "checksum": "e341d79b8fcb4969bed1f9f6a7ad0b5d032de516eabaa59661d2f8ce698bd3b7"
  },
  "permission-runtime-mode-contract": {
    "id": "permission-runtime-mode-contract",
    "path": "packages/contracts/src/orchestration.ts",
    "start": 120,
    "end": 143,
    "language": "typescript",
    "label": "Canonical runtime modes and approval decisions",
    "code": "export const RuntimeMode = Schema.Literals([\n  \"approval-required\",\n  \"auto-accept-edits\",\n  \"auto\",\n  \"full-access\",\n]);\nexport type RuntimeMode = typeof RuntimeMode.Type;\nexport const DEFAULT_RUNTIME_MODE: RuntimeMode = \"full-access\";\nexport const ProviderInteractionMode = Schema.Literals([\"default\", \"plan\"]);\nexport type ProviderInteractionMode = typeof ProviderInteractionMode.Type;\nexport const DEFAULT_PROVIDER_INTERACTION_MODE: ProviderInteractionMode = \"default\";\nexport const ProviderRequestKind = Schema.Literals([\"command\", \"file-read\", \"file-change\"]);\nexport type ProviderRequestKind = typeof ProviderRequestKind.Type;\nexport const AssistantDeliveryMode = Schema.Literals([\"buffered\", \"streaming\"]);\nexport type AssistantDeliveryMode = typeof AssistantDeliveryMode.Type;\nexport const ProviderApprovalDecision = Schema.Literals([\n  \"accept\",\n  \"acceptForSession\",\n  \"decline\",\n  \"cancel\",\n]);\nexport type ProviderApprovalDecision = typeof ProviderApprovalDecision.Type;\nexport const ProviderUserInputAnswers = Schema.Record(Schema.String, Schema.Unknown);\nexport type ProviderUserInputAnswers = typeof ProviderUserInputAnswers.Type;",
    "checksum": "2ec2b0f6d38c3c832ef4494cbe97a899fe4f4b83fe808ef16a1356580e935479"
  },
  "permission-codex-mode-map": {
    "id": "permission-codex-mode-map",
    "path": "apps/server/src/provider/Layers/CodexSessionRuntime.ts",
    "start": 268,
    "end": 340,
    "language": "typescript",
    "label": "T3 runtime modes mapped into Codex approval and sandbox settings",
    "code": "function runtimeModeToThreadConfig(input: RuntimeMode): {\n  readonly approvalPolicy: EffectCodexSchema.V2ThreadStartParams__AskForApproval;\n  readonly sandbox: EffectCodexSchema.V2ThreadStartParams__SandboxMode;\n  // Always explicit: omitting the field on resume keeps the thread's previous\n  // reviewer, which would leave auto_review sticky after switching modes.\n  readonly approvalsReviewer: EffectCodexSchema.V2ThreadStartParams__ApprovalsReviewer;\n} {\n  switch (input) {\n    case \"approval-required\":\n      return {\n        approvalPolicy: \"untrusted\",\n        sandbox: \"read-only\",\n        approvalsReviewer: \"user\",\n      };\n    case \"auto-accept-edits\":\n      return {\n        approvalPolicy: \"on-request\",\n        sandbox: \"workspace-write\",\n        approvalsReviewer: \"user\",\n      };\n    case \"auto\":\n      return {\n        approvalPolicy: \"on-request\",\n        sandbox: \"workspace-write\",\n        approvalsReviewer: \"auto_review\",\n      };\n    case \"full-access\":\n    default:\n      return {\n        approvalPolicy: \"never\",\n        sandbox: \"danger-full-access\",\n        approvalsReviewer: \"user\",\n      };\n  }\n}\n\nfunction buildThreadStartParams(input: {\n  readonly cwd: string;\n  readonly runtimeMode: RuntimeMode;\n  readonly model: string | undefined;\n  readonly serviceTier: CodexServiceTier | undefined;\n}): EffectCodexSchema.V2ThreadStartParams {\n  const config = runtimeModeToThreadConfig(input.runtimeMode);\n  return {\n    cwd: input.cwd,\n    approvalPolicy: config.approvalPolicy,\n    sandbox: config.sandbox,\n    approvalsReviewer: config.approvalsReviewer,\n    ...(input.model ? { model: input.model } : {}),\n    ...(input.serviceTier ? { serviceTier: input.serviceTier } : {}),\n  };\n}\n\nfunction runtimeModeToTurnSandboxPolicy(\n  input: RuntimeMode,\n): EffectCodexSchema.V2TurnStartParams__SandboxPolicy {\n  switch (input) {\n    case \"approval-required\":\n      return {\n        type: \"readOnly\",\n      };\n    case \"auto-accept-edits\":\n    case \"auto\":\n      return {\n        type: \"workspaceWrite\",\n      };\n    case \"full-access\":\n    default:\n      return {\n        type: \"dangerFullAccess\",\n      };\n  }\n}",
    "checksum": "bf3d7a104fb45d37eee289512fb96dc72046d830c24c5eda45fdd42346b519d9"
  },
  "permission-request-contract": {
    "id": "permission-request-contract",
    "path": "packages/contracts/src/providerRuntime.ts",
    "start": 430,
    "end": 469,
    "language": "typescript",
    "label": "Canonical approval and structured-input request payloads",
    "code": "const RequestOpenedPayload = Schema.Struct({\n  requestType: CanonicalRequestType,\n  detail: Schema.optional(TrimmedNonEmptyStringSchema),\n  args: Schema.optional(Schema.Unknown),\n});\nexport type RequestOpenedPayload = typeof RequestOpenedPayload.Type;\n\nconst RequestResolvedPayload = Schema.Struct({\n  requestType: CanonicalRequestType,\n  decision: Schema.optional(TrimmedNonEmptyStringSchema),\n  resolution: Schema.optional(Schema.Unknown),\n});\nexport type RequestResolvedPayload = typeof RequestResolvedPayload.Type;\n\nconst UserInputQuestionOption = Schema.Struct({\n  label: TrimmedNonEmptyStringSchema,\n  description: TrimmedNonEmptyStringSchema,\n});\nexport type UserInputQuestionOption = typeof UserInputQuestionOption.Type;\n\nexport const UserInputQuestion = Schema.Struct({\n  id: TrimmedNonEmptyStringSchema,\n  header: TrimmedNonEmptyStringSchema,\n  question: TrimmedNonEmptyStringSchema,\n  options: Schema.Array(UserInputQuestionOption),\n  multiSelect: Schema.optional(Schema.Boolean).pipe(\n    Schema.withConstructorDefault(Effect.succeed(false)),\n  ),\n});\nexport type UserInputQuestion = typeof UserInputQuestion.Type;\n\nconst UserInputRequestedPayload = Schema.Struct({\n  questions: Schema.Array(UserInputQuestion),\n});\nexport type UserInputRequestedPayload = typeof UserInputRequestedPayload.Type;\n\nconst UserInputResolvedPayload = Schema.Struct({\n  answers: UnknownRecordSchema,\n});\nexport type UserInputResolvedPayload = typeof UserInputResolvedPayload.Type;",
    "checksum": "6b1a92d91a1044987815a33034c9d57cf408dde2c10b3b0d1a518d7c63094277"
  },
  "work-task-usage-contract": {
    "id": "work-task-usage-contract",
    "path": "packages/contracts/src/providerRuntime.ts",
    "start": 471,
    "end": 543,
    "language": "typescript",
    "label": "Typed per-task usage and agent-versus-background classification",
    "code": "/**\n * Typed per-task usage rollup. Field names match the orchestration-v2 subagent\n * usage vocabulary (#4779) so the eventual migration is a rename, not a remap.\n * Claude reports per-activation deltas; Codex reports cumulative totals — the\n * merge strategy is provider-specific and lives in client-runtime.\n */\nexport const RuntimeTaskUsage = Schema.Struct({\n  totalTokens: NonNegativeInt,\n  inputTokens: Schema.optional(NonNegativeInt),\n  cachedInputTokens: Schema.optional(NonNegativeInt),\n  outputTokens: Schema.optional(NonNegativeInt),\n  reasoningOutputTokens: Schema.optional(NonNegativeInt),\n  toolUses: Schema.optional(NonNegativeInt),\n  durationMs: Schema.optional(NonNegativeInt),\n});\nexport type RuntimeTaskUsage = typeof RuntimeTaskUsage.Type;\n\nexport const TaskWorkflowPhase = Schema.Struct({\n  index: NonNegativeInt,\n  title: TrimmedNonEmptyStringSchema,\n});\nexport type TaskWorkflowPhase = typeof TaskWorkflowPhase.Type;\n\nexport const TaskRunHandles = Schema.Struct({\n  runId: Schema.optional(TrimmedNonEmptyStringSchema),\n  scriptPath: Schema.optional(TrimmedNonEmptyStringSchema),\n  transcriptDir: Schema.optional(TrimmedNonEmptyStringSchema),\n  /** Only http/https URLs may be stored here — sanitized at the adapter. */\n  sessionUrl: Schema.optional(TrimmedNonEmptyStringSchema),\n});\nexport type TaskRunHandles = typeof TaskRunHandles.Type;\n\n/**\n * Watch-loop task types: Monitor-tool tasks plus background shells (a shell\n * that outlives its turn is in practice a watch loop). Canonical single copy —\n * the server liveness registry, ingestion's agentKind stamp, and the client\n * fold's legacy fallback all classify with these sets.\n */\nexport const MONITOR_TASK_TYPES: ReadonlySet<string> = new Set([\n  \"monitor\",\n  \"monitor_mcp\",\n  \"local_bash\",\n  \"shell\",\n]);\n/** Task types that are neither agents nor watch loops (plan-mode bookkeeping). */\nexport const INERT_TASK_TYPES: ReadonlySet<string> = new Set([\"plan\", \"dream\"]);\n\n/**\n * Agent-vs-background classification, stamped by ingestion as `agentKind` so\n * persisted rows are self-describing. A deliberate denylist: the SDK's\n * agent-flavored type names drift (subagent, local_agent, local_workflow, …)\n * and an allowlist silently dropped real subagents when \"local_agent\"\n * appeared. A task launched from inside a subagent (agentId set) is\n * agent-internal background work UNLESS it is itself agent-flavored — a\n * nested agent can outlive its parent and stays in the roster.\n */\nexport function classifyTaskAgentKind(input: {\n  readonly taskType?: string | undefined;\n  readonly agentId?: string | undefined;\n}): \"agent\" | \"background\" {\n  const { taskType, agentId } = input;\n  const nonAgentType =\n    taskType !== undefined && (MONITOR_TASK_TYPES.has(taskType) || INERT_TASK_TYPES.has(taskType));\n  if (agentId !== undefined && agentId.trim().length > 0) {\n    return taskType === undefined || nonAgentType ? \"background\" : \"agent\";\n  }\n  return nonAgentType ? \"background\" : \"agent\";\n}\n\n/**\n * Optional agent-identity linkage carried on every task lifecycle payload.\n * Repeated on progress and terminal rows (not just start) so client folds can\n * reconstruct an agent even when its start row aged out of activity retention.",
    "checksum": "9c7794660442c1d9a47d1553b18d8e593f52d0f6f4ded9f377c395421336aab5"
  },
  "work-task-latest-activities": {
    "id": "work-task-latest-activities",
    "path": "apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts",
    "start": 569,
    "end": 646,
    "language": "typescript",
    "label": "Separate stable task progress and usage activity snapshots",
    "code": "      const linkage = taskLinkageActivityFields(event.payload as Record<string, unknown>);\n      // Usage and activity are independent latest-state streams. Keeping them\n      // under separate stable ids prevents a command/reasoning update from\n      // replacing the last known token count (and prevents a usage-only tick\n      // from blanking the last meaningful activity).\n      const identityLinkage = { ...linkage };\n      delete identityLinkage.typedUsage;\n      delete identityLinkage.status;\n      delete identityLinkage.error;\n      const title =\n        event.payload.description.trim().length > 0\n          ? { title: truncateDetail(event.payload.description, 120) }\n          : {};\n      const hasProgressState =\n        event.payload.typedUsage === undefined ||\n        event.payload.summary !== undefined ||\n        event.payload.lastToolName !== undefined ||\n        event.payload.status !== undefined ||\n        event.payload.error !== undefined;\n      return [\n        ...(hasProgressState\n          ? [\n              {\n                // Stable per-task id: activity is \"latest state\", not\n                // history, so each meaningful tick replaces the last. This\n                // bounds a large fleet to one activity row per task.\n                id: EventId.make(`task-progress:${event.threadId}:${event.payload.taskId}`),\n                createdAt: event.createdAt,\n                tone: \"info\" as const,\n                kind: \"task.progress\" as const,\n                summary:\n                  event.payload.description.trim().length > 0\n                    ? truncateDetail(event.payload.description, 120)\n                    : \"Reasoning update\",\n                payload: {\n                  taskId: event.payload.taskId,\n                  ...title,\n                  detail: truncateDetail(event.payload.summary ?? event.payload.description),\n                  ...(event.payload.summary\n                    ? { summary: truncateDetail(event.payload.summary) }\n                    : {}),\n                  ...(event.payload.lastToolName\n                    ? { lastToolName: event.payload.lastToolName }\n                    : {}),\n                  ...(event.payload.status ? { status: event.payload.status } : {}),\n                  ...(event.payload.error ? { error: event.payload.error } : {}),\n                  ...(event.payload.usage !== undefined ? { usage: event.payload.usage } : {}),\n                  ...identityLinkage,\n                },\n                turnId: toTurnId(event.turnId) ?? null,\n                ...maybeSequence,\n              },\n            ]\n          : []),\n        ...(event.payload.typedUsage !== undefined\n          ? [\n              {\n                id: EventId.make(`task-usage:${event.threadId}:${event.payload.taskId}`),\n                createdAt: event.createdAt,\n                tone: \"info\" as const,\n                kind: \"task.progress\" as const,\n                summary: \"Task usage updated\",\n                payload: {\n                  taskId: event.payload.taskId,\n                  ...title,\n                  ...identityLinkage,\n                  usageSnapshot: true,\n                  typedUsage: event.payload.typedUsage,\n                },\n                turnId: toTurnId(event.turnId) ?? null,\n                ...maybeSequence,\n              },\n            ]\n          : []),\n      ];\n    }\n\n    case \"task.updated\": {",
    "checksum": "11d184eb4842e6907a766a04a86a1b355065eb1ae64b2891b58d24d836acd812"
  },
  "work-subagent-usage-merge": {
    "id": "work-subagent-usage-merge",
    "path": "packages/client-runtime/src/state/subagentRuntime.ts",
    "start": 149,
    "end": 225,
    "language": "typescript",
    "label": "Tolerant field-wise task usage parsing and max merge",
    "code": "function asUsage(value: unknown): SubagentUsage | undefined {\n  if (typeof value !== \"object\" || value === null) {\n    return undefined;\n  }\n  const record = value as Record<string, unknown>;\n  const totalTokens = asCount(record.totalTokens);\n  if (totalTokens === undefined) {\n    return undefined;\n  }\n  const usage: {\n    totalTokens: number;\n    inputTokens?: number;\n    cachedInputTokens?: number;\n    outputTokens?: number;\n    reasoningOutputTokens?: number;\n    toolUses?: number;\n    durationMs?: number;\n  } = { totalTokens };\n  const inputTokens = asCount(record.inputTokens);\n  if (inputTokens !== undefined) usage.inputTokens = inputTokens;\n  const cachedInputTokens = asCount(record.cachedInputTokens);\n  if (cachedInputTokens !== undefined) usage.cachedInputTokens = cachedInputTokens;\n  const outputTokens = asCount(record.outputTokens);\n  if (outputTokens !== undefined) usage.outputTokens = outputTokens;\n  const reasoningOutputTokens = asCount(record.reasoningOutputTokens);\n  if (reasoningOutputTokens !== undefined) usage.reasoningOutputTokens = reasoningOutputTokens;\n  const toolUses = asCount(record.toolUses);\n  if (toolUses !== undefined) usage.toolUses = toolUses;\n  const durationMs = asCount(record.durationMs);\n  if (durationMs !== undefined) usage.durationMs = durationMs;\n  return usage;\n}\n\n/**\n * Provider-specific usage merge (#4779 semantics, verbatim):\n * - max-merge (Codex-style cumulative frames): field-wise maximum, idempotent\n *   under duplicate or late frames. Cumulative totals never shrink.\n * - accumulate (Claude-style activation deltas): not needed at this layer —\n *   Claude's task_progress usage is itself cumulative per task, so the fold\n *   also max-merges. The distinction matters when v2 sums activations.\n * Field-wise: a terminal payload carrying only totalTokens must not wipe a\n * known breakdown.\n */\nfunction mergeUsageMax(\n  current: SubagentUsage | null,\n  incoming: SubagentUsage | undefined,\n): SubagentUsage | null {\n  if (!incoming) {\n    return current;\n  }\n  if (!current) {\n    return incoming;\n  }\n  const pick = (a: number | undefined, b: number | undefined): number | undefined =>\n    a === undefined ? b : b === undefined ? a : Math.max(a, b);\n  const merged: {\n    totalTokens: number;\n    inputTokens?: number;\n    cachedInputTokens?: number;\n    outputTokens?: number;\n    reasoningOutputTokens?: number;\n    toolUses?: number;\n    durationMs?: number;\n  } = { totalTokens: Math.max(current.totalTokens, incoming.totalTokens) };\n  const inputTokens = pick(current.inputTokens, incoming.inputTokens);\n  if (inputTokens !== undefined) merged.inputTokens = inputTokens;\n  const cachedInputTokens = pick(current.cachedInputTokens, incoming.cachedInputTokens);\n  if (cachedInputTokens !== undefined) merged.cachedInputTokens = cachedInputTokens;\n  const outputTokens = pick(current.outputTokens, incoming.outputTokens);\n  if (outputTokens !== undefined) merged.outputTokens = outputTokens;\n  const reasoningOutputTokens = pick(current.reasoningOutputTokens, incoming.reasoningOutputTokens);\n  if (reasoningOutputTokens !== undefined) merged.reasoningOutputTokens = reasoningOutputTokens;\n  const toolUses = pick(current.toolUses, incoming.toolUses);\n  if (toolUses !== undefined) merged.toolUses = toolUses;\n  const durationMs = pick(current.durationMs, incoming.durationMs);\n  if (durationMs !== undefined) merged.durationMs = durationMs;\n  return merged;",
    "checksum": "0c82d5cb0342b54d4564be5359be4c6368ac86bfeb618d455edd558a5e3645a7"
  },
  "context-provider-binding-shape": {
    "id": "context-provider-binding-shape",
    "path": "apps/server/src/persistence/ProviderSessionRuntime.ts",
    "start": 35,
    "end": 110,
    "language": "typescript",
    "label": "Persisted provider-instance binding and opaque continuation state",
    "code": "export const ProviderSessionRuntime = Schema.Struct({\n  threadId: ThreadId,\n  providerName: Schema.String,\n  /**\n   * User-defined routing key for the configured provider instance that\n   * owns this session. Nullable only at the storage/migration boundary:\n   * rows persisted before the driver/instance split carry only\n   * `providerName`. Repository consumers must materialize a concrete\n   * instance id before routing.\n   */\n  providerInstanceId: Schema.NullOr(ProviderInstanceId),\n  adapterKey: Schema.String,\n  runtimeMode: RuntimeMode,\n  status: ProviderSessionRuntimeStatus,\n  lastSeenAt: IsoDateTime,\n  resumeCursor: Schema.NullOr(Schema.Unknown),\n  runtimePayload: Schema.NullOr(Schema.Unknown),\n});\nexport type ProviderSessionRuntime = typeof ProviderSessionRuntime.Type;\n\nexport const GetProviderSessionRuntimeInput = Schema.Struct({ threadId: ThreadId });\nexport type GetProviderSessionRuntimeInput = typeof GetProviderSessionRuntimeInput.Type;\n\nexport const DeleteProviderSessionRuntimeInput = Schema.Struct({ threadId: ThreadId });\nexport type DeleteProviderSessionRuntimeInput = typeof DeleteProviderSessionRuntimeInput.Type;\n\n/**\n * ProviderSessionRuntimeRepository - Service tag for provider runtime persistence.\n */\nexport class ProviderSessionRuntimeRepository extends Context.Service<\n  ProviderSessionRuntimeRepository,\n  {\n    /**\n     * Insert or replace a provider runtime row.\n     *\n     * Upserts by canonical `threadId`, including JSON payload/cursor fields.\n     */\n    readonly upsert: (\n      runtime: ProviderSessionRuntime,\n    ) => Effect.Effect<void, ProviderSessionRuntimeRepositoryError>;\n\n    /**\n     * Read provider runtime state by canonical thread id.\n     */\n    readonly getByThreadId: (\n      input: GetProviderSessionRuntimeInput,\n    ) => Effect.Effect<\n      Option.Option<ProviderSessionRuntime>,\n      ProviderSessionRuntimeRepositoryError\n    >;\n\n    /**\n     * List all provider runtime rows.\n     *\n     * Returned in ascending last-seen order.\n     */\n    readonly list: () => Effect.Effect<\n      ReadonlyArray<ProviderSessionRuntime>,\n      ProviderSessionRuntimeRepositoryError\n    >;\n\n    /**\n     * Delete provider runtime state by canonical thread id.\n     */\n    readonly deleteByThreadId: (\n      input: DeleteProviderSessionRuntimeInput,\n    ) => Effect.Effect<void, ProviderSessionRuntimeRepositoryError>;\n  }\n>()(\"t3/persistence/ProviderSessionRuntime/ProviderSessionRuntimeRepository\") {}\n\nconst ProviderSessionRuntimeDbRowSchema = ProviderSessionRuntime.mapFields(\n  Struct.assign({\n    resumeCursor: Schema.NullOr(Schema.fromJsonString(Schema.Unknown)),\n    runtimePayload: Schema.NullOr(Schema.fromJsonString(Schema.Unknown)),\n  }),\n);",
    "checksum": "b92dc6c01460eee6a905a51d0d848df3b28fd4410a9403789699bc459815cadd"
  },
  "context-memory-compaction-ingestion": {
    "id": "context-memory-compaction-ingestion",
    "path": "apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts",
    "start": 744,
    "end": 763,
    "language": "typescript",
    "label": "Provider compaction observation becomes durable thread activity",
    "code": "    case \"thread.state.changed\": {\n      if (event.payload.state !== \"compacted\") {\n        return [];\n      }\n\n      return [\n        {\n          id: event.eventId,\n          createdAt: event.createdAt,\n          tone: \"info\",\n          kind: \"context-compaction\",\n          summary: \"Context compacted\",\n          payload: {\n            state: event.payload.state,\n            ...(event.payload.detail !== undefined ? { detail: event.payload.detail } : {}),\n          },\n          turnId: toTurnId(event.turnId) ?? null,\n          ...maybeSequence,\n        },\n      ];",
    "checksum": "84f0ec54be712d09ef6dc181bcd36318a26e36de8def7182a8377454dd21fcdd"
  },
  "context-window-reducer-retention": {
    "id": "context-window-reducer-retention",
    "path": "packages/client-runtime/src/state/threadReducer.ts",
    "start": 562,
    "end": 592,
    "language": "typescript",
    "label": "Latest resolvable context-window snapshot retained per turn id",
    "code": "    // ── Activities ──────────────────────────────────────────────────\n    case \"thread.activity-appended\": {\n      const activity = event.payload.activity;\n      // A resolvable context-window update supersedes earlier resolvable ones\n      // for the same turn: consumers only read the latest value (walking the\n      // array backwards), and providers stream these updates continuously, so\n      // retaining the history grows the thread by thousands of rows over a\n      // long session. Mirrors the server-side snapshot rule in\n      // dropStaleContextWindowActivities; retention stays per turn so a\n      // thread.reverted that discards turns can still resolve a value from\n      // the turns that survive.\n      const supersedesContextWindow = isResolvableContextWindowActivity(activity);\n      const activities = pipe(\n        thread.activities,\n        Arr.filter(\n          (entry) =>\n            entry.id !== activity.id &&\n            !(\n              supersedesContextWindow &&\n              entry.turnId === activity.turnId &&\n              isResolvableContextWindowActivity(entry)\n            ),\n        ),\n        Arr.append(activity),\n        Arr.sort(activityOrder),\n      );\n\n      return {\n        kind: \"updated\",\n        thread: { ...thread, activities, updatedAt: event.occurredAt },\n      };",
    "checksum": "ae9a3e3858741dd9a80e70b34a5ab36dca52539d93e1b199f9572b7113f6c995"
  },
  "workbench-terminal-attach-order": {
    "id": "workbench-terminal-attach-order",
    "path": "apps/server/src/terminal/Manager.ts",
    "start": 2351,
    "end": 2402,
    "language": "typescript",
    "label": "Terminal attach buffers races, emits a snapshot, then delivers live events",
    "code": "  const attachStream: TerminalManager[\"Service\"][\"attachStream\"] = (input, listener) => {\n    let unsubscribe: (() => void) | null = null;\n\n    return Effect.gen(function* () {\n      const bufferedEvents: TerminalEvent[] = [];\n      let deliverLive = false;\n\n      unsubscribe = yield* subscribe((event) => {\n        if (event.threadId !== input.threadId || event.terminalId !== input.terminalId) {\n          return Effect.void;\n        }\n\n        if (!deliverLive) {\n          bufferedEvents.push(event);\n          return Effect.void;\n        }\n\n        const attachEvent = terminalEventToAttachEvent(event);\n        return attachEvent ? listener(attachEvent) : Effect.void;\n      });\n\n      const initialSnapshot = yield* openOrAttachForStream(input);\n\n      yield* listener({\n        type: \"snapshot\",\n        snapshot: initialSnapshot,\n      });\n\n      for (const event of bufferedEvents) {\n        if (isDuplicateAttachSnapshotEvent(event, initialSnapshot)) {\n          continue;\n        }\n\n        const attachEvent = terminalEventToAttachEvent(event);\n        if (attachEvent) {\n          yield* listener(attachEvent);\n        }\n      }\n\n      deliverLive = true;\n      return () => {\n        unsubscribe?.();\n        unsubscribe = null;\n      };\n    }).pipe(\n      Effect.catchCause((cause) =>\n        Effect.flatMap(\n          Effect.sync(() => {\n            unsubscribe?.();\n            unsubscribe = null;\n          }),\n          () => Effect.failCause(cause),",
    "checksum": "b271e39c3ccce7f5ba8015d4dc72f7ca64041d9d6ec6d4c91bdbbba668800ba9"
  },
  "workbench-asset-token-verification": {
    "id": "workbench-asset-token-verification",
    "path": "apps/server/src/assets/AssetAccess.ts",
    "start": 410,
    "end": 451,
    "language": "typescript",
    "label": "Asset URL signing followed by signature and expiry verification",
    "code": "          cause,\n        }),\n    ),\n  );\n  if (claims.kind === \"project-favicon\" || claims.kind === \"project-favicon-external\") {\n    const issuedAt = yield* Clock.currentTimeMillis;\n    expiresAt =\n      (Math.floor(issuedAt / PROJECT_FAVICON_TOKEN_BUCKET_MS) + 2) *\n      PROJECT_FAVICON_TOKEN_BUCKET_MS;\n    claims = { ...claims, expiresAt };\n  }\n  const encodedPayload = base64UrlEncode(encodeAssetClaims(claims));\n  const token = `${encodedPayload}.${signPayload(encodedPayload, signingSecret)}`;\n  return {\n    relativeUrl: `${ASSET_ROUTE_PREFIX}/${token}/${encodeURIComponent(fileName)}`,\n    expiresAt,\n    ...(sourcePath !== undefined ? { sourcePath } : {}),\n  };\n});\n\nexport const resolveAsset = Effect.fn(\"AssetAccess.resolveAsset\")(function* (\n  token: string,\n  relativePath: string,\n) {\n  const [encodedPayload, signature] = token.split(\".\");\n  if (!encodedPayload || !signature) return null;\n\n  const secretStore = yield* ServerSecretStore.ServerSecretStore;\n  const signingSecret = yield* secretStore.getOrCreateRandom(SIGNING_SECRET_NAME, 32).pipe(\n    Effect.tapError((cause) => Effect.logError(\"Failed to load the asset signing key.\", { cause })),\n    Effect.orElseSucceed(() => null),\n  );\n  if (!signingSecret) return null;\n  if (!timingSafeEqualBase64Url(signature, signPayload(encodedPayload, signingSecret))) return null;\n\n  const claims = decodeClaims(encodedPayload);\n  if (!claims || claims.expiresAt <= (yield* Clock.currentTimeMillis)) return null;\n\n  if (claims.kind === \"attachment\") {\n    const config = yield* ServerConfig.ServerConfig;\n    const attachmentPath = resolveAttachmentPathById({\n      attachmentsDir: config.attachmentsDir,",
    "checksum": "27cc3e4c869c07078758c87260ae1f162edb77abdb33fd820bf5a612faef5e3a"
  },
  "workbench-mcp-credential-issue": {
    "id": "workbench-mcp-credential-issue",
    "path": "apps/server/src/mcp/McpSessionRegistry.ts",
    "start": 112,
    "end": 168,
    "language": "typescript",
    "label": "Random MCP bearer credential and registry-generated scoped session identity",
    "code": "    const next = new Map(\n      Array.from(records).filter(\n        ([, record]) => timestamp - record.lastAliveAt <= livenessWindowMs,\n      ),\n    );\n    return next.size === records.size ? records : next;\n  };\n\n  const issue: McpSessionRegistryShape[\"issue\"] = Effect.fn(\"McpSessionRegistry.issue\")(\n    function* (request) {\n      const issuedAt = yield* currentTimeMillis;\n      const providerSessionId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);\n      const rawToken = yield* crypto.randomBytes(32).pipe(Effect.map(tokenFromBytes), Effect.orDie);\n      const tokenHash = yield* hashToken(rawToken);\n      const scope: McpInvocationContext.McpInvocationScope = {\n        environmentId,\n        threadId: ThreadId.make(request.threadId),\n        providerSessionId,\n        providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),\n        capabilities: new Set([\"preview\"]),\n        issuedAt,\n      };\n      yield* SynchronizedRef.update(state, ({ records }) => {\n        const next = new Map(pruneDead(records, issuedAt));\n        next.set(tokenHash, { tokenHash, scope, lastAliveAt: issuedAt });\n        return { records: next };\n      });\n      return {\n        config: {\n          environmentId,\n          threadId: scope.threadId,\n          providerSessionId,\n          providerInstanceId: scope.providerInstanceId,\n          endpoint,\n          authorizationHeader: `Bearer ${rawToken}`,\n        },\n      };\n    },\n  );\n\n  const resolve: McpSessionRegistryShape[\"resolve\"] = Effect.fn(\"McpSessionRegistry.resolve\")(\n    function* (rawToken) {\n      if (rawToken.length === 0) return undefined;\n      const tokenHash = yield* hashToken(rawToken);\n      const timestamp = yield* currentTimeMillis;\n      return yield* SynchronizedRef.modify(state, ({ records }) => {\n        const current = pruneDead(records, timestamp);\n        const record = current.get(tokenHash);\n        if (!record) return [undefined, { records: current }] as const;\n        const next = new Map(current);\n        next.set(tokenHash, { ...record, lastAliveAt: timestamp });\n        return [record.scope, { records: next }] as const;\n      });\n    },\n  );\n\n  const touch: McpSessionRegistryShape[\"touch\"] = Effect.fn(\"McpSessionRegistry.touch\")(",
    "checksum": "1c72aab293661e234f0a570d76f7c90b77c75b4982796ae2258b258060022cb0"
  },
  "workbench-pr-write-gates": {
    "id": "workbench-pr-write-gates",
    "path": "apps/server/src/pullRequest/PullRequestService.ts",
    "start": 1300,
    "end": 1367,
    "language": "typescript",
    "label": "Pull-request host capability checks followed by fresh viewer authorization",
    "code": "  const runAction: PullRequestService[\"Service\"][\"runAction\"] = (input) =>\n    requireProject(input).pipe(\n      Effect.flatMap((project): Effect.Effect<void, PullRequestError> => {\n        // The surface hides what a host cannot do, and this refuses it as well: a request that\n        // reached here anyway must not be handed to a provider that never claimed the action.\n        if (!project.api.capabilities.actions.includes(input.action)) {\n          return Effect.fail(\n            new PullRequestOperationError({\n              operation: \"runAction\",\n              detail: `This host cannot ${input.action} a change request.`,\n            }),\n          );\n        }\n        // A strategy the host does not offer must be refused rather than passed on: every\n        // provider maps an unrecognised method to its own default, so asking Azure DevOps to\n        // rebase would quietly merge instead of failing.\n        if (\n          input.mergeMethod !== undefined &&\n          !project.api.capabilities.mergeMethods.includes(input.mergeMethod)\n        ) {\n          return Effect.fail(\n            new PullRequestOperationError({\n              operation: \"runAction\",\n              detail: `This host cannot merge with the ${input.mergeMethod} strategy.`,\n            }),\n          );\n        }\n        // The same for the way a stale branch is brought up to date: a host that only merges\n        // must not be asked to rebase and left to pick something else.\n        if (\n          input.updateMethod !== undefined &&\n          !(project.api.capabilities.updateMethods ?? []).includes(input.updateMethod)\n        ) {\n          return Effect.fail(\n            new PullRequestOperationError({\n              operation: \"runAction\",\n              detail: `This host cannot update a branch by ${input.updateMethod}.`,\n            }),\n          );\n        }\n        // What the host can do and what this account may ask of it are two questions, and both\n        // have to say yes. The second is asked last, because it costs a request and the checks\n        // above do not.\n        return viewerPermissionsOf(project, input, \"runAction\").pipe(\n          Effect.flatMap((viewer): Effect.Effect<void, PullRequestError> => {\n            if (!viewer.actions.includes(input.action)) {\n              return Effect.fail(\n                new PullRequestOperationError({\n                  operation: \"runAction\",\n                  detail: ACTION_ACCESS_REFUSALS[input.action],\n                }),\n              );\n            }\n            if (\n              input.updateMethod !== undefined &&\n              !(viewer.updateMethods ?? []).includes(input.updateMethod)\n            ) {\n              return Effect.fail(\n                new PullRequestOperationError({\n                  operation: \"runAction\",\n                  detail: ACTION_ACCESS_REFUSALS[\"update-branch\"],\n                }),\n              );\n            }\n            return project.api\n              .runAction({\n                cwd: project.project.workspaceRoot,\n                repository: project.repository,",
    "checksum": "a76b545059b2edbfff26945859bf1c0085707d87b6d1d2ee395be300619adc6a"
  },
  "project-script-import-flow": {
    "id": "project-script-import-flow",
    "path": "apps/web/src/components/ProjectScriptsControl.tsx",
    "start": 80,
    "end": 150,
    "language": "tsx",
    "label": "Checked-in t3.json actions are deduplicated import suggestions",
    "code": "  const importableScripts = useMemo(\n    () =>\n      fileScripts.filter(\n        (fileScript) =>\n          !scripts.some(\n            (script) =>\n              script.command === fileScript.command ||\n              script.name.toLowerCase() === fileScript.name.toLowerCase(),\n          ),\n      ),\n    [fileScripts, scripts],\n  );\n  const dropdownItemClassName =\n    \"data-highlighted:bg-transparent data-highlighted:text-foreground hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground data-highlighted:hover:bg-accent data-highlighted:hover:text-accent-foreground data-highlighted:focus-visible:bg-accent data-highlighted:focus-visible:text-accent-foreground\";\n\n  const openAddDialog = () => {\n    setEditorRequest({ scriptId: null, initial: EMPTY_PROJECT_SCRIPT_INPUT });\n  };\n\n  const openEditDialog = (script: ProjectScript) => {\n    setActionsMenuOpen({ scripts: false, imports: false });\n    setEditorRequest(editorRequestForScript(script, keybindings));\n  };\n\n  const submitScript = useCallback(\n    (scriptId: string | null, input: NewProjectScriptInput) =>\n      scriptId === null ? onAddScript(input) : onUpdateScript(scriptId, input),\n    [onAddScript, onUpdateScript],\n  );\n\n  const importFileScript = async (fileScript: T3ProjectFileScript) => {\n    const payload: NewProjectScriptInput = {\n      name: fileScript.name,\n      command: fileScript.command,\n      icon: fileScript.icon ?? \"play\",\n      runOnWorktreeCreate: fileScript.runOnWorktreeCreate ?? false,\n      keybinding: null,\n      previewUrl: fileScript.previewUrl ?? null,\n      autoOpenPreview: fileScript.previewUrl ? (fileScript.autoOpenPreview ?? false) : false,\n    };\n    const result = await onAddScript(payload);\n    if (result._tag === \"Failure\" && !isAtomCommandInterrupted(result)) {\n      // Surface the failure through the regular add dialog, prefilled so the\n      // user can adjust and retry.\n      const error = squashAtomCommandFailure(result);\n      setEditorRequest({\n        scriptId: null,\n        initial: payload,\n        error: error instanceof Error ? error.message : \"Failed to import action.\",\n      });\n    }\n  };\n\n  const importMenuItems = importableScripts.length > 0 && (\n    <>\n      {primaryScript && <MenuSeparator />}\n      <MenuGroup>\n        <MenuGroupLabel>From t3.json</MenuGroupLabel>\n        {importableScripts.map((fileScript) => (\n          <MenuItem\n            key={`${fileScript.name} ${fileScript.command}`}\n            className={dropdownItemClassName}\n            onClick={() => void importFileScript(fileScript)}\n          >\n            <ScriptIcon icon={fileScript.icon ?? \"play\"} className=\"size-4\" />\n            <span className=\"truncate\">{fileScript.name}</span>\n            <MenuShortcut className=\"ms-auto\">\n              <DownloadIcon className=\"size-3.5\" aria-label=\"Import\" />\n            </MenuShortcut>\n          </MenuItem>\n        ))}",
    "checksum": "a21e41ea3772e4d8fafeaae8d60da9b9101bcc26a4891e02ec8283b31351b603"
  },
  "web-main-runtime-entry": {
    "id": "web-main-runtime-entry",
    "path": "apps/web/src/main.tsx",
    "start": 1,
    "end": 61,
    "language": "tsx",
    "label": "Electron-aware history and authenticated React entry",
    "code": "import React from \"react\";\nimport ReactDOM from \"react-dom/client\";\nimport { ClerkProvider } from \"@clerk/react\";\nimport { passkeys } from \"@clerk/electron/passkeys\";\nimport { ClerkProvider as ElectronClerkProvider } from \"@clerk/electron/react\";\nimport { createHashHistory, createBrowserHistory } from \"@tanstack/react-router\";\n\nimport \"./index.css\";\n\nimport { isElectron } from \"./env\";\nimport { ManagedRelayAuthProvider } from \"./cloud/managedAuth\";\nimport { hasCloudPublicConfig } from \"./cloud/publicConfig\";\nimport { getRouter } from \"./router\";\nimport {\n  syncDocumentElectronPlatformClasses,\n  syncDocumentWindowControlsOverlayClass,\n} from \"./lib/windowControlsOverlay\";\nimport { AppRoot } from \"./AppRoot\";\nimport { clerkAppearance } from \"./components/clerk/clerkAppearance\";\n\n// Electron loads the app from a file-backed shell, so hash history avoids path resolution issues.\nconst history = isElectron ? createHashHistory() : createBrowserHistory();\n\nconst router = getRouter(history);\n\nif (isElectron) {\n  syncDocumentElectronPlatformClasses(navigator.platform);\n  syncDocumentWindowControlsOverlayClass();\n}\n\nconst clerkPublishableKey = import.meta.env.VITE_CLERK_PUBLISHABLE_KEY as string | undefined;\n\n// First Clerk UI build containing https://github.com/clerk/javascript/pull/9500.\nconst electronClerkUI = {\n  __internal_clerkUIVersion: \"1.30.5-canary.v20260819050620\",\n};\n\nconst app = <AppRoot router={router} />;\n\nReactDOM.createRoot(document.getElementById(\"root\") as HTMLElement).render(\n  <React.StrictMode>\n    {clerkPublishableKey && hasCloudPublicConfig() ? (\n      isElectron ? (\n        <ElectronClerkProvider\n          {...electronClerkUI}\n          appearance={clerkAppearance}\n          publishableKey={clerkPublishableKey}\n          passkeys={passkeys}\n        >\n          <ManagedRelayAuthProvider>{app}</ManagedRelayAuthProvider>\n        </ElectronClerkProvider>\n      ) : (\n        <ClerkProvider appearance={clerkAppearance} publishableKey={clerkPublishableKey}>\n          <ManagedRelayAuthProvider>{app}</ManagedRelayAuthProvider>\n        </ClerkProvider>\n      )\n    ) : (\n      app\n    )}\n  </React.StrictMode>,\n);",
    "checksum": "469fcbadd4accb57b28f26730ae794e728586908360a345a42ebe3d8dd708f4d"
  },
  "web-app-root-providers": {
    "id": "web-app-root-providers",
    "path": "apps/web/src/AppRoot.tsx",
    "start": 1,
    "end": 23,
    "language": "tsx",
    "label": "Shared atom registry and route-persistent renderer hosts",
    "code": "import { RouterProvider } from \"@tanstack/react-router\";\n\nimport { ElectronBrowserHost } from \"./browser/ElectronBrowserHost\";\nimport { PreviewAutomationHosts } from \"./components/preview/PreviewAutomationHosts\";\nimport { QuitHoldOverlay } from \"./components/QuitHoldOverlay\";\nimport { AppAtomRegistryProvider } from \"./rpc/atomRegistry\";\nimport type { AppRouter } from \"./router\";\n\n/**\n * Owns renderer-wide providers. The Electron browser host intentionally sits\n * outside the router so its webviews survive route transitions, but it must\n * share the same atom registry as routed UI.\n */\nexport function AppRoot({ router }: { readonly router: AppRouter }) {\n  return (\n    <AppAtomRegistryProvider>\n      <RouterProvider router={router} />\n      <PreviewAutomationHosts />\n      <ElectronBrowserHost />\n      <QuitHoldOverlay />\n    </AppAtomRegistryProvider>\n  );\n}",
    "checksum": "73f37a466b15084db5148de417c21c833ee135b61b66e955032c4d47d8537b48"
  },
  "web-router-composition": {
    "id": "web-router-composition",
    "path": "apps/web/src/router.ts",
    "start": 1,
    "end": 20,
    "language": "typescript",
    "label": "Generated route-tree router construction",
    "code": "import { createRouter, RouterHistory } from \"@tanstack/react-router\";\n\nimport { routeTree } from \"./routeTree.gen\";\n\nexport function getRouter(history: RouterHistory) {\n  return createRouter({\n    routeTree,\n    history,\n    context: {},\n  });\n}\n\nexport type AppRouter = ReturnType<typeof getRouter>;\n\ndeclare module \"@tanstack/react-router\" {\n  interface Register {\n    router: AppRouter;\n  }\n}\n",
    "checksum": "0327fd93597b643fc4e5addbe87d4d74fa8a7310fca94e256569285cf8836979"
  },
  "web-environment-atom-catalog": {
    "id": "web-environment-atom-catalog",
    "path": "apps/web/src/connection/catalog.ts",
    "start": 1,
    "end": 5,
    "language": "typescript",
    "label": "Web environment catalog uses the shared atom runtime",
    "code": "import { createEnvironmentCatalogAtoms } from \"@t3tools/client-runtime/state/connections\";\n\nimport { connectionAtomRuntime } from \"./runtime\";\n\nexport const environmentCatalog = createEnvironmentCatalogAtoms(connectionAtomRuntime);",
    "checksum": "94a883ffc47ef7abafabccb826775bb943383795beb4b3e65b75c15604ce5124"
  },
  "web-environment-session-atoms": {
    "id": "web-environment-session-atoms",
    "path": "apps/web/src/state/session.ts",
    "start": 7,
    "end": 41,
    "language": "typescript",
    "label": "Per-environment prepared connection and session atoms",
    "code": "import { connectionAtomRuntime } from \"../connection/runtime\";\nimport { appAtomRegistry } from \"../rpc/atomRegistry\";\n\nexport const environmentSession = createEnvironmentSessionAtoms(connectionAtomRuntime);\n\nconst EMPTY_PREPARED_CONNECTION_ATOM = Atom.make(Option.none()).pipe(\n  Atom.withLabel(\"web-prepared-connection:empty\"),\n);\n\nexport function usePreparedConnection(environmentId: EnvironmentId | null) {\n  return useAtomValue(\n    environmentId === null\n      ? EMPTY_PREPARED_CONNECTION_ATOM\n      : environmentSession.preparedConnectionValueAtom(environmentId),\n  );\n}\n\nexport function readPreparedConnection(environmentId: EnvironmentId) {\n  return Option.getOrNull(\n    appAtomRegistry.get(environmentSession.preparedConnectionValueAtom(environmentId)),\n  );\n}\n\n/**\n * This client's authenticated session on one environment, as reported by that\n * environment's `/api/auth/session` endpoint. `data` stays populated across\n * SWR revalidations; `isPending` is only meaningful before the first resolve.\n */\nexport function useEnvironmentSessionState(environmentId: EnvironmentId) {\n  const result = useAtomValue(environmentSession.sessionStateAtom(environmentId));\n  return {\n    data: Option.getOrNull(AsyncResult.value(result)),\n    hasError: result._tag === \"Failure\",\n    isPending: result.waiting,\n  };",
    "checksum": "cb1d832614b303c2cfbc77120eda1b5f34b9de30e2027c19db0b0e98dfae198e"
  },
  "web-timeline-list-virtualization": {
    "id": "web-timeline-list-virtualization",
    "path": "apps/web/src/components/chat/MessagesTimeline.tsx",
    "start": 570,
    "end": 648,
    "language": "tsx",
    "label": "Keyed virtualized message timeline configuration",
    "code": "  if (rows.length === 0 && !isWorking) {\n    if (hideEmptyPlaceholder) {\n      return null;\n    }\n    return (\n      <div className=\"flex h-full items-center justify-center\">\n        <p className=\"text-placeholder text-sm\">Send a message to start the conversation.</p>\n      </div>\n    );\n  }\n\n  return (\n    <TimelineRowCtx value={sharedState}>\n      <TimelineRowActivityCtx value={activityState}>\n        <div ref={setTimelineViewportElement} className=\"relative h-full min-h-0\">\n          <LegendList<MessagesTimelineRow>\n            ref={listRef}\n            data={rows}\n            keyExtractor={keyExtractor}\n            getItemType={getItemType}\n            renderItem={renderItem}\n            estimatedItemSize={90}\n            initialScrollAtEnd\n            {...(anchoredEndSpace ? { anchoredEndSpace } : {})}\n            contentInsetEndAdjustment={contentInsetEndAdjustment}\n            maintainScrollAtEnd={\n              anchoredEndSpace || !liveFollowEnabled || disclosureToggleSettling\n                ? false\n                : TIMELINE_MAINTAIN_SCROLL_AT_END\n            }\n            maintainVisibleContentPosition={maintainVisibleContentPosition}\n            onScroll={handleScroll}\n            className={cn(\n              \"scrollbar-gutter-both h-full min-h-0 overflow-x-hidden overscroll-y-contain px-3 [overflow-anchor:none] sm:px-5\",\n              topFadeEnabled && \"topbar-scroll-fade\",\n            )}\n            ListHeaderComponent={\n              loadEarlier !== null ? (\n                <TimelineLoadEarlierHeader\n                  loading={loadEarlier.loading}\n                  onLoadEarlier={loadEarlier.onLoadEarlier}\n                  fade={topFadeEnabled}\n                />\n              ) : topFadeEnabled ? (\n                TIMELINE_LIST_FADE_HEADER\n              ) : (\n                TIMELINE_LIST_HEADER\n              )\n            }\n            ListFooterComponent={TIMELINE_LIST_FOOTER}\n          />\n          <TimelineMinimap\n            items={minimapItems}\n            hasPersistentGutter={minimapHasPersistentGutter}\n            hitStripWidth={minimapHitStripWidth}\n            stripMap={minimapStripMap}\n            onSelect={(item) => {\n              onManualNavigation();\n              void listRef.current?.scrollToIndex({\n                index: item.rowIndex,\n                animated: true,\n                viewOffset: 24,\n              });\n            }}\n          />\n        </div>\n      </TimelineRowActivityCtx>\n    </TimelineRowCtx>\n  );\n});\n\nfunction keyExtractor(item: MessagesTimelineRow) {\n  return item.id;\n}\n\nfunction getItemType(item: MessagesTimelineRow) {\n  return item.kind === \"message\" ? `message:${item.message.role}` : item.kind;\n}\n",
    "checksum": "ad64d1e19d070fdd16b99a02269619f65b85df48b309607f10b58fb156a6832e"
  },
  "web-timeline-row-structural-sharing": {
    "id": "web-timeline-row-structural-sharing",
    "path": "apps/web/src/components/chat/MessagesTimeline.tsx",
    "start": 2095,
    "end": 2113,
    "language": "tsx",
    "label": "Timeline row structural sharing for virtualized memo boundaries",
    "code": "// so LegendList (and React) can skip re-rendering unchanged items.\n// ---------------------------------------------------------------------------\n\n/** Returns a structurally-shared copy of `rows`: for each row whose content\n *  hasn't changed since last call, the previous object reference is reused. */\nfunction useStableRows(rows: MessagesTimelineRow[]): MessagesTimelineRow[] {\n  const prevState = useRef<StableMessagesTimelineRowsState>({\n    byId: new Map<string, MessagesTimelineRow>(),\n    result: [],\n  });\n\n  return useMemo(() => {\n    const nextState = computeStableMessagesTimelineRows(rows, prevState.current);\n    prevState.current = nextState;\n    return nextState.result;\n  }, [rows]);\n}\n\n// ---------------------------------------------------------------------------",
    "checksum": "74026e988767cb072249b769001abbf35b59542f6245e824e2fefdb2fbbe8ffc"
  },
  "web-sidebar-row-locality": {
    "id": "web-sidebar-row-locality",
    "path": "apps/web/src/components/Sidebar.tsx",
    "start": 2200,
    "end": 2252,
    "language": "tsx",
    "label": "Sidebar streaming row locality and callback references",
    "code": "    SNOOZED_SHELF_EXPANDED_KEY,\n    false,\n    Schema.Boolean,\n  );\n  const toggleSnoozedShelf = useCallback(\n    () => setSnoozedShelfExpanded((value) => !value),\n    [setSnoozedShelfExpanded],\n  );\n  const visibleSnoozedThreads = useMemo(() => {\n    if (snoozedShelfExpanded) return snoozedThreads;\n    // The open thread must never vanish behind the collapsed shelf: a\n    // snoozed thread reached by route (deep link, open before snoozing\n    // elsewhere) keeps its row — with highlight and wake affordance — same\n    // exception the settled tail's \"Show more\" makes.\n    if (routeThreadKey === null) return [];\n    const routeThread = snoozedThreads.find(\n      (thread) =>\n        scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)) === routeThreadKey,\n    );\n    return routeThread === undefined ? [] : [routeThread];\n  }, [routeThreadKey, snoozedShelfExpanded, snoozedThreads]);\n\n  const orderedThreads = useMemo(\n    () => [...pinnedThreads, ...activeThreads, ...visibleSnoozedThreads, ...renderedSettledThreads],\n    [pinnedThreads, activeThreads, visibleSnoozedThreads, renderedSettledThreads],\n  );\n  const orderedThreadKeys = useMemo(\n    () =>\n      orderedThreads.map((thread) =>\n        scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),\n      ),\n    [orderedThreads],\n  );\n  // Rows call back into the click handler without carrying the ordered list as\n  // a prop — a fresh array identity per shell update would defeat every row's\n  // memoization. The ref keeps shift-range-select working against the list as\n  // rendered at click time.\n  const orderedThreadKeysRef = useRef(orderedThreadKeys);\n  orderedThreadKeysRef.current = orderedThreadKeys;\n  const threadByKey = useMemo(\n    () =>\n      new Map(\n        orderedThreads.map(\n          (thread) =>\n            [scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), thread] as const,\n        ),\n      ),\n    [orderedThreads],\n  );\n  // Handlers read these through refs: depending on per-update Map/Set\n  // identities would give every row a fresh callback prop on each shell\n  // event and defeat row memoization during streaming.\n  const threadByKeyRef = useRef(threadByKey);",
    "checksum": "0ca7fefcf227ef98a2738f7ce0001d6889c5b1e1e7a76701cdaab7ad1d3ed2ae"
  },
  "web-client-tracing-export": {
    "id": "web-client-tracing-export",
    "path": "apps/web/src/observability/clientTracing.ts",
    "start": 15,
    "end": 96,
    "language": "typescript",
    "label": "Primary-environment OTLP client tracing lifecycle",
    "code": "\nconst DEFAULT_EXPORT_INTERVAL_MS = 1_000;\nconst CLIENT_TRACING_RESOURCE = {\n  serviceName: \"t3-web\",\n  attributes: {\n    \"service.runtime\": \"t3-web\",\n    \"service.mode\": isElectron ? \"electron\" : \"browser\",\n    \"service.version\": APP_VERSION,\n  },\n} as const;\n\nconst delegateRuntimeLayer = Layer.mergeAll(\n  primaryEnvironmentHttpLayer,\n  OtlpExporter.layerFlusher,\n  OtlpSerialization.layerJson,\n  Layer.succeed(HttpClient.TracerDisabledWhen, () => true),\n);\n\nlet activeDelegate: Tracer.Tracer | null = null;\nlet activeRuntime: ManagedRuntime.ManagedRuntime<never, never> | null = null;\nlet activeScope: Scope.Closeable | null = null;\nlet activeConfigKey: string | null = null;\nlet configurationGeneration = 0;\nlet pendingConfiguration = Promise.resolve();\n\nexport interface ClientTracingConfig {\n  readonly exportIntervalMs?: number;\n}\n\nexport const ClientTracingLive = Layer.succeed(\n  Tracer.Tracer,\n  Tracer.make({\n    span(options) {\n      return activeDelegate?.span(options) ?? new Tracer.NativeSpan(options);\n    },\n  }),\n);\n\nexport function configureClientTracing(config: ClientTracingConfig = {}): Promise<void> {\n  if (config.exportIntervalMs === undefined && activeConfigKey !== null) {\n    return pendingConfiguration;\n  }\n  pendingConfiguration = pendingConfiguration.finally(() => applyClientTracingConfig(config));\n  return pendingConfiguration;\n}\n\nasync function applyClientTracingConfig(config: ClientTracingConfig): Promise<void> {\n  const otlpTracesUrl = resolvePrimaryEnvironmentHttpUrl(\"/api/observability/v1/traces\");\n  const exportIntervalMs = Math.max(10, config.exportIntervalMs ?? DEFAULT_EXPORT_INTERVAL_MS);\n  const nextConfigKey = `${otlpTracesUrl}|${exportIntervalMs}`;\n\n  if (activeConfigKey === nextConfigKey && activeDelegate !== null) {\n    return;\n  }\n\n  activeConfigKey = nextConfigKey;\n  const generation = ++configurationGeneration;\n\n  const previousRuntime = activeRuntime;\n  const previousScope = activeScope;\n\n  activeDelegate = null;\n  activeRuntime = null;\n  activeScope = null;\n\n  await disposeTracerRuntime(previousRuntime, previousScope);\n\n  const runtime = ManagedRuntime.make(delegateRuntimeLayer);\n  const scope = runtime.runSync(Scope.make());\n\n  const delegateResult = await settleAsyncResult(() =>\n    runtime.runPromiseExit(\n      Scope.provide(scope)(\n        OtlpTracer.make({\n          url: otlpTracesUrl,\n          exportInterval: `${exportIntervalMs} millis`,\n          resource: CLIENT_TRACING_RESOURCE,\n        }),\n      ),\n    ),\n  );\n  if (delegateResult._tag === \"Failure\") {",
    "checksum": "ea79ca0af49221763e5a8a63f3964a422be6f57b8bf234cea9115c51800954d5"
  },
  "web-sidebar-optimistic-pinning": {
    "id": "web-sidebar-optimistic-pinning",
    "path": "apps/web/src/components/Sidebar.tsx",
    "start": 2554,
    "end": 2610,
    "language": "tsx",
    "label": "Optimistic pin-order override and canonical surrender rules",
    "code": "  // and holding it would launder a stale order into later drags.\n  const pinnedDndSensors = useSensors(\n    useSensor(PointerSensor, { activationConstraint: { distance: 6 } }),\n  );\n  const [optimisticPinnedOrder, setOptimisticPinnedOrder] = useState<{\n    readonly order: readonly string[];\n    /** pinOrderKey per thread as of the drop — the baseline that tells a\n        concurrent client's write apart from one of our own landing. */\n    readonly keysAtDrop: ReadonlyMap<string, string | null>;\n    /** The keys this drop writes (one per planned assignment). The\n        override holds until all of them appear in canonical state. */\n    readonly assignedKeys: ReadonlyMap<string, string>;\n  } | null>(null);\n  const orderedPinnedThreads = useMemo(() => {\n    if (optimisticPinnedOrder === null) return pinnedThreads;\n    return orderItemsByPreferredIds({\n      items: pinnedThreads,\n      preferredIds: optimisticPinnedOrder.order,\n      getId: (thread) => scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),\n    });\n  }, [optimisticPinnedOrder, pinnedThreads]);\n  useEffect(() => {\n    if (optimisticPinnedOrder === null) return;\n    const canonical = pinnedThreads.filter((thread) =>\n      reorderablePinnedKeys.has(scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id))),\n    );\n    const canonicalKeys = canonical.map((thread) =>\n      scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),\n    );\n    // The override represents one drop against one snapshot of the world.\n    // Release it when the world moves on: membership changed (pin/unpin/\n    // snooze/wake — the override can't say where members it never saw\n    // belong), a key changed to something we did NOT write (a concurrent\n    // client's reorder that must win), every key we wrote has landed, or\n    // canonical already matches. Releasing on the FIRST landed key instead\n    // of the last exposes the half-written order mid-materialization and\n    // the block visibly reshuffles once per write.\n    const membershipChanged =\n      canonicalKeys.length !== optimisticPinnedOrder.order.length ||\n      canonicalKeys.some((key) => !optimisticPinnedOrder.order.includes(key));\n    const foreignKeyLanded = canonical.some((thread, index) => {\n      const threadKey = canonicalKeys[index]!;\n      const currentKey = thread.pinOrderKey ?? null;\n      if (currentKey === optimisticPinnedOrder.keysAtDrop.get(threadKey)) return false;\n      return currentKey !== optimisticPinnedOrder.assignedKeys.get(threadKey);\n    });\n    const currentKeyByThreadKey = new Map(\n      canonical.map((thread, index) => [canonicalKeys[index]!, thread.pinOrderKey ?? null]),\n    );\n    const allAssignmentsLanded = [...optimisticPinnedOrder.assignedKeys].every(\n      ([threadKey, orderKey]) => currentKeyByThreadKey.get(threadKey) === orderKey,\n    );\n    const orderConfirmed =\n      !membershipChanged &&\n      canonicalKeys.every((key, index) => key === optimisticPinnedOrder.order[index]);\n    if (membershipChanged || foreignKeyLanded || allAssignmentsLanded || orderConfirmed) {\n      setOptimisticPinnedOrder(null);",
    "checksum": "587d2e08f3d5f4a8193054fcd9c8afa66b3c80d57456718f2adcdee4ffa71836"
  },
  "mobile-app-root-composition": {
    "id": "mobile-app-root-composition",
    "path": "apps/mobile/src/App.tsx",
    "start": 61,
    "end": 106,
    "language": "tsx",
    "label": "Mobile root Atom, provider, navigation, and native host composition",
    "code": "export default function App() {\n  return (\n    <RegistryContext.Provider value={appAtomRegistry}>\n      <CloudAuthProvider>\n        <AppearancePreferencesProvider>\n          <AppContent />\n        </AppearancePreferencesProvider>\n      </CloudAuthProvider>\n    </RegistryContext.Provider>\n  );\n}\n\nfunction AppContent() {\n  const { themeAppearance } = useAppearancePreferences();\n  const statusBarBg = useThemeColor(\"--color-status-bar\");\n  const navigationTheme = useMobileNavigationTheme(themeAppearance);\n\n  return (\n    <>\n      <SplashScreenCoordinator />\n      <GestureHandlerRootView className=\"flex-1\">\n        <KeyboardProvider statusBarTranslucent>\n          <SafeAreaProvider>\n            <StatusBar\n              barStyle={themeAppearance === \"dark\" ? \"light-content\" : \"dark-content\"}\n              backgroundColor={statusBarBg}\n              translucent\n            />\n            {/* The navigation theme drives the NATIVE header appearance: native-stack\n                forwards `dark` as the nav bar's overrideUserInterfaceStyle. Without\n                this, React Navigation defaults to its light theme and every native\n                header (glass buttons, title, materials) is forced light even when\n                the system is in dark mode. */}\n            {/* Blur target for Android dropdown backdrops — see appBlurTarget.ts. */}\n            <BlurTargetView ref={appBlurTargetRef} style={{ flex: 1 }}>\n              <IncomingShareProvider>\n                <Navigation linking={appLinking} theme={navigationTheme} />\n              </IncomingShareProvider>\n              <ConfirmDialogHost />\n            </BlurTargetView>\n            {/* Anchored-menu overlays render here — in-window, so the\n                keyboard stays up while a dropdown is open. */}\n            <OverlayPortalHost />\n          </SafeAreaProvider>\n        </KeyboardProvider>\n      </GestureHandlerRootView>",
    "checksum": "46115b33d72272b987a9b97658d848d7e5fd73e991f885c285a6c2ff369725fd"
  },
  "mobile-connection-runtime-layer": {
    "id": "mobile-connection-runtime-layer",
    "path": "apps/mobile/src/connection/runtime.ts",
    "start": 1,
    "end": 45,
    "language": "typescript",
    "label": "Shared connection and snapshot layers with mobile platform services",
    "code": "import { Connection } from \"@t3tools/client-runtime/connection\";\nimport { shellSnapshotLoaderLayer } from \"@t3tools/client-runtime/state/shell\";\nimport { threadSnapshotLoaderLayer } from \"@t3tools/client-runtime/state/threads\";\nimport * as Layer from \"effect/Layer\";\nimport { Atom } from \"effect/unstable/reactivity\";\n\nimport { runtimeContextLayer } from \"../lib/runtime\";\nimport {\n  mobileBackgroundActivityObserverLayer,\n  mobileBackgroundActivityReporterLayer,\n} from \"./background-activity\";\nimport { connectionPlatformLayer } from \"./platform\";\n\nconst providedConnectionPlatformLayer = connectionPlatformLayer.pipe(\n  Layer.provide(runtimeContextLayer),\n);\n\nconst snapshotLoaderLayer = Layer.merge(threadSnapshotLoaderLayer, shellSnapshotLoaderLayer);\n\ntype ConnectionLayerSource =\n  | typeof Connection.layer\n  | typeof snapshotLoaderLayer\n  | typeof runtimeContextLayer\n  | typeof connectionPlatformLayer\n  | typeof mobileBackgroundActivityObserverLayer\n  | typeof mobileBackgroundActivityReporterLayer;\n\nconst providedClientConnectionLayer = Layer.merge(Connection.layer, snapshotLoaderLayer).pipe(\n  Layer.provideMerge(\n    Layer.mergeAll(\n      runtimeContextLayer,\n      providedConnectionPlatformLayer,\n      mobileBackgroundActivityObserverLayer,\n    ),\n  ),\n);\n\nconst connectionLayer = mobileBackgroundActivityReporterLayer.pipe(\n  Layer.provideMerge(providedClientConnectionLayer),\n);\n\nexport const connectionAtomRuntime: Atom.AtomRuntime<\n  Layer.Success<ConnectionLayerSource>,\n  Layer.Error<ConnectionLayerSource>\n> = Atom.runtime(connectionLayer);",
    "checksum": "b65580b503a79da712a1398f7ef6988f434ec21193c7223eca5edbf597857db4"
  },
  "mobile-persistence-schema": {
    "id": "mobile-persistence-schema",
    "path": "apps/mobile/src/persistence/mobile-database.ts",
    "start": 242,
    "end": 275,
    "language": "typescript",
    "label": "SQLite client cache and preference schema with versioned migration",
    "code": "  yield* Effect.tryPromise({\n    try: async () => {\n      await database.execAsync(\"PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;\");\n      const schema = await database.getFirstAsync<{ readonly user_version: number }>(\n        \"PRAGMA user_version\",\n      );\n      await database.withExclusiveTransactionAsync(async (transaction) => {\n        await transaction.execAsync(`\n              CREATE TABLE IF NOT EXISTS client_cache (\n                environment_id TEXT NOT NULL,\n                kind TEXT NOT NULL,\n                cache_key TEXT NOT NULL,\n                schema_version INTEGER NOT NULL,\n                payload TEXT NOT NULL,\n                updated_at INTEGER NOT NULL,\n                PRIMARY KEY (environment_id, kind, cache_key)\n              ) WITHOUT ROWID;\n\n              CREATE INDEX IF NOT EXISTS client_cache_environment_updated\n                ON client_cache (environment_id, updated_at DESC);\n\n              CREATE TABLE IF NOT EXISTS client_preferences (\n                singleton INTEGER PRIMARY KEY NOT NULL CHECK (singleton = 1),\n                payload TEXT NOT NULL,\n                updated_at INTEGER NOT NULL\n              );\n            `);\n      });\n      if ((schema?.user_version ?? 0) < DATABASE_SCHEMA_VERSION) {\n        const migrated = await migrateLegacyFileCaches(database);\n        if (migrated) {\n          await database.execAsync(`PRAGMA user_version = ${DATABASE_SCHEMA_VERSION};`);\n        }\n      }",
    "checksum": "4c4f4137e909027a14ac1ec6e1724cfb765961790354b87747351df46910ecb0"
  },
  "mobile-draft-update-flush": {
    "id": "mobile-draft-update-flush",
    "path": "apps/mobile/src/state/use-composer-drafts.ts",
    "start": 212,
    "end": 229,
    "language": "typescript",
    "label": "Draft persistence flush before JavaScript runtime teardown",
    "code": "/**\n * Lands any debounced or in-flight draft write before the JS runtime is torn\n * down (app update restart), so the freshest draft state survives it. A write\n * failure propagates so the caller can decide whether the restart may proceed.\n */\nexport async function flushComposerDrafts(): Promise<void> {\n  // An edit during an awaited write schedules another debounced write, so\n  // keep landing snapshots until no debounce is pending after a queue drain.\n  do {\n    while (persistTimer !== null) {\n      clearTimeout(persistTimer);\n      persistTimer = null;\n      await persistenceQueue.run(() =>\n        writePersistedComposerDrafts(appAtomRegistry.get(composerDraftsAtom)),\n      );\n    }\n    await persistenceQueue.run(() => Promise.resolve());\n  } while (persistTimer !== null);",
    "checksum": "eae8cd0dee12f66549b90f8f01a1eca248189e6b8a1c0c5d7af1bc9ea281c576"
  },
  "mobile-outbox-optimistic-durability": {
    "id": "mobile-outbox-optimistic-durability",
    "path": "apps/mobile/src/state/thread-outbox-manager.ts",
    "start": 91,
    "end": 124,
    "language": "typescript",
    "label": "Optimistic enqueue, durable rollback, and pre-delivery confirmation",
    "code": "  // The queued atom drives the composer's immediate \"queued\" feedback, so it\n  // is published synchronously; the durable write happens behind it and rolls\n  // the message back out if it fails (durability only matters for crash\n  // recovery, not for the in-session queue).\n  const enqueue = (message: QueuedThreadMessage): Promise<void> => {\n    setMessages([\n      ...currentMessages().filter((candidate) => candidate.messageId !== message.messageId),\n      message,\n    ]);\n    return serialize(async () => {\n      try {\n        await options.storage.write(message);\n      } catch (cause) {\n        // Roll back by reference, not messageId: a retry enqueue with the same\n        // id may have optimistically replaced this attempt while the write was\n        // in flight, and its entry must survive this attempt's failure.\n        setMessages(currentMessages().filter((candidate) => candidate !== message));\n        throw new ThreadOutboxManagerError({\n          operation: \"enqueue\",\n          environmentId: message.environmentId,\n          threadId: message.threadId,\n          messageId: message.messageId,\n          cause,\n        });\n      }\n    });\n  };\n\n  // Resolves once all pending mutations (including any in-flight enqueue\n  // write) have settled, reporting whether the message is still queued. The\n  // drain awaits this before dispatching so a message whose durable write\n  // later fails can never have been delivered first.\n  const confirmQueued = (message: QueuedThreadMessage): Promise<boolean> =>\n    serialize(async () => currentMessages().some((candidate) => candidate === message));",
    "checksum": "616baa8c3ce65855265d73b8db622400fa95ca5b49951b6aa112a214a55dc21c"
  },
  "mobile-outbox-delivery-policy": {
    "id": "mobile-outbox-delivery-policy",
    "path": "apps/mobile/src/state/thread-outbox-model.ts",
    "start": 145,
    "end": 226,
    "language": "typescript",
    "label": "Outbox existence guards, capped backoff, and failure classification",
    "code": "export function threadOutboxRetryDelayMs(attempt: number): number {\n  return Math.min(1_000 * 2 ** Math.max(0, attempt - 1), THREAD_OUTBOX_MAX_RETRY_DELAY_MS);\n}\n\nexport type ThreadOutboxDeliveryAction = \"wait\" | \"remove\" | \"send\";\n\nexport function resolveThreadOutboxDeliveryAction(input: {\n  readonly isCreation: boolean;\n  readonly threadExists: boolean;\n  readonly shellStatus: EnvironmentShellStatus;\n  readonly environmentConnected: boolean;\n  readonly threadBusy: boolean;\n}): ThreadOutboxDeliveryAction {\n  if (input.isCreation) {\n    // A pending task creates its thread on delivery. If the thread already\n    // exists the creation command went through and only cleanup remains.\n    if (input.threadExists) {\n      return \"remove\";\n    }\n    // Wait for the shell to be live before sending: until the thread list has\n    // synchronized, a previously delivered creation whose cleanup failed would\n    // look missing and get re-issued, duplicating the thread.\n    return input.environmentConnected && input.shellStatus === \"live\" ? \"send\" : \"wait\";\n  }\n  if (!input.threadExists) {\n    return input.shellStatus === \"live\" ? \"remove\" : \"wait\";\n  }\n  return input.environmentConnected ? \"send\" : \"wait\";\n}\n\n/**\n * A queued creation can only be dispatched once its payload would pass server\n * validation; incomplete payloads stay pending until the user edits them.\n */\nexport function isQueuedThreadCreationSendable(message: QueuedThreadMessage): boolean {\n  if (!message.creation) {\n    return false;\n  }\n  if (message.text.trim().length === 0 || message.modelSelection === undefined) {\n    return false;\n  }\n  return message.creation.workspaceMode !== \"worktree\" || Boolean(message.creation.branch);\n}\n\nfunction errorMessage(error: unknown): string | null {\n  if (error instanceof Error) {\n    return error.message;\n  }\n  if (typeof error === \"object\" && error !== null && \"message\" in error) {\n    return typeof error.message === \"string\" ? error.message : null;\n  }\n  return typeof error === \"string\" ? error : null;\n}\n\nexport function shouldRetryThreadOutboxDelivery(error: unknown): boolean {\n  if (\n    typeof error === \"object\" &&\n    error !== null &&\n    \"_tag\" in error &&\n    error._tag === \"ConnectionTransientError\"\n  ) {\n    return true;\n  }\n  return isTransportConnectionErrorMessage(errorMessage(error));\n}\n\nexport type ThreadOutboxCommandStage = \"settings-sync\" | \"start-turn\";\nexport type ThreadOutboxFailureAction = \"retry\" | \"discard\";\n\nexport function resolveThreadOutboxFailureAction(input: {\n  readonly stage: ThreadOutboxCommandStage;\n  readonly error: unknown;\n  readonly interrupted: boolean;\n}): ThreadOutboxFailureAction {\n  if (\n    input.stage === \"settings-sync\" ||\n    input.interrupted ||\n    shouldRetryThreadOutboxDelivery(input.error)\n  ) {\n    return \"retry\";\n  }\n  return \"discard\";",
    "checksum": "d2969b0b428827e9c62ee69aaa4353ae90a097d523872d145dc0650edd68d6cf"
  },
  "mobile-share-commit-boundary": {
    "id": "mobile-share-commit-boundary",
    "path": "apps/mobile/src/features/sharing/incoming-share-inbox.ts",
    "start": 46,
    "end": 124,
    "language": "typescript",
    "label": "Durable share inbox write before native handoff acknowledgement",
    "code": "/**\n * Serializes every durable inbox mutation. This prevents a stale storage load\n * or a foreground refresh from restoring an item after it has been consumed.\n */\nexport class IncomingShareInbox {\n  private readonly operations = new SerializedAsyncQueue();\n\n  constructor(private readonly dependencies: IncomingShareInboxDependencies) {}\n\n  private runExclusive<T>(operation: () => Promise<T>): Promise<T> {\n    return this.operations.run(operation);\n  }\n\n  private clearNativePayloads(): void {\n    try {\n      this.dependencies.clearPayloads();\n    } catch (error) {\n      this.dependencies.onClearError?.(error);\n    }\n  }\n\n  private async cleanup(operation: () => Promise<void>): Promise<void> {\n    try {\n      await operation();\n    } catch (error) {\n      this.dependencies.onCleanupError?.(error);\n    }\n  }\n\n  refresh(options: { readonly ingestNative: boolean }): Promise<ReadonlyArray<IncomingShareDraft>> {\n    return this.runExclusive(async () => {\n      const loaded = await this.dependencies.loadDrafts();\n      const persisted = sortAndDedupeIncomingShares(loaded);\n      if (!options.ingestNative) {\n        return persisted;\n      }\n\n      const payloads = this.dependencies.getPayloads();\n      if (payloads.length === 0) {\n        return persisted;\n      }\n\n      // A share extension payload remains available until the containing app\n      // acknowledges it. Use a content-derived id so a crash after the durable\n      // write but before acknowledgement reuses the same inbox item.\n      const shareId = await this.dependencies.idForPayloads(payloads);\n      if (loaded.some((draft) => draft.id === shareId)) {\n        if (this.dependencies.cleanupReplayedPayloads) {\n          await this.cleanup(() => this.dependencies.cleanupReplayedPayloads!(payloads));\n        }\n        this.clearNativePayloads();\n        return persisted;\n      }\n\n      const built = await this.dependencies.buildDraft({\n        payloads,\n        id: shareId,\n        createdAt: this.dependencies.now(),\n      });\n      const { draft } = built;\n      if (!hasIncomingShareContent(draft)) {\n        // Unsupported native payloads cannot become actionable on retry and\n        // would otherwise reopen the project picker on every foreground.\n        await this.cleanup(built.cleanup);\n        this.clearNativePayloads();\n        throw new Error(\n          draft.warnings[0] ?? \"The shared content is not supported by the composer.\",\n        );\n      }\n\n      // The durable inbox write is the transaction boundary. Never clear the\n      // native handoff first: a process termination must leave one recoverable\n      // copy on one side of the boundary.\n      await this.dependencies.writeDraft(draft);\n      await this.cleanup(built.cleanup);\n      this.clearNativePayloads();\n      return sortAndDedupeIncomingShares([draft, ...persisted]);\n    });\n  }",
    "checksum": "0677f4b5f578d272ee74ec62dbb82f10bfbf9f0a1e7fb08a7aebd371b20e891e"
  },
  "mobile-native-surface-probe": {
    "id": "mobile-native-surface-probe",
    "path": "apps/mobile/src/features/terminal/nativeTerminalModule.ts",
    "start": 48,
    "end": 100,
    "language": "typescript",
    "label": "Optional native terminal resolution and compiled revision probe",
    "code": "export function resolveNativeTerminalSurfaceView(): ComponentType<NativeTerminalSurfaceProps> | null {\n  if (cachedNativeTerminalSurfaceView) {\n    return cachedNativeTerminalSurfaceView;\n  }\n\n  if (nativeTerminalSurfaceViewResolutionFailed) {\n    return null;\n  }\n\n  if (getExpoViewConfig(NATIVE_TERMINAL_MODULE_NAME) == null) {\n    return null;\n  }\n\n  try {\n    cachedNativeTerminalSurfaceView = requireNativeView<NativeTerminalSurfaceProps>(\n      NATIVE_TERMINAL_MODULE_NAME,\n    );\n  } catch (cause) {\n    nativeTerminalSurfaceViewResolutionFailed = true;\n    console.error(\n      new NativeViewResolutionError({\n        nativeModuleName: NATIVE_TERMINAL_MODULE_NAME,\n        cause,\n      }),\n    );\n    return null;\n  }\n\n  return cachedNativeTerminalSurfaceView ?? null;\n}\n\n/**\n * Revision of the native hardware-keyboard handling compiled into the installed binary,\n * or `null` when the binary predates the revision constant (or the module is missing).\n * Used in terminal debug logs to detect stale native builds.\n */\nexport function getNativeTerminalHardwareKeyRevision(): number | null {\n  try {\n    if (typeof requireOptionalNativeModule !== \"function\") {\n      return null;\n    }\n    const module = requireOptionalNativeModule<{ readonly hardwareKeyRevision?: number }>(\n      NATIVE_TERMINAL_MODULE_NAME,\n    );\n    return module?.hardwareKeyRevision ?? null;\n  } catch {\n    return null;\n  }\n}\n\nexport function hasNativeTerminalSurface() {\n  return resolveNativeTerminalSurfaceView() !== null;\n}",
    "checksum": "daf96c0c42f44f5c8c887398b2a5433dad5ca64c2e1095a57da203bcce82c4d6"
  },
  "mobile-update-restart-guard": {
    "id": "mobile-update-restart-guard",
    "path": "apps/mobile/src/features/updates/app-updates.ts",
    "start": 417,
    "end": 480,
    "language": "typescript",
    "label": "Deferred OTA flush and foreground-handoff safety gate",
    "code": "async function applyDeferredAppUpdateInstall(\n  client: AppUpdateClient,\n  environment: AppUpdateEnvironment,\n  deferral: AppUpdateDeferral,\n): Promise<void> {\n  if (!deferral.pendingInstall || deferral.installInProgress) return;\n  deferral.installInProgress = true;\n  const flushed = await settlePromise(() => environment.flushPendingWrites());\n  const safe = await settlePromise(() => environment.isSafeToRestartInBackground());\n  if (flushed._tag === \"Failure\" || safe._tag !== \"Success\" || !safe.value) {\n    if (flushed._tag === \"Failure\") {\n      // Nothing is lost yet: keep the state-bearing runtime alive and retry\n      // the flush at the next backgrounding instead of restarting over it.\n      reportUpdateFailure(flushed, \"Could not save pending state.\", undefined);\n    }\n    deferral.installInProgress = false;\n    // This attempt already ran in the current background session; retrying\n    // before a fresh transition would just loop over the same failure.\n    scheduleDeferredAppUpdateInstall(client, environment, deferral, false);\n    return;\n  }\n  const reloaded = await settlePromise(() => client.reloadAsync());\n  if (reloaded._tag === \"Failure\") {\n    reportUpdateFailure(reloaded, \"Downloaded, but could not restart the app.\", undefined);\n    deferral.installInProgress = false;\n    // Let later checks re-arm the install; the downloaded update still\n    // applies at the next cold start regardless.\n    deferral.pendingInstall = false;\n  }\n}\n\nasync function defaultConfirmInstallNow(): Promise<boolean> {\n  const { Alert } = await import(\"react-native\");\n  return new Promise<boolean>((resolve) => {\n    Alert.alert(\n      \"Update ready\",\n      \"A new version has been downloaded and installs automatically the next time you leave the app. Install it now instead?\",\n      [\n        { onPress: () => resolve(false), style: \"cancel\", text: \"Later\" },\n        { onPress: () => resolve(true), text: \"Install Now\" },\n      ],\n      { cancelable: true, onDismiss: () => resolve(false) },\n    );\n  });\n}\n\nasync function defaultFlushPendingWrites(): Promise<void> {\n  // Attempt every flush before surfacing the first failure, so one broken\n  // store cannot keep the others from landing.\n  const results = await Promise.allSettled([\n    import(\"../../state/use-composer-drafts\").then((drafts) => drafts.flushComposerDrafts()),\n    import(\"../../state/thread-outbox\").then((outbox) => outbox.flushThreadOutbox()),\n  ]);\n  const failed = results.find(\n    (result): result is PromiseRejectedResult => result.status === \"rejected\",\n  );\n  if (failed) throw failed.reason;\n}\n\nasync function defaultIsSafeToRestartInBackground(): Promise<boolean> {\n  const { isForegroundHandoffActive } = await import(\"../../lib/foreground-handoff\");\n  if (isForegroundHandoffActive()) return false;\n  const { AppState } = await import(\"react-native\");\n  return AppState.currentState === \"background\";",
    "checksum": "c7202351a95153093f1dd5607987e399683888e4ca03628c4aef7bc2afd51cc2"
  },
  "desktop-preload-bridge": {
    "id": "desktop-preload-bridge",
    "path": "apps/desktop/src/preload.ts",
    "start": 30,
    "end": 103,
    "language": "typescript",
    "label": "Curated renderer bridge for local, SSH, exposure, WSL, and file operations",
    "code": "contextBridge.exposeInMainWorld(\"desktopBridge\", {\n  getAppBranding: () => {\n    const result = ipcRenderer.sendSync(IpcChannels.GET_APP_BRANDING_CHANNEL);\n    if (typeof result !== \"object\" || result === null) {\n      return null;\n    }\n    return result as ReturnType<DesktopBridge[\"getAppBranding\"]>;\n  },\n  getSystemLocale: () => {\n    const result = ipcRenderer.sendSync(IpcChannels.GET_SYSTEM_LOCALE_CHANNEL);\n    return typeof result === \"string\" ? result : null;\n  },\n  getLocalEnvironmentBootstraps: () => {\n    const result = ipcRenderer.sendSync(IpcChannels.GET_LOCAL_ENVIRONMENT_BOOTSTRAPS_CHANNEL);\n    if (!Array.isArray(result)) {\n      return [];\n    }\n    return result as ReturnType<DesktopBridge[\"getLocalEnvironmentBootstraps\"]>;\n  },\n  getLocalEnvironmentBearerToken: () =>\n    ipcRenderer.invoke(IpcChannels.GET_LOCAL_ENVIRONMENT_BEARER_TOKEN_CHANNEL),\n  getClientSettings: () => ipcRenderer.invoke(IpcChannels.GET_CLIENT_SETTINGS_CHANNEL),\n  setClientSettings: (settings) =>\n    ipcRenderer.invoke(IpcChannels.SET_CLIENT_SETTINGS_CHANNEL, settings),\n  getConnectionCatalog: () => ipcRenderer.invoke(IpcChannels.GET_CONNECTION_CATALOG_CHANNEL),\n  setConnectionCatalog: (catalog) =>\n    ipcRenderer.invoke(IpcChannels.SET_CONNECTION_CATALOG_CHANNEL, catalog),\n  clearConnectionCatalog: () => ipcRenderer.invoke(IpcChannels.CLEAR_CONNECTION_CATALOG_CHANNEL),\n  discoverSshHosts: () => ipcRenderer.invoke(IpcChannels.DISCOVER_SSH_HOSTS_CHANNEL),\n  ensureSshEnvironment: async (target, options) =>\n    unwrapEnsureSshEnvironmentResult(\n      await ipcRenderer.invoke(IpcChannels.ENSURE_SSH_ENVIRONMENT_CHANNEL, {\n        target,\n        ...(options === undefined ? {} : { options }),\n      }),\n    ),\n  disconnectSshEnvironment: (target) =>\n    ipcRenderer.invoke(IpcChannels.DISCONNECT_SSH_ENVIRONMENT_CHANNEL, target),\n  fetchSshEnvironmentDescriptor: (httpBaseUrl) =>\n    ipcRenderer.invoke(IpcChannels.FETCH_SSH_ENVIRONMENT_DESCRIPTOR_CHANNEL, { httpBaseUrl }),\n  bootstrapSshBearerSession: (httpBaseUrl, credential) =>\n    ipcRenderer.invoke(IpcChannels.BOOTSTRAP_SSH_BEARER_SESSION_CHANNEL, {\n      httpBaseUrl,\n      credential,\n    }),\n  fetchSshSessionState: (httpBaseUrl, bearerToken) =>\n    ipcRenderer.invoke(IpcChannels.FETCH_SSH_SESSION_STATE_CHANNEL, { httpBaseUrl, bearerToken }),\n  issueSshWebSocketTicket: (httpBaseUrl, bearerToken) =>\n    ipcRenderer.invoke(IpcChannels.ISSUE_SSH_WEBSOCKET_TOKEN_CHANNEL, { httpBaseUrl, bearerToken }),\n  onSshPasswordPrompt: (listener) => {\n    const wrappedListener = (_event: Electron.IpcRendererEvent, request: unknown) => {\n      if (typeof request !== \"object\" || request === null) return;\n      listener(request as Parameters<typeof listener>[0]);\n    };\n\n    ipcRenderer.on(IpcChannels.SSH_PASSWORD_PROMPT_CHANNEL, wrappedListener);\n    return () => {\n      ipcRenderer.removeListener(IpcChannels.SSH_PASSWORD_PROMPT_CHANNEL, wrappedListener);\n    };\n  },\n  resolveSshPasswordPrompt: (requestId, password) =>\n    ipcRenderer.invoke(IpcChannels.RESOLVE_SSH_PASSWORD_PROMPT_CHANNEL, { requestId, password }),\n  getServerExposureState: () => ipcRenderer.invoke(IpcChannels.GET_SERVER_EXPOSURE_STATE_CHANNEL),\n  setServerExposureMode: (mode) =>\n    ipcRenderer.invoke(IpcChannels.SET_SERVER_EXPOSURE_MODE_CHANNEL, mode),\n  setTailscaleServeEnabled: (input) =>\n    ipcRenderer.invoke(IpcChannels.SET_TAILSCALE_SERVE_ENABLED_CHANNEL, input),\n  getAdvertisedEndpoints: () => ipcRenderer.invoke(IpcChannels.GET_ADVERTISED_ENDPOINTS_CHANNEL),\n  getWslState: () => ipcRenderer.invoke(IpcChannels.GET_WSL_STATE_CHANNEL),\n  setWslBackendEnabled: (enabled) =>\n    ipcRenderer.invoke(IpcChannels.SET_WSL_BACKEND_ENABLED_CHANNEL, enabled),\n  setWslDistro: (distro) => ipcRenderer.invoke(IpcChannels.SET_WSL_DISTRO_CHANNEL, distro),\n  setWslOnly: (enabled) => ipcRenderer.invoke(IpcChannels.SET_WSL_ONLY_CHANNEL, enabled),\n  pickFolder: (options) => ipcRenderer.invoke(IpcChannels.PICK_FOLDER_CHANNEL, options),",
    "checksum": "f1c239b62a4b38550da29b44ca8086edd3b2f76df4483787b6628674fe980daf"
  },
  "desktop-bootstrap-order": {
    "id": "desktop-bootstrap-order",
    "path": "apps/desktop/src/app/DesktopApp.ts",
    "start": 142,
    "end": 218,
    "language": "typescript",
    "label": "Endpoint selection, desktop protocol, IPC, primary start, and parallel WSL reconciliation",
    "code": "const bootstrap = Effect.gen(function* () {\n  const pool = yield* DesktopBackendPool.DesktopBackendPool;\n  const primaryBackend = yield* pool.primary;\n  const state = yield* DesktopState.DesktopState;\n  const environment = yield* DesktopEnvironment.DesktopEnvironment;\n  const desktopSettings = yield* DesktopAppSettings.DesktopAppSettings;\n  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;\n  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;\n  const desktopWindow = yield* DesktopWindow.DesktopWindow;\n  yield* logBootstrapInfo(\"bootstrap start\");\n\n  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {\n    return yield* new DesktopDevelopmentBackendPortRequiredError();\n  }\n\n  const backendPortSelection = yield* resolveDesktopBackendPort(environment.configuredBackendPort);\n  const backendPort = backendPortSelection.port;\n  yield* logBootstrapInfo(\n    backendPortSelection.selectedByScan\n      ? \"selected backend port via sequential scan\"\n      : \"using configured backend port\",\n    {\n      port: backendPort,\n      ...(backendPortSelection.selectedByScan ? { startPort: DEFAULT_DESKTOP_BACKEND_PORT } : {}),\n    },\n  );\n\n  const settings = yield* desktopSettings.get;\n  if (settings.serverExposureMode !== environment.defaultDesktopSettings.serverExposureMode) {\n    yield* logBootstrapInfo(\"bootstrap restoring persisted server exposure mode\", {\n      mode: settings.serverExposureMode,\n    });\n  }\n  const serverExposureState = yield* serverExposure.configureFromSettings({ port: backendPort });\n  const backendConfig = yield* serverExposure.backendConfig;\n  const electronProtocol = yield* ElectronProtocol.ElectronProtocol;\n  const rendererTarget = environment.isDevelopment\n    ? Option.getOrThrow(environment.devServerUrl)\n    : backendConfig.httpBaseUrl;\n  yield* electronProtocol.registerDesktopProtocol({\n    scheme: ElectronProtocol.getDesktopScheme(environment.isDevelopment),\n    targetOrigin: rendererTarget,\n    backendOrigin: backendConfig.httpBaseUrl,\n    clerkFrontendApiHostname: DesktopClerk.desktopClerkFrontendApiHostname,\n  });\n  yield* logBootstrapInfo(\"bootstrap resolved backend endpoint\", {\n    baseUrl: backendConfig.httpBaseUrl.href,\n  });\n  if (serverExposureState.endpointUrl) {\n    yield* logBootstrapInfo(\"bootstrap enabled network access\", {\n      endpointUrl: serverExposureState.endpointUrl,\n    });\n  } else if (settings.serverExposureMode === \"network-accessible\") {\n    yield* logBootstrapWarning(\n      \"bootstrap fell back to local-only because no advertised network host was available\",\n    );\n  }\n\n  yield* installDesktopIpcHandlers();\n  yield* logBootstrapInfo(\"bootstrap ipc handlers registered\");\n\n  if (!(yield* Ref.get(state.quitting))) {\n    // In wsl-only mode the renderer is served by the WSL backend, which can be\n    // slow to cold-boot — show a \"Connecting to WSL\" splash immediately so the\n    // app feels responsive instead of presenting no window until WSL is ready.\n    // (Dual mode opens fast off the Windows primary, so no splash there.)\n    if (settings.wslOnly === true && settings.wslBackendEnabled === true) {\n      yield* desktopWindow.showConnectingSplash;\n    }\n    yield* primaryBackend.start;\n    yield* logBootstrapInfo(\"bootstrap backend start requested\");\n    // Bring up the WSL backend if the user previously enabled it. The\n    // primary is already starting; reconcile fires off the WSL register\n    // in parallel rather than blocking primary readiness on a possibly\n    // slow first wsl.exe spawn.\n    yield* Effect.forkScoped(wslBackend.reconcile);\n  }",
    "checksum": "3382a448d70b84c155daa8b98ea9f42a42702152d451cb49be7ba0608c948342"
  },
  "desktop-primary-platform-choice": {
    "id": "desktop-primary-platform-choice",
    "path": "apps/desktop/src/backend/DesktopBackendConfiguration.ts",
    "start": 689,
    "end": 728,
    "language": "typescript",
    "label": "Host-local primary label with the Windows-only WSL override",
    "code": "  // Single source of truth for what the primary actually runs as. Both\n  // the start-config dispatch and the renderer-facing label derive from\n  // this, so they can't disagree — e.g. the label reading \"WSL\" while the\n  // config silently fell back to Windows because WSL is unavailable.\n  // Dispatch happens at resolve time so toggling wsl-only between restarts\n  // is picked up on the next start cycle (the pool's primary instance is\n  // created once at layer init, but configResolve fires on each restart).\n  const describePrimary = Effect.gen(function* () {\n    const persistedSettings = yield* settings.get;\n    const wslRequested = persistedSettings.wslOnly && persistedSettings.wslBackendEnabled;\n    // Only honor wsl-only when WSL is actually usable. If the user\n    // persisted wsl-only but WSL has since become unavailable (wsl.exe\n    // removed, no distro), fall back to the Windows primary instead of\n    // looping forever on preflight failures: the Connections backend\n    // control is hidden while WSL is unavailable, so a stuck WSL primary\n    // would otherwise leave no in-app way back to Windows.\n    const useWsl = wslRequested && (yield* wslEnvironment.isAvailable);\n    return { useWsl, wslRequested, distro: persistedSettings.wslDistro };\n  });\n\n  return DesktopBackendConfiguration.of({\n    resolvePrimary: Effect.gen(function* () {\n      const { useWsl, wslRequested } = yield* describePrimary;\n      if (useWsl) {\n        return yield* buildWslPrimaryConfig;\n      }\n      if (wslRequested) {\n        yield* Effect.logWarning(\n          \"WSL-only backend requested but WSL is unavailable; starting the Windows primary instead.\",\n        );\n      }\n      return yield* buildWindowsPrimaryConfig;\n    }).pipe(Effect.withSpan(\"desktop.backendConfiguration.resolvePrimary\")),\n    resolvePrimaryLabel: Effect.gen(function* () {\n      const { useWsl, distro } = yield* describePrimary;\n      if (!useWsl) {\n        return environment.platform === \"win32\" ? \"Windows\" : \"Local environment\";\n      }\n      return distro ? `WSL (${distro})` : \"WSL\";\n    }).pipe(Effect.withSpan(\"desktop.backendConfiguration.resolvePrimaryLabel\")),",
    "checksum": "58261db624128a02030dd25fb009fc7f141e0d8e67cf9b57cfab3735e468550d"
  },
  "desktop-pool-scope-lifecycle": {
    "id": "desktop-pool-scope-lifecycle",
    "path": "apps/desktop/src/backend/DesktopBackendPool.ts",
    "start": 327,
    "end": 419,
    "language": "typescript",
    "label": "Per-instance child scopes and primary-protected unregister lifecycle",
    "code": "              return Effect.fail(\n                new DesktopBackendPoolInstanceAlreadyRegisteredError({ id: spec.id }),\n              );\n            }\n            if (existing?._tag === \"Closing\") {\n              return Effect.succeed([\n                { _tag: \"Wait\", done: existing.done } as const,\n                current,\n              ] as const);\n            }\n            return Effect.gen(function* () {\n              // Provide the captured factory services first, then the child scope\n              // last so instance finalizers are owned by the unregisterable scope.\n              const instanceScope = yield* Scope.fork(layerScope, \"sequential\");\n              const instance = yield* DesktopBackendManager.makeBackendInstance(spec).pipe(\n                Effect.provide(factoryContext),\n                Scope.provide(instanceScope),\n              );\n              const next = new Map(current);\n              next.set(spec.id, {\n                _tag: \"Active\",\n                instance,\n                scope: Option.some(instanceScope),\n              });\n              return [\n                { _tag: \"Registered\", instance } as const,\n                next as ReadonlyMap<BackendInstanceId, RegisteredInstance>,\n              ] as const;\n            });\n          },\n        ).pipe(\n          Effect.flatMap((result) =>\n            result._tag === \"Registered\"\n              ? Effect.succeed(result.instance)\n              : Deferred.await(result.done).pipe(Effect.andThen(register(spec))),\n          ),\n        ),\n      );\n\n    const unregister: DesktopBackendPool[\"Service\"][\"unregister\"] = (id) =>\n      Effect.gen(function* () {\n        if (id === DesktopBackendManager.PRIMARY_INSTANCE_ID) {\n          return yield* new DesktopBackendPoolCannotUnregisterPrimaryError();\n        }\n        const done = yield* Deferred.make<void>();\n        const action = yield* SynchronizedRef.modifyEffect(\n          instancesRef,\n          (\n            current,\n          ): Effect.Effect<\n            readonly [UnregisterAction, ReadonlyMap<BackendInstanceId, RegisteredInstance>]\n          > => {\n            const entry = current.get(id);\n            if (entry === undefined) {\n              return Effect.succeed([{ _tag: \"Absent\" } as const, current] as const);\n            }\n            if (entry._tag === \"Closing\") {\n              return Effect.succeed([\n                { _tag: \"Wait\", done: entry.done } as const,\n                current,\n              ] as const);\n            }\n            const next = new Map(current);\n            next.set(id, { _tag: \"Closing\", done });\n            return Effect.succeed([\n              { _tag: \"Close\", entry } as const,\n              next as ReadonlyMap<BackendInstanceId, RegisteredInstance>,\n            ] as const);\n          },\n        );\n\n        if (action._tag === \"Absent\") return;\n        if (action._tag === \"Wait\") {\n          yield* Deferred.await(action.done);\n          return;\n        }\n\n        const finish = SynchronizedRef.modifyEffect(instancesRef, (current) => {\n          const closing = current.get(id);\n          if (closing?._tag !== \"Closing\" || closing.done !== done) {\n            return Effect.succeed([undefined, current] as const);\n          }\n          const next = new Map(current);\n          next.delete(id);\n          return Effect.succeed([\n            undefined,\n            next as ReadonlyMap<BackendInstanceId, RegisteredInstance>,\n          ] as const);\n        }).pipe(Effect.andThen(Deferred.succeed(done, undefined)), Effect.asVoid);\n        yield* Option.match(action.entry.scope, {\n          onNone: () => Effect.void,\n          onSome: (scope) => Scope.close(scope, Exit.void).pipe(Effect.ignore),\n        }).pipe(Effect.ensuring(finish));",
    "checksum": "6cc62e74d59a260508a4457eaed647f2bcf1ff9b77a41fd4d41276af7f22aab0"
  },
  "desktop-process-channels": {
    "id": "desktop-process-channels",
    "path": "apps/desktop/src/backend/DesktopBackendManager.ts",
    "start": 451,
    "end": 526,
    "language": "typescript",
    "label": "Bootstrap, telemetry, diagnostics-control, and WSL stdin process channels",
    "code": "  const onOutput = options.onOutput ?? (() => Effect.void);\n  const bootstrapStream = Stream.encodeText(Stream.make(`${bootstrapJson}\\n`));\n  const additionalFds: Record<`fd${number}`, ChildProcess.AdditionalFdConfig> = {};\n  if (options.bootstrapDelivery === \"fd3\") {\n    additionalFds.fd3 = {\n      type: \"input\",\n      stream: bootstrapStream,\n    };\n    if (options.bootstrap.desktopTelemetryFd !== undefined) {\n      additionalFds[`fd${options.bootstrap.desktopTelemetryFd}`] = {\n        type: \"input\",\n        stream: options.desktopTelemetryStream,\n      };\n    }\n    if (options.bootstrap.desktopTelemetryControlFd !== undefined) {\n      additionalFds[`fd${options.bootstrap.desktopTelemetryControlFd}`] = {\n        type: \"output\",\n      };\n    }\n  }\n  const command = ChildProcess.make(options.executablePath, options.args, {\n    cwd: options.cwd,\n    env: options.env,\n    extendEnv: options.extendEnv,\n    // In Electron main, process.execPath points to the Electron binary.\n    // Run the child in Node mode so this backend process does not become a GUI app instance.\n    stdin: options.bootstrapDelivery === \"stdin\" ? bootstrapStream : \"ignore\",\n    stdout: options.captureOutput ? \"pipe\" : \"inherit\",\n    stderr: options.captureOutput ? \"pipe\" : \"inherit\",\n    killSignal: \"SIGTERM\",\n    forceKillAfter: DEFAULT_BACKEND_TERMINATE_GRACE,\n    // wsl.exe drops additional file descriptors when forwarding to the Linux\n    // side, so the WSL spawn path delivers the bootstrap envelope via stdin\n    // (`--bootstrap-fd 0`) instead.\n    ...(options.bootstrapDelivery === \"fd3\" ? { additionalFds } : {}),\n  });\n\n  const handle = yield* spawner.spawn(command).pipe(\n    Effect.mapError(\n      (cause) =>\n        new BackendProcessSpawnError({\n          executablePath: options.executablePath,\n          entryPath: options.entryPath,\n          cwd: options.cwd,\n          httpBaseUrl: options.httpBaseUrl,\n          cause,\n        }),\n    ),\n  );\n  const outputFibers: Array<Fiber.Fiber<void, never>> = [];\n\n  yield* options.onStarted?.(handle.pid) ?? Effect.void;\n  if (\n    options.bootstrap.desktopTelemetryControlFd !== undefined &&\n    options.onDesktopTelemetryControl !== undefined\n  ) {\n    const controlFd = options.bootstrap.desktopTelemetryControlFd;\n    const handleControl = options.onDesktopTelemetryControl;\n    yield* handle.getOutputFd(controlFd).pipe(\n      Stream.decodeText(),\n      Stream.splitLines,\n      Stream.filter((line) => line.trim().length > 0),\n      Stream.runForEach((line) =>\n        decodeDesktopTelemetryControlLine(line).pipe(\n          Effect.flatMap(handleControl),\n          Effect.catchCause((cause) =>\n            logBackendProcessWarning(\"ignored invalid desktop telemetry control message\", {\n              fd: controlFd,\n              cause: Cause.pretty(cause),\n            }),\n          ),\n        ),\n      ),\n      Effect.catchCause((cause) =>\n        logBackendProcessWarning(\"desktop telemetry control stream stopped\", {\n          fd: controlFd,",
    "checksum": "9a38b54eef1d5d1bb2e4a11a70cac83f681b4d8369b8d44c0548c7efd93119de"
  },
  "desktop-http-readiness-loop": {
    "id": "desktop-http-readiness-loop",
    "path": "apps/desktop/src/backend/DesktopBackendManager.ts",
    "start": 566,
    "end": 591,
    "language": "typescript",
    "label": "Repeated HTTP readiness budgets while the local child remains alive",
    "code": "  // Probe readiness in a loop while the backend process is still alive\n  // instead of giving up after the first budget. A slow cold boot (the\n  // WSL bundle loading across /mnt/c, or a first launch right after an\n  // update) can exceed the initial readiness budget while the backend is\n  // about to come up moments later; a one-shot probe left the app stuck\n  // on \"Connecting to WSL…\" forever even though the backend kept running\n  // and became healthy. Each round gets a fresh budget, and the forked\n  // loop is torn down with the run scope once the child exits.\n  const probeReadiness = Effect.fn(\"desktop.backendProcess.probeReadiness\")(() =>\n    waitForHttpReady({\n      executablePath: options.executablePath,\n      entryPath: options.entryPath,\n      cwd: options.cwd,\n      httpBaseUrl: options.httpBaseUrl,\n      timeout: options.readinessTimeout ?? DEFAULT_BACKEND_READINESS_TIMEOUT,\n    }).pipe(\n      Effect.flatMap(() => options.onReady?.() ?? Effect.void),\n      Effect.as(true),\n      Effect.catchTags({\n        BackendReadinessTimeoutError: (error) =>\n          (options.onReadinessFailure?.(error) ?? Effect.void).pipe(Effect.as(false)),\n      }),\n    ),\n  );\n\n  yield* probeReadiness().pipe(Effect.repeat({ while: (ready) => !ready }), Effect.forkScoped);",
    "checksum": "cb8c41817f08f82de4211db178fdc26c0f9686235c75cd46ff75bf53e8c0f476"
  },
  "desktop-updater-quit-boundary": {
    "id": "desktop-updater-quit-boundary",
    "path": "apps/desktop/src/app/DesktopLifecycle.ts",
    "start": 198,
    "end": 227,
    "language": "typescript",
    "label": "Updater-controlled quit bypasses the ordinary before-quit hold",
    "code": "    let updaterQuitAllowed = false;\n    yield* electronTheme.onUpdated(() => {\n      void runEffect(\n        desktopWindow.syncAppearance.pipe(Effect.withSpan(\"desktop.lifecycle.themeUpdated\")),\n      );\n    });\n    yield* electronApp.onBeforeQuitForUpdate(() => {\n      // Electron's updater owns the remaining quit/install/relaunch sequence.\n      // Cancelling the following app \"before-quit\" event breaks that sequence,\n      // most visibly on macOS where the native updater performs the relaunch.\n      updaterQuitAllowed = true;\n      void runEffect(\n        logLifecycleInfo(\"allowing updater-controlled quit\").pipe(\n          Effect.withSpan(\"desktop.lifecycle.beforeQuitForUpdate\"),\n        ),\n      );\n    });\n    yield* electronApp.on(\"before-quit\", (event: Electron.Event) => {\n      handleBeforeQuit(\n        event,\n        runEffect,\n        () => quitAllowed || updaterQuitAllowed,\n        () => {\n          quitAllowed = true;\n        },\n      );\n    });\n    yield* electronApp.on(\"activate\", () => {\n      void runEffect(\n        Effect.gen(function* () {",
    "checksum": "cc836843d91d37f40a435053ead939e6c9ce439e4fd7860cf814e0497261be6f"
  },
  "desktop-all-instance-shutdown": {
    "id": "desktop-all-instance-shutdown",
    "path": "apps/desktop/src/app/DesktopApp.ts",
    "start": 295,
    "end": 315,
    "language": "typescript",
    "label": "Application finalizer gracefully stops every registered local backend",
    "code": "    const runId = yield* makeDesktopRunId;\n    yield* Effect.annotateLogsScoped({ scope: \"desktop\", runId });\n    yield* Effect.annotateCurrentSpan({ scope: \"desktop\", runId });\n\n    const shutdown = yield* DesktopShutdown.DesktopShutdown;\n\n    yield* Effect.addFinalizer(() =>\n      Effect.gen(function* () {\n        const pool = yield* DesktopBackendPool.DesktopBackendPool;\n        // Stop every backend in the pool, not just the primary. The\n        // electronApp.quit() path can race ahead of the layer-scope\n        // cascade, so leaving the WSL instance for its parent scope\n        // finalizer means it gets hard-killed by the OS instead of\n        // receiving SIGTERM + grace. Stops run concurrently.\n        const instances = yield* pool.list;\n        yield* Effect.forEach(instances, (instance) => instance.stop(), {\n          concurrency: \"unbounded\",\n        });\n      }).pipe(Effect.ensuring(shutdown.markComplete)),\n    );\n",
    "checksum": "cd58d3b5122f8a81ad2f1f2f27e43a2e7c188f6e8a354df6ce67585070d496a9"
  },
  "distribution-cli-contract": {
    "id": "distribution-cli-contract",
    "path": "apps/server/package.json",
    "start": 1,
    "end": 22,
    "language": "json",
    "label": "The t3 npm executable and published dist payload",
    "code": "{\n  \"name\": \"t3\",\n  \"version\": \"0.0.33\",\n  \"license\": \"MIT\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/pingdotgg/t3code\",\n    \"directory\": \"apps/server\"\n  },\n  \"bin\": {\n    \"t3\": \"./dist/bin.mjs\"\n  },\n  \"files\": [\n    \"dist\"\n  ],\n  \"type\": \"module\",\n  \"scripts\": {\n    \"dev\": \"node --watch src/bin.ts\",\n    \"build:bundle\": \"vp pack && vp pack src/service-launcher.ts --out-dir dist --no-clean\",\n    \"start\": \"node dist/bin.mjs\",\n    \"typecheck\": \"tsgo --noEmit\",\n    \"test\": \"vp test run\"",
    "checksum": "d17e2567fc16fd9ca3b5640c87befcc259679127fb33e96434ef58249f1288f3"
  },
  "distribution-cli-bundles-web": {
    "id": "distribution-cli-bundles-web",
    "path": "apps/server/scripts/cli.ts",
    "start": 143,
    "end": 176,
    "language": "typescript",
    "label": "CLI build copies the web renderer into the server package",
    "code": "const buildCmd = Command.make(\n  \"build\",\n  {\n    verbose: Flag.boolean(\"verbose\").pipe(Flag.withDefault(false)),\n  },\n  (config) =>\n    Effect.gen(function* () {\n      const path = yield* Path.Path;\n      const fs = yield* FileSystem.FileSystem;\n      const repoRoot = yield* RepoRoot;\n      const serverDir = path.join(repoRoot, \"apps/server\");\n\n      yield* Effect.log(\"[cli] Running tsdown...\");\n      yield* runCommand(\n        ChildProcess.make(process.execPath, [\"--run\", \"build:bundle\"], {\n          cwd: serverDir,\n          stdout: config.verbose ? \"inherit\" : \"ignore\",\n          stderr: \"inherit\",\n          shell: false,\n        }),\n      );\n\n      const webDist = path.join(repoRoot, \"apps/web/dist\");\n      const clientTarget = path.join(serverDir, \"dist/client\");\n\n      if (yield* fs.exists(webDist)) {\n        yield* fs.copy(webDist, clientTarget);\n        yield* applyDevelopmentIconOverrides(repoRoot, serverDir);\n        yield* Effect.log(\"[cli] Bundled web app into dist/client\");\n      } else {\n        yield* Effect.logWarning(\"[cli] Web dist not found — skipping client bundle.\");\n      }\n    }),\n).pipe(Command.withDescription(\"Build the server package (tsdown + bundle web client).\"));",
    "checksum": "4ad46f56921042886a21ff4b2de66dd2eacebe0eb7e55c6c38cd083469e4ef47"
  },
  "distribution-desktop-artifact-contract": {
    "id": "distribution-desktop-artifact-contract",
    "path": "scripts/build-desktop-artifact.ts",
    "start": 2059,
    "end": 2107,
    "language": "typescript",
    "label": "Desktop artifact naming, packed resources, update feed, and macOS target",
    "code": "  const buildConfig: Record<string, unknown> = {\n    appId: DESKTOP_APP_ID,\n    productName: resolveDesktopProductName(version),\n    artifactName: \"T3-Code-${version}-${arch}.${ext}\",\n    electronLanguages: [...DESKTOP_ELECTRON_LANGUAGES],\n    files: [...DESKTOP_FILE_EXCLUSIONS],\n    directories: {\n      buildResources: \"apps/desktop/resources\",\n    },\n    // All platforms keep app.asar fully packed; electron-builder's default\n    // smart unpack extracts native libraries, which loaders find in\n    // app.asar.unpacked. Windows additionally ships the server tree as the\n    // hand-packed server.asar sidecar (see WINDOWS_SERVER_ASAR_RESOURCE).\n    extraResources: [\n      ...DESKTOP_EXTRA_RESOURCES,\n      ...(platform === \"win\" ? WINDOWS_SERVER_EXTRA_RESOURCES : []),\n    ],\n  };\n  const updateChannel = resolveDesktopUpdateChannel(version);\n  const publishConfig = yield* resolveGitHubPublishConfig(updateChannel);\n  if (publishConfig) {\n    buildConfig.publish = [publishConfig];\n  } else if (mockUpdates) {\n    buildConfig.publish = [\n      {\n        provider: \"generic\",\n        url: resolveMockUpdateServerUrl(mockUpdateServerPort),\n      },\n    ];\n  }\n\n  if (platform === \"mac\") {\n    buildConfig.mac = {\n      target: target === \"dmg\" ? [target, \"zip\"] : [target],\n      icon: \"icon.icns\",\n      category: \"public.app-category.developer-tools\",\n      protocols: [\n        {\n          name: \"T3 Code\",\n          schemes: [\"t3code\", \"t3code-dev\"],\n        },\n      ],\n      ...(macPasskeySigning\n        ? {\n            entitlements: macPasskeySigning.entitlementsPath,\n            provisioningProfile: macPasskeySigning.provisioningProfilePath,\n          }\n        : {}),\n    };",
    "checksum": "d86868659c92e31e0c84c37ffc43eb5d126a3dfdaa6d14e97fa9cc076312ff89"
  },
  "distribution-desktop-linux-windows-targets": {
    "id": "distribution-desktop-linux-windows-targets",
    "path": "scripts/build-desktop-artifact.ts",
    "start": 2133,
    "end": 2174,
    "language": "typescript",
    "label": "Linux and Windows desktop target configuration",
    "code": "  if (platform === \"linux\") {\n    buildConfig.linux = {\n      target: [target],\n      executableName: \"t3code\",\n      icon: \"icons\",\n      category: \"Development\",\n      // electron-builder turns these into MimeType=x-scheme-handler/<scheme>;\n      // in the .desktop entry (Exec already gets %U), so browsers can hand\n      // t3code:// OAuth callbacks to the app.\n      protocols: [\n        {\n          name: \"T3 Code\",\n          schemes: [\"t3code\", \"t3code-dev\"],\n        },\n      ],\n      desktop: {\n        entry: {\n          StartupWMClass: \"t3code\",\n        },\n      },\n    };\n  }\n\n  if (platform === \"win\") {\n    buildConfig.npmRebuild = false;\n    // Keep blockmap-based differential downloads enabled while changing the\n    // installed file topology. The optimization is in the payload shape, not\n    // in trading update bandwidth for install speed.\n    buildConfig.nsis = { differentialPackage: true };\n    const winConfig: Record<string, unknown> = {\n      target: [target],\n      icon: \"icon.ico\",\n      // Resource editing applies the product metadata and icon independently\n      // of code signing. Disabling it for local unsigned builds leaves the\n      // packaged executable with Electron's stock icon.\n      signAndEditExecutable: true,\n    };\n    if (signed) {\n      winConfig.azureSignOptions = yield* AzureTrustedSigningOptionsConfig;\n    }\n    buildConfig.win = winConfig;\n  }",
    "checksum": "86c6ea4e376e5cce7355d8e2c5e0471d8cfbb17be0975ca8ad5233c0ad82f39d"
  },
  "distribution-release-matrix": {
    "id": "distribution-release-matrix",
    "path": ".github/workflows/release.yml",
    "start": 342,
    "end": 397,
    "language": "yaml",
    "label": "The four desktop artifacts actually shipped by release CI",
    "code": "  build:\n    name: Build ${{ matrix.label }}\n    # build_wsl_node_pty stays in `needs` so it runs first and its artifact is\n    # available to download, but only the Windows matrix entry consumes it. We\n    # therefore gate the job on preflight + relay (must succeed) WITHOUT requiring\n    # build_wsl_node_pty, so a failed Linux prebuild doesn't skip the macOS/Linux\n    # builds. `!cancelled()` (not `!failure()`) lets the job run even when\n    # build_wsl_node_pty failed; the Windows-only download step below then fails\n    # that single platform if the prebuild is missing.\n    needs: [preflight, relay_public_config, build_wsl_node_pty]\n    if: ${{ !cancelled() && needs.preflight.result == 'success' && needs.relay_public_config.result == 'success' }}\n    runs-on: ${{ matrix.runner }}\n    timeout-minutes: 30\n    env:\n      T3CODE_CLERK_PUBLISHABLE_KEY: ${{ needs.relay_public_config.outputs.clerk_publishable_key }}\n      T3CODE_CLERK_JWT_TEMPLATE: ${{ needs.relay_public_config.outputs.clerk_jwt_template }}\n      T3CODE_CLERK_CLI_OAUTH_CLIENT_ID: ${{ needs.relay_public_config.outputs.clerk_cli_oauth_client_id }}\n      T3CODE_RELAY_URL: ${{ needs.relay_public_config.outputs.relay_url }}\n    strategy:\n      fail-fast: false\n      matrix:\n        include:\n          - label: macOS arm64\n            runner: blacksmith-12vcpu-macos-26\n            platform: mac\n            target: dmg\n            arch: arm64\n            rust_target: aarch64-apple-darwin\n            resource_key: darwin-arm64\n          - label: macOS x64\n            runner: blacksmith-12vcpu-macos-26\n            platform: mac\n            target: dmg\n            arch: x64\n            rust_target: x86_64-apple-darwin\n            resource_key: darwin-x64\n          - label: Linux x64\n            runner: blacksmith-32vcpu-ubuntu-2404\n            platform: linux\n            target: AppImage\n            arch: x64\n            rust_target: x86_64-unknown-linux-gnu\n            resource_key: linux-x64\n          - label: Windows x64\n            runner: blacksmith-32vcpu-windows-2025\n            platform: win\n            target: nsis\n            arch: x64\n            rust_target: x86_64-pc-windows-msvc\n            resource_key: win32-x64\n          # - label: Windows arm64\n          #   runner: windows-11-arm\n          #   platform: win\n          #   target: nsis\n          #   arch: arm64\n    steps:",
    "checksum": "e7a92ff379e65dc8c67d6b2cbe3d5f834a4ff4a6a48fca09f395ac33d93a6dde"
  },
  "distribution-cli-before-release": {
    "id": "distribution-cli-before-release",
    "path": ".github/workflows/release.yml",
    "start": 709,
    "end": 791,
    "language": "yaml",
    "label": "Exact CLI publication gates GitHub Release publication",
    "code": "  publish_cli:\n    name: Publish CLI to npm\n    needs: [preflight, relay_public_config, quality, build]\n    if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.relay_public_config.result == 'success' && needs.quality.result == 'success' && needs.build.result == 'success' }}\n    runs-on: ubuntu-24.04 # blacksmith-8vcpu-ubuntu-2404\n    timeout-minutes: 10\n    permissions:\n      contents: read\n      id-token: write\n    env:\n      T3CODE_CLERK_PUBLISHABLE_KEY: ${{ needs.relay_public_config.outputs.clerk_publishable_key }}\n      T3CODE_CLERK_JWT_TEMPLATE: ${{ needs.relay_public_config.outputs.clerk_jwt_template }}\n      T3CODE_CLERK_CLI_OAUTH_CLIENT_ID: ${{ needs.relay_public_config.outputs.clerk_cli_oauth_client_id }}\n      T3CODE_RELAY_URL: ${{ needs.relay_public_config.outputs.relay_url }}\n    steps:\n      - name: Checkout\n        uses: actions/checkout@v6\n        with:\n          ref: ${{ needs.preflight.outputs.ref }}\n          sparse-checkout: |\n            /*\n            !/.repos/\n          sparse-checkout-cone-mode: false\n\n      - name: Setup Vite+\n        uses: voidzero-dev/setup-vp@v1\n        with:\n          node-version-file: package.json\n          cache: true\n          run-install: |\n            args:\n              - --filter=t3...\n              - --filter=@t3tools/web...\n              - --filter=@t3tools/scripts...\n\n      - name: Download relay client tracing config\n        uses: actions/download-artifact@v8\n        with:\n          name: relay-client-tracing-config\n          path: ${{ runner.temp }}/relay-client-tracing\n\n      - name: Load relay client tracing config\n        shell: bash\n        run: |\n          config_path=\"$RUNNER_TEMP/relay-client-tracing/relay-client-tracing.env\"\n          tracing_token=\"$(sed -n 's/^T3CODE_RELAY_CLIENT_OTLP_TRACES_TOKEN=//p' \"$config_path\")\"\n          echo \"::add-mask::$tracing_token\"\n          cat \"$config_path\" >> \"$GITHUB_ENV\"\n\n      - name: Align package versions to release version\n        run: node scripts/update-release-package-versions.ts \"${{ needs.preflight.outputs.version }}\"\n\n      - name: Build web package\n        run: vp run --filter @t3tools/web build\n\n      - name: Build CLI package\n        run: vp run --filter t3 build\n\n      - name: Download resource monitors\n        uses: actions/download-artifact@v8\n        with:\n          pattern: resource-monitor-*\n          path: ${{ runner.temp }}/resource-monitors\n\n      - name: Bundle resource monitors into CLI package\n        shell: bash\n        run: |\n          set -euo pipefail\n          for artifact_dir in \"$RUNNER_TEMP\"/resource-monitors/resource-monitor-*; do\n            resource_key=\"${artifact_dir##*/resource-monitor-}\"\n            target_dir=\"apps/server/dist/resource-monitor/${resource_key}\"\n            mkdir -p \"$target_dir\"\n            cp \"$artifact_dir\"/t3-resource-monitor* \"$target_dir/\"\n            chmod +x \"$target_dir\"/t3-resource-monitor 2>/dev/null || true\n          done\n\n      - name: Publish CLI package\n        run: node apps/server/scripts/cli.ts publish --tag \"${{ needs.preflight.outputs.cli_dist_tag }}\" --app-version \"${{ needs.preflight.outputs.version }}\" --verbose\n\n  release:\n    name: Publish GitHub Release\n    needs: [preflight, build, publish_cli]\n    if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.build.result == 'success' && needs.publish_cli.result == 'success' }}",
    "checksum": "08174e0cfbd9d1a218a3690cdd7f77f0de1d49b01cf5289c2ef9097b5c164af6"
  },
  "distribution-mobile-fingerprint-publish": {
    "id": "distribution-mobile-fingerprint-publish",
    "path": ".github/workflows/mobile-eas-production.yml",
    "start": 263,
    "end": 286,
    "language": "yaml",
    "label": "Production OTA publication requires a matching native fingerprint",
    "code": "      - name: Publish fingerprint-gated OTA\n        if: steps.expo-token.outputs.present == 'true' && github.event_name == 'push'\n        working-directory: apps/mobile\n        env:\n          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}\n        run: |\n          message=\"$(git log -1 --pretty=%s | head -c 120) ($(git rev-parse --short=9 HEAD))\"\n          for platform in ios android; do\n            # eas-cli prints an environment-loaded notice to stdout before the\n            # JSON even with --json, so discard everything before the document.\n            hash=\"$(eas fingerprint:generate --platform \"$platform\" --environment production --json --non-interactive | sed -n '/^{/,$p' | jq -er '.hash | select(type == \"string\" and length > 0)')\"\n            matching=\"$(eas build:list --platform \"$platform\" --build-profile production --status finished --fingerprint-hash \"$hash\" --limit 1 --json --non-interactive | jq 'length')\"\n            if [ \"$matching\" -gt 0 ]; then\n              eas update \\\n                --channel production \\\n                --environment production \\\n                --platform \"$platform\" \\\n                --message \"$message\" \\\n                --non-interactive\n              echo \":white_check_mark: $platform: OTA published to production (fingerprint \\`$hash\\`)\" >> \"$GITHUB_STEP_SUMMARY\"\n            else\n              echo \":warning: $platform: no finished production build matches fingerprint \\`$hash\\` — OTA skipped; JS changes reach $platform only once a matching build ships\" >> \"$GITHUB_STEP_SUMMARY\"\n            fi\n          done",
    "checksum": "fe28375e5fe7f07cc02a0734c5be7cbf132acec9b52a32a9ae2b98139c8e4f31"
  },
  "distribution-download-resolution": {
    "id": "distribution-download-resolution",
    "path": "apps/marketing/src/pages/download.astro",
    "start": 89,
    "end": 132,
    "language": "typescript",
    "label": "Marketing download links resolve against latest GitHub Release assets",
    "code": "<script>\n  import { fetchLatestRelease, RELEASES_URL } from \"../lib/releases\";\n\n  async function init() {\n    const versionLabel = document.getElementById(\"version-label\");\n    // Only release-asset links; mobile store cards have no data-asset and keep their href.\n    const cards = document.querySelectorAll<HTMLAnchorElement>(\"a[data-asset]\");\n\n    try {\n      const release = await fetchLatestRelease();\n\n      if (versionLabel && release.tag_name) {\n        versionLabel.textContent = `Latest (${release.tag_name})`;\n      }\n\n      const changelogLink = document.getElementById(\"changelog-link\") as HTMLAnchorElement | null;\n      if (changelogLink && release.html_url) {\n        changelogLink.href = release.html_url;\n        changelogLink.style.display = \"\";\n      }\n\n      cards.forEach((card) => {\n        const suffix = card.dataset.asset;\n        if (!suffix) return;\n\n        const match = (release.assets ?? []).find((a) => a.name.endsWith(`-${suffix}`));\n        if (match) {\n          card.href = match.browser_download_url;\n        } else {\n          card.href = RELEASES_URL;\n        }\n      });\n    } catch {\n      if (versionLabel) {\n        versionLabel.textContent = \"Could not load release info.\";\n      }\n      cards.forEach((card) => {\n        card.href = RELEASES_URL;\n      });\n    }\n  }\n\n  init();\n</script>",
    "checksum": "2797f24449eb4c2753ee4fc82674f127d1cd273af1aa0b25d2f7cc769b4367d0"
  },
  "distribution-aur-selection": {
    "id": "distribution-aur-selection",
    "path": "packaging/aur/scripts/release.sh",
    "start": 9,
    "end": 44,
    "language": "bash",
    "label": "Stable and nightly tags select separate checksum-pinned AUR packages",
    "code": "if [[ \"$tag\" =~ ^v[0-9]+\\.[0-9]+\\.[0-9]+$ ]]; then\n  pkgname='t3code-bin'\nelif [[ \"$tag\" =~ ^v[0-9]+\\.[0-9]+\\.[0-9]+-nightly\\.[0-9]{8}\\.[0-9]+$ ]]; then\n  pkgname='t3code-nightly-bin'\nelse\n  echo \"Release $tag does not publish an AUR package.\"\n  exit 0\nfi\n\nversion=\"${tag#v}\"\npkgver=\"${version//-/_}\"\nasset_name=\"T3-Code-${version}-x86_64.AppImage\"\nrelease_json=\"$(gh api \"repos/$repo/releases/tags/$tag\")\"\nasset_digest=\"$(jq -r --arg name \"$asset_name\" \\\n  '.assets[] | select(.name == $name) | .digest' <<<\"$release_json\")\"\nappimage_sha256=\"${asset_digest#sha256:}\"\n\nif [[ ! \"$appimage_sha256\" =~ ^[0-9a-f]{64}$ ]]; then\n  echo \"Release $tag is missing $asset_name or its SHA-256 digest.\" >&2\n  exit 1\nfi\n\nwork_dir=\"$(mktemp -d)\"\ntrap 'rm -rf -- \"$work_dir\"' EXIT\ngh api -H 'Accept: application/vnd.github.raw' \\\n  \"repos/$repo/contents/LICENSE?ref=$tag\" > \"$work_dir/LICENSE\"\nlicense_sha256=\"$(sha256sum \"$work_dir/LICENSE\" | awk '{print $1}')\"\n\npackage_dir=\"$repo_root/packaging/aur/$pkgname\"\ncd \"$package_dir\"\nsed -Ei \\\n  -e \"s/^pkgver=.*/pkgver=$pkgver/\" \\\n  -e \"s/^pkgrel=.*/pkgrel=$pkgrel/\" \\\n  -e \"/# AppImage$/s/'[0-9a-f]{64}'/'$appimage_sha256'/\" \\\n  -e \"/# upstream license$/s/'[0-9a-f]{64}'/'$license_sha256'/\" \\\n  PKGBUILD",
    "checksum": "fc2a09bb70266affc8b9779eb18da4d303cefb2ffad79934ddd803286cda7299"
  },
  "release-channel-resolution": {
    "id": "release-channel-resolution",
    "path": ".github/workflows/release.yml",
    "start": 103,
    "end": 155,
    "language": "bash",
    "label": "Stable and nightly releases derive different versions, tags, and latest policy",
    "code": "      - id: release_meta\n        name: Resolve release version\n        shell: bash\n        env:\n          DISPATCH_CHANNEL: ${{ github.event.inputs.channel }}\n          DISPATCH_VERSION: ${{ github.event.inputs.version }}\n          NIGHTLY_DATE: ${{ github.run_started_at }}\n          NIGHTLY_SHA: ${{ github.sha }}\n          NIGHTLY_RUN_NUMBER: ${{ github.run_number }}\n        run: |\n          if [[ \"${GITHUB_EVENT_NAME}\" == \"schedule\" || ( \"${GITHUB_EVENT_NAME}\" == \"workflow_dispatch\" && \"${DISPATCH_CHANNEL:-stable}\" == \"nightly\" ) ]]; then\n            nightly_date=\"$(date -u -d \"$NIGHTLY_DATE\" +%Y%m%d)\"\n\n            node scripts/resolve-nightly-release.ts \\\n              --date \"$nightly_date\" \\\n              --run-number \"$NIGHTLY_RUN_NUMBER\" \\\n              --sha \"$NIGHTLY_SHA\" \\\n              --github-output\n\n            echo \"release_channel=nightly\" >> \"$GITHUB_OUTPUT\"\n            echo \"cli_dist_tag=nightly\" >> \"$GITHUB_OUTPUT\"\n            echo \"is_prerelease=true\" >> \"$GITHUB_OUTPUT\"\n            echo \"make_latest=false\" >> \"$GITHUB_OUTPUT\"\n          else\n            if [[ \"${GITHUB_EVENT_NAME}\" == \"workflow_dispatch\" ]]; then\n              raw=\"${DISPATCH_VERSION}\"\n              if [[ -z \"$raw\" ]]; then\n                echo \"workflow_dispatch stable releases require the version input.\" >&2\n                exit 1\n              fi\n            else\n              raw=\"${GITHUB_REF_NAME}\"\n            fi\n\n            version=\"${raw#v}\"\n            if [[ ! \"$version\" =~ ^[0-9]+\\.[0-9]+\\.[0-9]+([.-][0-9A-Za-z.-]+)?$ ]]; then\n              echo \"Invalid release version: $raw\" >&2\n              exit 1\n            fi\n\n            echo \"release_channel=stable\" >> \"$GITHUB_OUTPUT\"\n            echo \"version=$version\" >> \"$GITHUB_OUTPUT\"\n            echo \"tag=v$version\" >> \"$GITHUB_OUTPUT\"\n            echo \"name=T3 Code v$version\" >> \"$GITHUB_OUTPUT\"\n            echo \"cli_dist_tag=latest\" >> \"$GITHUB_OUTPUT\"\n            if [[ \"$version\" =~ ^[0-9]+\\.[0-9]+\\.[0-9]+$ ]]; then\n              echo \"is_prerelease=false\" >> \"$GITHUB_OUTPUT\"\n              echo \"make_latest=true\" >> \"$GITHUB_OUTPUT\"\n            else\n              echo \"is_prerelease=true\" >> \"$GITHUB_OUTPUT\"\n              echo \"make_latest=false\" >> \"$GITHUB_OUTPUT\"\n            fi\n          fi",
    "checksum": "14a9355c1c509245042afe02fcfb4fd155578c5b31615b9440e1ca4a7375c4e7"
  },
  "release-exact-version-invariant": {
    "id": "release-exact-version-invariant",
    "path": "docs/operations/release.md",
    "start": 174,
    "end": 187,
    "language": "markdown",
    "label": "npm exact-version publication precedes every released client",
    "code": "## Server self-update release invariant\n\nConnected servers update to the client's exact version, not to an npm dist-tag. Every released\ndesktop or hosted client version must therefore have a matching `t3@<version>` package available on\nnpm before users can receive that client.\n\nThe workflow enforces this ordering:\n\n1. `publish_cli` publishes the exact stable or nightly version to npm.\n2. `release` depends on `publish_cli` before exposing desktop artifacts in GitHub Releases.\n3. `deploy_web` depends on `release` before moving the hosted channel to the new client.\n\nPreserve these dependencies when changing the release graph. Publishing a client first would leave\nthe **Update server** action targeting a package version that does not exist yet.",
    "checksum": "22eb4423a30d49b23f50117b70459bc87aacfafc9f766b8fe75d0083df4377f8"
  },
  "desktop-update-check-download": {
    "id": "desktop-update-check-download",
    "path": "apps/desktop/src/updates/DesktopUpdates.ts",
    "start": 334,
    "end": 458,
    "language": "typescript",
    "label": "Desktop channel selection, update checks, and user-triggered download",
    "code": "  const applyAutoUpdaterChannel = Effect.fn(\"desktop.updates.applyAutoUpdaterChannel\")(function* (\n    channel: DesktopUpdateChannel,\n  ) {\n    yield* Effect.annotateCurrentSpan({ channel });\n    const allowsPrerelease = channel === \"nightly\";\n    yield* electronUpdater.setChannel(channel);\n    yield* electronUpdater.setAllowPrerelease(allowsPrerelease);\n    yield* electronUpdater.setAllowDowngrade(allowsPrerelease);\n    yield* electronUpdater.setFullChangelog(allowsPrerelease);\n    yield* logUpdaterInfo(\"using update channel\", {\n      channel,\n      allowPrerelease: allowsPrerelease,\n      allowDowngrade: allowsPrerelease,\n      fullChangelog: allowsPrerelease,\n    });\n  });\n\n  const shouldEnableAutoUpdates = resolveDisabledReason.pipe(Effect.map(Option.isNone));\n\n  const checkForUpdates = Effect.fn(\"desktop.updates.checkForUpdates\")(function* (\n    reason: string,\n    actionReservation: \"acquire\" | \"held\" = \"acquire\",\n  ) {\n    yield* Effect.annotateCurrentSpan({ reason });\n    if (yield* Ref.get(desktopState.quitting)) return false;\n    if (!(yield* Ref.get(updaterConfiguredRef))) return false;\n\n    const state = yield* Ref.get(updateStateRef);\n    if (state.status === \"downloading\") {\n      yield* logUpdaterInfo(\"skipping update check while update is active\", {\n        reason,\n        status: state.status,\n      });\n      return false;\n    }\n\n    if (actionReservation === \"acquire\" && !(yield* tryStartUpdateAction(\"check\"))) return false;\n\n    const check = Effect.gen(function* () {\n      const checkedAt = yield* currentIsoTimestamp;\n      yield* setState(reduceDesktopUpdateStateOnCheckStart(state, checkedAt));\n      yield* logUpdaterInfo(\"checking for updates\", { reason });\n\n      return yield* electronUpdater.checkForUpdates.pipe(\n        Effect.as(true),\n        Effect.catchTags({\n          ElectronUpdaterCheckForUpdatesError: Effect.fn(\n            \"desktop.updates.handleCheckForUpdatesFailure\",\n          )(function* (error) {\n            const failedAt = yield* currentIsoTimestamp;\n            yield* updateState((current) =>\n              reduceDesktopUpdateStateOnCheckFailure(current, error.message, failedAt),\n            );\n            yield* logUpdaterError(error.message, {\n              errorTag: error._tag,\n              channel: error.channel,\n            });\n            return true;\n          }),\n        }),\n      );\n    });\n\n    return yield* actionReservation === \"held\"\n      ? check\n      : check.pipe(Effect.ensuring(finishUpdateAction(\"check\")));\n  });\n\n  const downloadAvailableUpdate = Effect.gen(function* () {\n    const state = yield* Ref.get(updateStateRef);\n    if (!(yield* Ref.get(updaterConfiguredRef)) || state.status !== \"available\") {\n      return { accepted: false, completed: false };\n    }\n\n    if (!(yield* tryStartUpdateAction(\"download\"))) {\n      return { accepted: false, completed: false };\n    }\n\n    return yield* Effect.gen(function* () {\n      yield* setState(reduceDesktopUpdateStateOnDownloadStart(state));\n      yield* electronUpdater.setDisableDifferentialDownload(\n        isArm64HostRunningIntelBuild(environment.runtimeInfo),\n      );\n      yield* logUpdaterInfo(\"downloading update\");\n      yield* electronUpdater.downloadUpdate;\n      return { accepted: true, completed: true };\n    }).pipe(\n      Effect.catchTags({\n        ElectronUpdaterDownloadUpdateError: Effect.fn(\"desktop.updates.handleDownloadFailure\")(\n          function* (error) {\n            yield* updateState((current) =>\n              reduceDesktopUpdateStateOnDownloadFailure(current, error.message),\n            );\n            yield* logUpdaterError(error.message, {\n              errorTag: error._tag,\n              channel: error.channel,\n            });\n            return { accepted: true, completed: false };\n          },\n        ),\n      }),\n      Effect.onInterrupt(() =>\n        updateState((current) => (current.status === \"downloading\" ? state : current)).pipe(\n          Effect.asVoid,\n        ),\n      ),\n      Effect.catchCause((cause) => {\n        if (Cause.hasInterruptsOnly(cause)) {\n          return Effect.failCause(cause);\n        }\n        const error = new DesktopUpdateUnexpectedActionError({ action: \"download\", cause });\n        return Effect.gen(function* () {\n          yield* updateState((current) =>\n            reduceDesktopUpdateStateOnDownloadFailure(current, error.message),\n          );\n          yield* logUpdaterError(error.message, {\n            errorTag: error._tag,\n            action: error.action,\n          });\n          return { accepted: true, completed: false };\n        });\n      }),\n      Effect.ensuring(finishUpdateAction(\"download\")),\n    );\n  }).pipe(Effect.withSpan(\"desktop.updates.downloadAvailableUpdate\"));",
    "checksum": "446f64f027ab1d89316bef75ed8f588b90ca57499d539bc7843dbab3994a2393"
  },
  "desktop-update-install-boundary": {
    "id": "desktop-update-install-boundary",
    "path": "apps/desktop/src/updates/DesktopUpdates.ts",
    "start": 465,
    "end": 575,
    "language": "typescript",
    "label": "Desktop install stops every backend before updater-controlled restart",
    "code": "  const installDownloadedUpdate = Effect.gen(function* () {\n    const state = yield* Ref.get(updateStateRef);\n    const hasInstallableDownload =\n      state.downloadedVersion !== null &&\n      (state.status === \"downloaded\" ||\n        (state.status === \"error\" &&\n          (state.errorContext === null || state.errorContext === \"install\")));\n    if (\n      (yield* Ref.get(desktopState.quitting)) ||\n      !(yield* Ref.get(updaterConfiguredRef)) ||\n      !hasInstallableDownload\n    ) {\n      return { accepted: false, completed: false };\n    }\n\n    if (!(yield* tryStartUpdateAction(\"install\"))) {\n      return { accepted: false, completed: false };\n    }\n\n    yield* Ref.set(desktopState.quitting, true);\n\n    return yield* Effect.gen(function* () {\n      // Stop every backend in the pool, not just the primary. With\n      // parallel WSL + Windows backends, leaving the WSL instance up\n      // means quitAndInstall's app.quit() exits before the pool's\n      // scope cascade has a chance to run its stop finalizer, so the\n      // WSL child gets hard-killed by the OS instead of receiving\n      // SIGTERM + grace. Stops run concurrently with the same 5s\n      // budget the primary had on its own.\n      const instances = yield* pool.list;\n      yield* Effect.forEach(\n        instances,\n        (instance) => instance.stop({ timeout: Duration.seconds(5) }),\n        { concurrency: \"unbounded\" },\n      );\n      yield* electronWindow.destroyAll;\n      yield* electronUpdater.quitAndInstall({\n        isSilent: true,\n        isForceRunAfter: true,\n      });\n      return { accepted: true, completed: false };\n    }).pipe(\n      Effect.catchTags({\n        ElectronUpdaterQuitAndInstallError: Effect.fn(\"desktop.updates.handleInstallFailure\")(\n          function* (error) {\n            yield* resetInstallAction;\n            yield* updateState((current) =>\n              reduceDesktopUpdateStateOnInstallFailure(current, error.message),\n            );\n            yield* logUpdaterError(error.message, {\n              errorTag: error._tag,\n              channel: error.channel,\n              isSilent: error.isSilent,\n              isForceRunAfter: error.isForceRunAfter,\n            });\n            return { accepted: true, completed: false };\n          },\n        ),\n      }),\n      Effect.onInterrupt(() => resetInstallAction),\n      Effect.catchCause((cause) =>\n        Effect.gen(function* () {\n          if (Cause.hasInterruptsOnly(cause)) {\n            return yield* Effect.failCause(cause);\n          }\n          yield* resetInstallAction;\n          const error = new DesktopUpdateUnexpectedActionError({ action: \"install\", cause });\n          yield* updateState((current) =>\n            reduceDesktopUpdateStateOnInstallFailure(current, error.message),\n          );\n          yield* logUpdaterError(error.message, {\n            errorTag: error._tag,\n            action: error.action,\n          });\n          return { accepted: true, completed: false };\n        }),\n      ),\n    );\n  }).pipe(Effect.withSpan(\"desktop.updates.installDownloadedUpdate\"));\n\n  const startUpdatePollers: Effect.Effect<void, never, Scope.Scope> = Effect.gen(function* () {\n    yield* Effect.sleep(AUTO_UPDATE_STARTUP_DELAY).pipe(\n      Effect.andThen(checkForUpdates(\"startup\")),\n      Effect.catchCause((cause) => {\n        if (Cause.hasInterruptsOnly(cause)) {\n          return Effect.void;\n        }\n        const error = new DesktopUpdatePollerError({ poller: \"startup\", cause });\n        return logUpdaterError(error.message, {\n          errorTag: error._tag,\n          poller: error.poller,\n        });\n      }),\n      Effect.forkScoped,\n    );\n    yield* Effect.sleep(AUTO_UPDATE_POLL_INTERVAL).pipe(\n      Effect.andThen(checkForUpdates(\"poll\")),\n      Effect.forever,\n      Effect.catchCause((cause) => {\n        if (Cause.hasInterruptsOnly(cause)) {\n          return Effect.void;\n        }\n        const error = new DesktopUpdatePollerError({ poller: \"poll\", cause });\n        return logUpdaterError(error.message, {\n          errorTag: error._tag,\n          poller: error.poller,\n        });\n      }),\n      Effect.forkScoped,\n    );\n  }).pipe(Effect.withSpan(\"desktop.updates.startPollers\"));",
    "checksum": "c192a6561381eb1d602b20151a6d027ae2bbbf6a34ec901d4b37a3f1421d8e95"
  },
  "server-update-exact-preflight": {
    "id": "server-update-exact-preflight",
    "path": "apps/server/src/cloud/selfUpdate.ts",
    "start": 64,
    "end": 169,
    "language": "typescript",
    "label": "Server self-update accepts only an exact version that passes staged preflight",
    "code": "  const update: ServerSelfUpdate[\"Service\"][\"update\"] = Effect.fn(\n    \"cloud.server_self_update.update\",\n  )(function* (input, reportProgress = () => Effect.void) {\n    if (capability === \"desktop-managed\") {\n      return yield* failWith(\n        \"This server is managed by the T3 Code desktop app on its machine; update the desktop app to update it.\",\n      );\n    }\n    if (capability === null) {\n      return yield* failWith(\n        \"Remote updates require the T3 Code background service. Run `t3 service install` on the server machine.\",\n      );\n    }\n\n    const targetVersion = input.targetVersion.trim();\n    if (!isExactServiceVersion(targetVersion)) {\n      return yield* failWith(`'${targetVersion}' is not an exact t3 version.`);\n    }\n    if (yield* Ref.getAndSet(inFlight, true)) {\n      return yield* failWith(\"A server update is already in progress.\");\n    }\n\n    return yield* Effect.gen(function* () {\n      yield* reportProgress(\"downloading\");\n      const paths = yield* ensurePinnedRuntimeInstalled({\n        baseDir: serverConfig.baseDir,\n        version: targetVersion,\n        fs,\n        path,\n        runner,\n        validate: (runtime) =>\n          runner\n            .run({\n              command: execPath,\n              args: [\n                runtime.entryPath,\n                \"__service-preflight\",\n                \"--database-path\",\n                serverConfig.dbPath,\n                \"--launcher-protocol\",\n                String(SERVICE_LAUNCHER_PROTOCOL),\n              ],\n              timeout: PREFLIGHT_TIMEOUT,\n            })\n            .pipe(\n              Effect.mapError(\n                (cause) =>\n                  new PinnedRuntimeInstallError({\n                    step: \"running the staged service preflight\",\n                    cause,\n                  }),\n              ),\n              Effect.flatMap(\n                (\n                  result,\n                ): Effect.Effect<\n                  void,\n                  PinnedRuntimeInstallError | PinnedRuntimePreflightBlockedError\n                > => {\n                  if (result.code !== 0) {\n                    return Effect.fail(\n                      new PinnedRuntimeInstallError({\n                        step: \"running the staged service preflight\",\n                        exitCode: Number(result.code),\n                        stdoutLength: result.stdout.length,\n                        stderrLength: result.stderr.length,\n                      }),\n                    );\n                  }\n                  let parsed: unknown;\n                  try {\n                    parsed = JSON.parse(result.stdout.trim());\n                  } catch (cause) {\n                    return Effect.fail(\n                      new PinnedRuntimeInstallError({\n                        step: \"decoding the staged service preflight\",\n                        cause,\n                      }),\n                    );\n                  }\n                  const preflight = decodeServicePreflightResult(parsed);\n                  if (preflight === undefined || preflight.version !== targetVersion) {\n                    return Effect.fail(\n                      new PinnedRuntimeInstallError({\n                        step: \"verifying the staged service preflight\",\n                      }),\n                    );\n                  }\n                  return preflight.status === \"ready\"\n                    ? Effect.void\n                    : Effect.fail(\n                        new PinnedRuntimePreflightBlockedError({\n                          version: targetVersion,\n                          reason: preflight.reason,\n                        }),\n                      );\n                },\n              ),\n            ),\n      }).pipe(\n        Effect.mapError((error) =>\n          error._tag === \"PinnedRuntimePreflightBlockedError\"\n            ? failWith(error.reason, error)\n            : failWith(`Could not prepare t3@${targetVersion}.`, error),\n        ),\n      );",
    "checksum": "2024b45fe781d2feca6c8eb96b8b543c146198449303cc50ed7d838efa3e3ab3"
  },
  "server-update-launcher-handoff": {
    "id": "server-update-launcher-handoff",
    "path": "apps/server/src/cloud/selfUpdate.ts",
    "start": 171,
    "end": 191,
    "language": "typescript",
    "label": "Prepared server runtime is handed to the stable launcher by update id",
    "code": "      yield* reportProgress(\"installing\");\n      const updateId = yield* launcher\n        .requestUpdate({ targetVersion, dbPath: serverConfig.dbPath })\n        .pipe(\n          Effect.mapError((error) =>\n            failWith(\n              error._tag === \"ServiceLauncherRejectedError\"\n                ? error.reason\n                : \"Could not ask the service launcher to activate the prepared update.\",\n              error,\n            ),\n          ),\n        );\n\n      yield* Effect.logInfo(\"Server update prepared; handing off to the service launcher.\", {\n        updateId,\n        targetVersion,\n        runtimePath: paths.entryPath,\n      });\n      return { targetVersion, method: \"boot-service\" as const, updateId };\n    }).pipe(Effect.onError(() => Ref.set(inFlight, false)));",
    "checksum": "ce552ec0f0f18d4a12f7a90044b4492a886c4e35c1044f3bedf158442e4ec62b"
  },
  "mobile-ota-fingerprint-policy": {
    "id": "mobile-ota-fingerprint-policy",
    "path": "apps/mobile/app.config.ts",
    "start": 159,
    "end": 180,
    "language": "typescript",
    "label": "Mobile runtime compatibility is keyed by native fingerprint",
    "code": "const config: ExpoConfig = {\n  name: variant.appName,\n  slug: \"t3-code\",\n  platforms: [\"ios\", \"android\"],\n  scheme: variant.scheme,\n  version: \"1.0.4\",\n  runtimeVersion: {\n    // Fingerprint (not appVersion) so an OTA only reaches binaries whose native\n    // project — native deps, config plugins, AND patches/ — matches the update.\n    // With appVersion, every 0.1.0 build shares a runtime version, so a JS update\n    // could land on a binary missing the native changes it needs and crash.\n    policy: process.env.MOBILE_VERSION_POLICY ?? \"fingerprint\",\n  },\n  orientation: \"portrait\",\n  icon: variant.assets.appIcon,\n  userInterfaceStyle: \"automatic\",\n  updates: {\n    enabled: true,\n    url: \"https://u.expo.dev/d763fcb8-d37c-41ea-a773-b54a0ab4a454\",\n    checkAutomatically: \"ON_LOAD\",\n    fallbackToCacheTimeout: 0,\n  },",
    "checksum": "8fca9ce8ca5fe7a6a1fa27d63f6bef643e0df47b68108ea3c1bbb3d29227b3a2"
  },
  "analytics-posthog-controls": {
    "id": "analytics-posthog-controls",
    "path": "apps/server/src/telemetry/AnalyticsService.ts",
    "start": 31,
    "end": 44,
    "language": "typescript",
    "label": "PostHog destination, opt-out, and bounded buffer configuration",
    "code": "const TelemetryEnvConfig = Config.all({\n  posthogKey: Config.string(\"T3CODE_POSTHOG_KEY\").pipe(\n    Config.withDefault(\"phc_XOWci4oZP4VvLiEyrFqkFjP4CZn55mjYYBMREK5Wd6m\"),\n  ),\n  posthogHost: Config.string(\"T3CODE_POSTHOG_HOST\").pipe(\n    Config.withDefault(\"https://us.i.posthog.com\"),\n  ),\n  enabled: Config.boolean(\"T3CODE_TELEMETRY_ENABLED\").pipe(Config.withDefault(true)),\n  flushBatchSize: Config.number(\"T3CODE_TELEMETRY_FLUSH_BATCH_SIZE\").pipe(Config.withDefault(20)),\n  maxBufferedEvents: Config.number(\"T3CODE_TELEMETRY_MAX_BUFFERED_EVENTS\").pipe(\n    Config.withDefault(1_000),\n  ),\n  wslDistroName: Config.string(\"WSL_DISTRO_NAME\").pipe(Config.option),\n});",
    "checksum": "f3c3ac2e572cef41e21529c9b74a5142da3d04ae2b8f5b948096e8eb497141c9"
  },
  "analytics-posthog-boundary": {
    "id": "analytics-posthog-boundary",
    "path": "apps/server/src/telemetry/AnalyticsService.ts",
    "start": 69,
    "end": 134,
    "language": "typescript",
    "label": "Installation-scoped analytics payload and PostHog batch boundary",
    "code": "export const make = Effect.gen(function* () {\n  const telemetryConfig = yield* TelemetryEnvConfig;\n  const httpClient = yield* HttpClient.HttpClient;\n  const serverConfig = yield* ServerConfig.ServerConfig;\n  const identifier = yield* getTelemetryIdentifier;\n  const bufferRef = yield* Ref.make<ReadonlyArray<BufferedAnalyticsEvent>>([]);\n  const clientType = serverConfig.mode === \"desktop\" ? \"desktop-app\" : \"cli-web-client\";\n  const hostPlatform = yield* HostProcessPlatform;\n  const hostArchitecture = yield* HostProcessArchitecture;\n\n  const enqueueBufferedEvent = (event: string, properties?: Readonly<Record<string, unknown>>) =>\n    Effect.flatMap(DateTime.now, (now) =>\n      Ref.modify(bufferRef, (current) => {\n        const appended = [\n          ...current,\n          {\n            event,\n            ...(properties ? { properties } : {}),\n            capturedAt: DateTime.formatIso(now),\n          } satisfies BufferedAnalyticsEvent,\n        ];\n\n        const next =\n          appended.length > telemetryConfig.maxBufferedEvents\n            ? appended.slice(appended.length - telemetryConfig.maxBufferedEvents)\n            : appended;\n\n        return [\n          {\n            size: next.length,\n            dropped: next.length !== appended.length,\n          } as const,\n          next,\n        ] as const;\n      }),\n    );\n\n  const sendBatch = Effect.fn(\"AnalyticsService.sendBatch\")(function* (\n    events: ReadonlyArray<BufferedAnalyticsEvent>,\n  ) {\n    if (!telemetryConfig.enabled || !identifier) return;\n\n    const payload = {\n      api_key: telemetryConfig.posthogKey,\n      batch: events.map((event) => ({\n        event: event.event,\n        distinct_id: identifier,\n        properties: {\n          ...event.properties,\n          $process_person_profile: false,\n          platform: hostPlatform,\n          wsl: Option.getOrUndefined(telemetryConfig.wslDistroName),\n          arch: hostArchitecture,\n          t3CodeVersion: packageJson.version,\n          clientType,\n        },\n        timestamp: event.capturedAt,\n      })),\n    };\n\n    yield* HttpClientRequest.post(`${telemetryConfig.posthogHost}/batch/`).pipe(\n      HttpClientRequest.bodyJson(payload),\n      Effect.flatMap(httpClient.execute),\n      Effect.flatMap(HttpClientResponse.filterStatusOk),\n    );\n  });",
    "checksum": "80a1888ab4ce1d23e1388a370d7d82c5313eeb46c325eb8d74c5609a55b8a82a"
  },
  "analytics-identity-ladder": {
    "id": "analytics-identity-ladder",
    "path": "apps/server/src/telemetry/Identify.ts",
    "start": 248,
    "end": 299,
    "language": "typescript",
    "label": "Hashed Codex, Claude, then anonymous analytics identity ladder",
    "code": "/**\n * getTelemetryIdentifier - Users are \"identified\" by finding the first match of the following, then hashing the value.\n * 1. ~/.codex/auth.json tokens.account_id\n * 2. ~/.claude.json userID\n * 3. ~/.t3/telemetry/anonymous-id\n */\nexport const getTelemetryIdentifierForHome = Effect.fn(\"getTelemetryIdentifierForHome\")(\n  function* (homeDirectory: string) {\n    const codexAccountId = yield* getCodexAccountId(homeDirectory).pipe(\n      Effect.catchTags({\n        TelemetryIdentityReadError: (error) =>\n          logTelemetryIdentityError(error).pipe(Effect.as(Option.none<string>())),\n        TelemetryIdentityDecodeError: (error) =>\n          logTelemetryIdentityError(error).pipe(Effect.as(Option.none<string>())),\n      }),\n    );\n    if (Option.isSome(codexAccountId)) {\n      return yield* hash(\"codex\", codexAccountId.value);\n    }\n\n    const claudeUserId = yield* getClaudeUserId(homeDirectory).pipe(\n      Effect.catchTags({\n        TelemetryIdentityReadError: (error) =>\n          logTelemetryIdentityError(error).pipe(Effect.as(Option.none<string>())),\n        TelemetryIdentityDecodeError: (error) =>\n          logTelemetryIdentityError(error).pipe(Effect.as(Option.none<string>())),\n      }),\n    );\n    if (Option.isSome(claudeUserId)) {\n      return yield* hash(\"claude\", claudeUserId.value);\n    }\n\n    const anonymousId = yield* upsertAnonymousId.pipe(\n      Effect.map(Option.some),\n      Effect.catchTags({\n        TelemetryIdentityReadError: (error) =>\n          logTelemetryIdentityError(error).pipe(Effect.as(Option.none<string>())),\n        TelemetryAnonymousIdGenerationError: (error) =>\n          logTelemetryIdentityError(error).pipe(Effect.as(Option.none<string>())),\n        TelemetryAnonymousIdPersistenceError: (error) =>\n          logTelemetryIdentityError(error).pipe(Effect.as(Option.none<string>())),\n      }),\n    );\n    if (Option.isSome(anonymousId)) {\n      return yield* hash(\"anonymous\", anonymousId.value);\n    }\n\n    return null;\n  },\n  Effect.tapError(logTelemetryIdentityError),\n  Effect.orElseSucceed(() => null),\n);",
    "checksum": "faea0eb8f89de6534789b7d542ee9f8ca43255aea1750edd5948f682e9a41018"
  },
  "observability-local-remote-lanes": {
    "id": "observability-local-remote-lanes",
    "path": "apps/server/src/observability/Layers/Observability.ts",
    "start": 19,
    "end": 93,
    "language": "typescript",
    "label": "Local trace sink remains active while OTLP traces and metrics are optional",
    "code": "export const ObservabilityLive = Layer.unwrap(\n  Effect.gen(function* () {\n    const config = yield* ServerConfig.ServerConfig;\n    const attribution = yield* ResourceAttribution.ResourceAttribution;\n\n    const traceReferencesLayer = Layer.mergeAll(\n      Layer.succeed(Tracer.MinimumTraceLevel, config.traceMinLevel),\n      Layer.succeed(References.TracerTimingEnabled, config.traceTimingEnabled),\n      httpHeaderRedactionLayer,\n    );\n\n    const tracerLayer = Layer.unwrap(\n      Effect.gen(function* () {\n        const sink = yield* makeTraceSink({\n          filePath: config.serverTracePath,\n          maxBytes: config.traceMaxBytes,\n          maxFiles: config.traceMaxFiles,\n          batchWindowMs: config.traceBatchWindowMs,\n          onFlush: (stats) =>\n            attribution.record({\n              component: \"server-trace\",\n              operation: \"append\",\n              logicalWriteBytes: stats.logicalWriteBytes,\n              count: stats.count,\n              durationMs: stats.durationMs,\n            }),\n        });\n        const delegate =\n          config.otlpTracesUrl === undefined\n            ? undefined\n            : yield* OtlpTracer.make({\n                url: config.otlpTracesUrl,\n                exportInterval: `${config.otlpExportIntervalMs} millis`,\n                resource: {\n                  serviceName: config.otlpServiceName,\n                  attributes: {\n                    \"service.runtime\": \"t3-server\",\n                    \"service.mode\": config.mode,\n                  },\n                },\n              });\n\n        const tracer = yield* makeLocalFileTracer({\n          filePath: config.serverTracePath,\n          maxBytes: config.traceMaxBytes,\n          maxFiles: config.traceMaxFiles,\n          batchWindowMs: config.traceBatchWindowMs,\n          sink,\n          ...(delegate ? { delegate } : {}),\n        });\n\n        return Layer.mergeAll(\n          Layer.succeed(Tracer.Tracer, tracer),\n          BrowserTraceCollector.layer(sink),\n        );\n      }),\n    ).pipe(Layer.provide(OtlpExporter.layerFlusher), Layer.provideMerge(otlpSerializationLayer));\n\n    const metricsLayer =\n      config.otlpMetricsUrl === undefined\n        ? Layer.empty\n        : OtlpMetrics.layer({\n            url: config.otlpMetricsUrl,\n            exportInterval: `${config.otlpExportIntervalMs} millis`,\n            resource: {\n              serviceName: config.otlpServiceName,\n              attributes: {\n                \"service.runtime\": \"t3-server\",\n                \"service.mode\": config.mode,\n              },\n            },\n          }).pipe(Layer.provideMerge(otlpSerializationLayer));\n\n    return Layer.mergeAll(ServerLoggerLive, traceReferencesLayer, tracerLayer, metricsLayer);\n  }),",
    "checksum": "17644127b1a5444891920976b4f660fd3be2843d14f8d933394aad5b5c24f390"
  },
  "observability-browser-ingest": {
    "id": "observability-browser-ingest",
    "path": "apps/server/src/http.ts",
    "start": 146,
    "end": 199,
    "language": "typescript",
    "label": "Authenticated browser traces land locally before optional OTLP forwarding",
    "code": "export const otlpTracesProxyRouteLayer = HttpRouter.add(\n  \"POST\",\n  OTLP_TRACES_PROXY_PATH,\n  Effect.gen(function* () {\n    yield* authenticateRawRouteWithScope(AuthOrchestrationOperateScope);\n    const request = yield* HttpServerRequest.HttpServerRequest;\n    const config = yield* ServerConfig.ServerConfig;\n    const otlpTracesUrl = config.otlpTracesUrl;\n    const browserTraceCollector = yield* BrowserTraceCollector.BrowserTraceCollector;\n    const httpClient = yield* HttpClient.HttpClient;\n    const bodyJson = cast<unknown, OtlpTracer.TraceData>(yield* request.json);\n\n    yield* Effect.try({\n      try: () => decodeOtlpTraceRecords(bodyJson),\n      catch: (cause) => new DecodeOtlpTraceRecordsError({ cause, bodyJson }),\n    }).pipe(\n      Effect.flatMap((records) => browserTraceCollector.record(records)),\n      Effect.catch((cause) =>\n        Effect.logWarning(\"Failed to decode browser OTLP traces\", {\n          cause,\n          bodyJson,\n        }),\n      ),\n    );\n\n    if (otlpTracesUrl === undefined) {\n      return HttpServerResponse.empty({ status: 204 });\n    }\n\n    return yield* httpClient\n      .post(otlpTracesUrl, {\n        body: HttpBody.jsonUnsafe(bodyJson),\n      })\n      .pipe(\n        Effect.flatMap(HttpClientResponse.filterStatusOk),\n        Effect.as(HttpServerResponse.empty({ status: 204 })),\n        Effect.tapError((cause) =>\n          Effect.logWarning(\"Failed to export browser OTLP traces\", {\n            cause,\n            otlpTracesUrl,\n          }),\n        ),\n        Effect.orElseSucceed(() =>\n          HttpServerResponse.text(\"Trace export failed.\", { status: 502 }),\n        ),\n      );\n  }).pipe(\n    Effect.catchTags({\n      EnvironmentAuthInvalidError: HttpServerRespondable.toResponse,\n      EnvironmentInternalError: HttpServerRespondable.toResponse,\n      EnvironmentScopeRequiredError: HttpServerRespondable.toResponse,\n    }),\n  ),\n);",
    "checksum": "220e35097ba87ab35826ac3da655a6551055a457378aba8aaa77c21f843990c0"
  },
  "resource-telemetry-demand-history": {
    "id": "resource-telemetry-demand-history",
    "path": "docs/internals/resource-telemetry.md",
    "start": 129,
    "end": 170,
    "language": "markdown",
    "label": "Bounded native history and diagnostics-driven telemetry streaming",
    "code": "### Native history and streaming\n\nEvery native sample is appended to a one-hour in-memory ring bounded to 3,600\nsnapshots, 20,000 retained process rows, and 64 MiB of retained history bytes.\nHistory stays in the sidecar until a `readHistory` request and is returned in\nbounded chunks. The first bound reached wins, so high process counts or large\nprocess names and command lines shorten the effective history window.\n\nPeriodic snapshot streaming is disabled by default. The server enables it only\nwhile at least one diagnostics subscription is retained. `sampleNow` remains\navailable for explicit refreshes and identity validation.\n\nThe server adjusts native sampling without restarting the sidecar:\n\n- suspended, locked, low-power, or serious/critical thermal state: 15 seconds;\n- battery: 5 seconds;\n- normal AC: 1 second;\n- unknown or stale power: 5 seconds in the background and 1 second while live\n  diagnostics is open.\n\n### Sampling limits\n\nThis is counter sampling, not syscall tracing.\n\n- A process that starts and exits entirely between samples may not be observed.\n- Cumulative CPU and I/O counters still provide accurate deltas for processes\n  that survive across samples.\n- Exact file paths, individual write syscalls, ETW events, eBPF events, and\n  Endpoint Security events are outside this implementation.\n\nThose deeper tracing systems can be added later as opt-in diagnostic modes\nwithout changing the public `ResourceTelemetry` model.\n\n## I/O semantics\n\nThe monitor preserves platform semantics instead of presenting all counters as\nequivalent:\n\n- Unix-like platforms report storage I/O counters exposed by `sysinfo`.\n- Windows reports all process I/O bytes, not only disk bytes.\n- Operating-system caches can prevent logical application reads or writes from\n  appearing as physical storage bytes.",
    "checksum": "5bc90ad0498b5f6e9b3dfc618b9d6f42d05938c26dfb3dcdc8b98d01446d89f7"
  },
  "connect-oauth-hosted-handoff": {
    "id": "connect-oauth-hosted-handoff",
    "path": "packages/shared/src/connectAuth.ts",
    "start": 19,
    "end": 104,
    "language": "typescript",
    "label": "Hosted OAuth handoff and loopback versus out-of-band callbacks",
    "code": "/**\n * Requested at authorize time by the hosted page and honored by the CLI's\n * token exchange; keep both sides on this single definition.\n */\nexport const CONNECT_OAUTH_SCOPES = [\"openid\", \"profile\", \"email\"] as const;\n\nexport interface ConnectAuthorizeRequest {\n  readonly state: string;\n  readonly challenge: string;\n  /**\n   * Present when a loopback CLI initiated the request: the hosted /connect\n   * page then asks Clerk to redirect the authorization code straight to\n   * `http://127.0.0.1:<port>/callback` instead of the hosted callback page.\n   */\n  readonly loopbackPort?: number;\n}\n\n/**\n * The URL the CLI prints for the user to open in a browser. `state` and\n * `code_challenge` ride the fragment so they never reach the hosted app's\n * server or CDN logs; neither is a secret.\n *\n * Both CLI flows route through the hosted /connect page rather than hitting\n * Clerk's /oauth/authorize directly: a signed-out browser sent straight to\n * /oauth/authorize goes through Clerk's sign-in redirect, which does not\n * reliably preserve the authorize query parameters (state, response_type,\n * code_challenge). The hosted page waits for a Clerk session first, then\n * forwards the request with the parameters intact.\n */\nexport function buildConnectAuthorizeRequestUrl(input: {\n  readonly hostedAppUrl: string;\n  readonly state: string;\n  readonly challenge: string;\n  readonly loopbackPort?: number;\n}): string {\n  const url = new URL(CONNECT_AUTHORIZE_PATH, input.hostedAppUrl);\n  url.hash = new URLSearchParams([\n    [CONNECT_AUTH_STATE_PARAM, input.state],\n    [CONNECT_AUTH_CHALLENGE_PARAM, input.challenge],\n    ...(input.loopbackPort === undefined\n      ? []\n      : [[CONNECT_AUTH_PORT_PARAM, String(input.loopbackPort)] as [string, string]]),\n  ]).toString();\n  return url.toString();\n}\n\nexport function readConnectAuthorizeRequest(url: URL): ConnectAuthorizeRequest | null {\n  const params = readHashParams(url);\n  const state = params.get(CONNECT_AUTH_STATE_PARAM)?.trim() ?? \"\";\n  const challenge = params.get(CONNECT_AUTH_CHALLENGE_PARAM)?.trim() ?? \"\";\n  if (!state || !challenge) {\n    return null;\n  }\n  const port = params.get(CONNECT_AUTH_PORT_PARAM);\n  if (port === null) {\n    return { state, challenge };\n  }\n  // A present-but-invalid port means the link was corrupted; reject the whole\n  // request rather than silently downgrading a loopback flow to the\n  // out-of-band one, which would strand the waiting CLI.\n  const loopbackPort = parseLoopbackPort(port.trim());\n  if (loopbackPort === null) {\n    return null;\n  }\n  return { state, challenge, loopbackPort };\n}\n\nfunction parseLoopbackPort(value: string): number | null {\n  if (!/^\\d{1,5}$/.test(value)) {\n    return null;\n  }\n  const port = Number(value);\n  return port >= 1 && port <= 65535 ? port : null;\n}\n\n/**\n * Redirect URI for the CLI's local callback listener. Must stay in sync with\n * the redirect URI registered on the Clerk CLI OAuth application.\n */\nexport function connectLoopbackRedirectUri(port: number): string {\n  return `http://127.0.0.1:${port}${CONNECT_LOOPBACK_CALLBACK_PATH}`;\n}\n\nexport function connectCallbackUrl(hostedAppUrl: string): string {\n  return new URL(CONNECT_CALLBACK_PATH, hostedAppUrl).toString();\n}",
    "checksum": "019508052e9e226164594a9bd72a85bf869819e0c3de33c5d0f4865e25decbbb"
  },
  "connect-oauth-cli-pkce": {
    "id": "connect-oauth-cli-pkce",
    "path": "apps/server/src/cloud/CliTokenManager.ts",
    "start": 266,
    "end": 323,
    "language": "typescript",
    "label": "CLI PKCE, state validation, and authorization-code exchange",
    "code": "const makePkceRequest = Effect.gen(function* () {\n  const crypto = yield* Crypto.Crypto;\n  const verifier = Encoding.encodeBase64Url(yield* crypto.randomBytes(32));\n  const challenge = Encoding.encodeBase64Url(\n    yield* crypto.digest(\"SHA-256\", new TextEncoder().encode(verifier)),\n  );\n  const state = Encoding.encodeBase64Url(yield* crypto.randomBytes(16));\n  return { verifier, challenge, state };\n});\n\nexport interface OutOfBandOAuthPromptInput {\n  readonly authorizeUrl: string;\n  readonly validate: (value: string) => Effect.Effect<string, string>;\n}\n\n/**\n * Out-of-band OAuth for machines without a local browser (SSH). The user\n * opens the hosted /connect URL elsewhere, signs in, and enters the displayed\n * code in this terminal. The PKCE verifier never leaves this process, so the\n * authorization code is useless to an observer, and the state bundled into\n * the blob preserves the loopback flow's CSRF check.\n */\nexport const outOfBandOAuthLogin = Effect.fn(\"cloud.cli_token.out_of_band_oauth_login\")(function* <\n  E,\n  R,\n>(promptForCode: (input: OutOfBandOAuthPromptInput) => Effect.Effect<string, E, R>) {\n  const metadata = yield* cloudCliOAuthConfig;\n  const hostedAppUrl = yield* hostedAppUrlConfig;\n  const { verifier, challenge, state } = yield* makePkceRequest;\n\n  const authorizationCode = yield* promptForCode({\n    authorizeUrl: buildConnectAuthorizeRequestUrl({ hostedAppUrl, state, challenge }),\n    validate: (value) => {\n      const checked = checkConnectAuthCode(value, state);\n      return typeof checked === \"string\" ? Effect.fail(checked) : Effect.succeed(value);\n    },\n  }).pipe(\n    // Clerk authorization codes expire on this horizon anyway; matching the\n    // loopback flow's timeout turns an abandoned prompt into a clear error.\n    Effect.timeout(CLOUD_CLI_OAUTH_CALLBACK_TIMEOUT),\n    Effect.catchTag(\"TimeoutError\", (cause) =>\n      Effect.fail(new CloudCliAuthorizationTimeoutError({ cause })),\n    ),\n  );\n  // promptForCode is caller-supplied, so re-check the returned value rather\n  // than trusting that the prompt ran validate.\n  const authCode = checkConnectAuthCode(authorizationCode, state);\n  if (typeof authCode === \"string\") {\n    return yield* new CloudCliAuthorizationError({ cause: authCode });\n  }\n\n  return yield* exchangeToken(metadata, {\n    grant_type: \"authorization_code\",\n    code: authCode.code,\n    redirect_uri: connectCallbackUrl(hostedAppUrl),\n    client_id: metadata.clientId,\n    code_verifier: verifier,\n  });",
    "checksum": "0c0afa4526b464e06018e6ceb78ba3bbcfd588ced7303dbd9b515a9a5f7cedd8"
  },
  "connect-browser-dpop-key": {
    "id": "connect-browser-dpop-key",
    "path": "apps/web/src/cloud/dpop.ts",
    "start": 24,
    "end": 143,
    "language": "typescript",
    "label": "Browser P-256 DPoP key storage, generation, and thumbprint",
    "code": "const DPOP_DATABASE_NAME = \"t3code:cloud-auth\";\nconst DPOP_DATABASE_VERSION = 1;\nconst DPOP_KEY_STORE_NAME = \"keys\";\nconst DPOP_KEY_ID = \"relay-dpop-proof-key\";\nconst decodeDpopPublicJwk = Schema.decodeUnknownEffect(DpopPublicJwk);\n\nexport const browserCryptoLayer = Layer.succeed(\n  Crypto.Crypto,\n  Crypto.make({\n    randomBytes: (size) => globalThis.crypto.getRandomValues(new Uint8Array(size)),\n    digest: (algorithm, data) =>\n      Effect.promise(async () => {\n        const input = new Uint8Array(data.length);\n        input.set(data);\n        return new Uint8Array(await globalThis.crypto.subtle.digest(algorithm, input.buffer));\n      }),\n  }),\n);\n\nfunction dpopError(message: string, cause?: unknown) {\n  return new BrowserDpopError({ message, ...(cause === undefined ? {} : { cause }) });\n}\n\nfunction openDpopDatabase(): Effect.Effect<IDBDatabase, BrowserDpopError> {\n  return Effect.callback<IDBDatabase, BrowserDpopError>((resume) => {\n    const request = indexedDB.open(DPOP_DATABASE_NAME, DPOP_DATABASE_VERSION);\n    request.addEventListener(\"error\", () =>\n      resume(\n        Effect.fail(dpopError(\"Could not open DPoP key storage.\", request.error ?? undefined)),\n      ),\n    );\n    request.addEventListener(\"upgradeneeded\", () => {\n      if (!request.result.objectStoreNames.contains(DPOP_KEY_STORE_NAME)) {\n        request.result.createObjectStore(DPOP_KEY_STORE_NAME);\n      }\n    });\n    request.addEventListener(\"success\", () => resume(Effect.succeed(request.result)));\n  });\n}\n\nexport function readStoredBrowserDpopKey(): Effect.Effect<BrowserDpopKey | null, BrowserDpopError> {\n  if (typeof indexedDB === \"undefined\") {\n    return Effect.succeed(null);\n  }\n  return Effect.acquireUseRelease(\n    openDpopDatabase(),\n    (database) =>\n      Effect.callback<BrowserDpopKey | null, BrowserDpopError>((resume) => {\n        const request = database\n          .transaction(DPOP_KEY_STORE_NAME, \"readonly\")\n          .objectStore(DPOP_KEY_STORE_NAME)\n          .get(DPOP_KEY_ID);\n        request.addEventListener(\"error\", () =>\n          resume(Effect.fail(dpopError(\"Could not read DPoP key.\", request.error ?? undefined))),\n        );\n        request.addEventListener(\"success\", () =>\n          resume(Effect.succeed((request.result as BrowserDpopKey | undefined) ?? null)),\n        );\n      }),\n    (database) => Effect.sync(() => database.close()),\n  );\n}\n\nexport function writeStoredBrowserDpopKey(\n  key: BrowserDpopKey,\n): Effect.Effect<void, BrowserDpopError> {\n  if (typeof indexedDB === \"undefined\") {\n    return Effect.void;\n  }\n  return Effect.acquireUseRelease(\n    openDpopDatabase(),\n    (database) =>\n      Effect.callback<void, BrowserDpopError>((resume) => {\n        const transaction = database.transaction(DPOP_KEY_STORE_NAME, \"readwrite\");\n        transaction.addEventListener(\"error\", () =>\n          resume(\n            Effect.fail(dpopError(\"Could not write DPoP key.\", transaction.error ?? undefined)),\n          ),\n        );\n        transaction.addEventListener(\"complete\", () => resume(Effect.void));\n        transaction.objectStore(DPOP_KEY_STORE_NAME).put(key, DPOP_KEY_ID);\n      }),\n    (database) => Effect.sync(() => database.close()),\n  );\n}\n\nexport const generateBrowserDpopKey = Effect.gen(function* () {\n  const generated = yield* Effect.tryPromise({\n    try: () =>\n      crypto.subtle.generateKey({ name: \"ECDSA\", namedCurve: \"P-256\" }, true, [\n        \"sign\",\n        \"verify\",\n      ]) as Promise<CryptoKeyPair>,\n    catch: (cause) => dpopError(\"Could not generate DPoP proof key.\", cause),\n  });\n  const privateJwk = yield* Effect.tryPromise({\n    try: () => crypto.subtle.exportKey(\"jwk\", generated.privateKey),\n    catch: (cause) => dpopError(\"Could not export DPoP private key.\", cause),\n  });\n  const publicJwk = yield* Effect.tryPromise({\n    try: () => crypto.subtle.exportKey(\"jwk\", generated.publicKey),\n    catch: (cause) => dpopError(\"Could not export DPoP public key.\", cause),\n  }).pipe(\n    Effect.flatMap((jwk) => decodeDpopPublicJwk(jwk)),\n    Effect.mapError((cause) =>\n      cause instanceof BrowserDpopError\n        ? cause\n        : dpopError(\"Generated DPoP public key is invalid.\", cause),\n    ),\n  );\n  const privateKey = yield* Effect.tryPromise({\n    try: () => importJWK(privateJwk as JWK, \"ES256\", { extractable: false }) as Promise<CryptoKey>,\n    catch: (cause) => dpopError(\"Could not import DPoP private key.\", cause),\n  });\n  return {\n    privateKey,\n    publicJwk,\n    thumbprint: computeDpopJwkThumbprint(publicJwk),\n  };\n});",
    "checksum": "6a8194ca1a98d84a004e00c32168993c56318488d07f4c377c7ecfebf192d7c5"
  },
  "connect-environment-link-handshake": {
    "id": "connect-environment-link-handshake",
    "path": "apps/web/src/cloud/linkEnvironment.ts",
    "start": 402,
    "end": 493,
    "language": "typescript",
    "label": "Client-side relay challenge, environment proof, link, and runtime setup",
    "code": "export function linkPrimaryEnvironmentToCloud(input: {\n  readonly target: CloudLinkTarget;\n  readonly clerkToken: string;\n  readonly mode?: CloudLinkMode;\n}): Effect.Effect<\n  void,\n  CloudEnvironmentLinkError,\n  EnvironmentRegistry | HttpClient.HttpClient | ManagedRelay.ManagedRelayClient\n> {\n  return Effect.gen(function* () {\n    const configuredRelayUrl = relayUrl();\n    if (!configuredRelayUrl) {\n      return yield* new CloudEnvironmentLinkError({\n        message: \"T3CODE_RELAY_URL is not configured.\",\n      });\n    }\n    const managedTunnelsEnabled = (input.mode ?? \"managed\") === \"managed\";\n    const providerKind = managedTunnelsEnabled\n      ? MANAGED_ENDPOINT_PROVIDER_KIND\n      : PUBLISH_ONLY_PROVIDER_KIND;\n    const relayClient = yield* ManagedRelay.ManagedRelayClient;\n    const environmentClient = yield* makeEnvironmentHttpApiClient(input.target.httpBaseUrl);\n    if (managedTunnelsEnabled) {\n      yield* ensureRelayClientAvailable(EnvironmentId.make(input.target.environmentId));\n    }\n\n    const challenge = yield* relayClient\n      .createEnvironmentLinkChallenge({\n        clerkToken: input.clerkToken,\n        payload: {\n          notificationsEnabled: true,\n          liveActivitiesEnabled: true,\n          managedTunnelsEnabled,\n        },\n      })\n      .pipe(\n        Effect.mapError(\n          decodedRelayClientError(\n            `${configuredRelayUrl}/v1/client/environment-link-challenges failed`,\n          ),\n        ),\n      );\n    const proof = yield* environmentClient.connect\n      .linkProof({\n        headers: {},\n        payload: {\n          challenge: challenge.challenge,\n          relayIssuer: configuredRelayUrl,\n          endpoint: {\n            httpBaseUrl: input.target.httpBaseUrl,\n            wsBaseUrl: input.target.wsBaseUrl,\n            providerKind,\n          },\n          origin: endpointOrigin(input.target.httpBaseUrl),\n        },\n      })\n      .pipe(Effect.mapError(environmentApiError(\"Could not obtain environment link proof.\")));\n    const link = yield* relayClient\n      .linkEnvironment({\n        clerkToken: input.clerkToken,\n        payload: {\n          proof,\n          notificationsEnabled: true,\n          liveActivitiesEnabled: true,\n          managedTunnelsEnabled,\n        },\n      })\n      .pipe(\n        Effect.mapError(\n          decodedRelayClientError(`${configuredRelayUrl}/v1/client/environment-links failed`),\n        ),\n      );\n    yield* ensureLinkedEnvironmentMatches({\n      expectedEnvironmentId: input.target.environmentId,\n      expectedProviderKind: providerKind,\n      link,\n    });\n\n    yield* environmentClient.connect\n      .relayConfig({\n        headers: {},\n        payload: {\n          relayUrl: configuredRelayUrl,\n          relayIssuer: link.relayIssuer,\n          cloudUserId: link.cloudUserId,\n          environmentCredential: link.environmentCredential,\n          cloudMintPublicKey: link.cloudMintPublicKey,\n          endpointRuntime: link.endpointRuntime,\n        },\n      })\n      .pipe(Effect.mapError(environmentApiError(\"Could not configure environment relay access.\")));\n  }).pipe(Effect.provide(primaryEnvironmentHttpLayer));",
    "checksum": "205bb065dd80ce2f8b9cc5b0a127f436a52d7654918dbe64c11a55556a788dd1"
  },
  "connect-relay-linker-provision": {
    "id": "connect-relay-linker-provision",
    "path": "infra/relay/src/environments/EnvironmentLinker.ts",
    "start": 227,
    "end": 341,
    "language": "typescript",
    "label": "Relay challenge verification, replay defense, link, and endpoint provisioning",
    "code": "      const challenge = yield* relayTokens.verifyLinkChallenge({\n        token: verified.challenge,\n        userId: input.userId,\n        request: {\n          notificationsEnabled: input.request.notificationsEnabled,\n          liveActivitiesEnabled: input.request.liveActivitiesEnabled,\n          managedTunnelsEnabled: input.request.managedTunnelsEnabled,\n        },\n        nowEpochSeconds: nowSeconds,\n      });\n      if (challenge === null) {\n        return yield* new EnvironmentLinkProofInvalid({\n          userId: input.userId,\n          environmentId: verified.environmentId,\n          reason: \"challenge_invalid\",\n          stage: \"verify_challenge\",\n        });\n      }\n      const expiresAt = DateTime.make(verified.exp * 1_000);\n      if (expiresAt._tag === \"None\") {\n        return yield* new EnvironmentLinkProofInvalid({\n          userId: input.userId,\n          environmentId: verified.environmentId,\n          reason: \"invalid_signature_or_scope\",\n          stage: \"validate_expiration\",\n        });\n      }\n      const consumedNonce = yield* proofReplay.consume({\n        thumbprint: verified.environmentPublicKey,\n        jti: verified.jti,\n        iat: verified.iat,\n        expiresAt: expiresAt.value,\n      });\n      if (!consumedNonce) {\n        return yield* new EnvironmentLinkProofInvalid({\n          userId: input.userId,\n          environmentId: verified.environmentId,\n          reason: \"replayed_nonce\",\n          stage: \"consume_proof_nonce\",\n        });\n      }\n      const consumedChallenge = yield* proofReplay.consume({\n        thumbprint: \"relay-environment-link-challenge\",\n        jti: challenge.jti,\n        iat: challenge.iat,\n        expiresAt: expiresAt.value,\n      });\n      if (!consumedChallenge) {\n        return yield* new EnvironmentLinkProofInvalid({\n          userId: input.userId,\n          environmentId: verified.environmentId,\n          reason: \"challenge_invalid\",\n          stage: \"consume_challenge_nonce\",\n        });\n      }\n      if (input.request.managedTunnelsEnabled && !isLoopbackManagedTunnelOrigin(verified.origin)) {\n        return yield* new EnvironmentLinkProofInvalid({\n          userId: input.userId,\n          environmentId: verified.environmentId,\n          reason: \"origin_not_allowed\",\n          stage: \"validate_origin\",\n        });\n      }\n      // Downgrading a managed link to publish-only must release the tunnel and\n      // DNS that were provisioned for it — nothing else cleans them up until a\n      // full unlink. Best effort: a cleanup failure must not block the link\n      // itself, and the provider treats an absent allocation as already\n      // deprovisioned, so retrying on every non-tunnel link is cheap.\n      if (!input.request.managedTunnelsEnabled) {\n        yield* managedEndpointProvider\n          .deprovision({\n            userId: input.userId,\n            environmentId: verified.environmentId,\n          })\n          .pipe(\n            Effect.tapError((error) =>\n              Effect.logWarning(\"managed endpoint deprovision on publish-only link failed\", {\n                environmentId: verified.environmentId,\n                errorTag: error._tag,\n              }),\n            ),\n            Effect.ignore,\n          );\n      }\n      const provisioned = input.request.managedTunnelsEnabled\n        ? yield* managedEndpointProvider.provision({\n            userId: input.userId,\n            environmentId: verified.environmentId,\n            origin: verified.origin,\n          })\n        : null;\n      const endpoint = provisioned?.endpoint ?? verified.endpoint;\n      // The secure-endpoint requirement only matters when the relay advertises\n      // this endpoint for other devices to reach (managed tunnel). Publish-only\n      // links are reached out of band (e.g. Tailscale) and their stored endpoint\n      // is never used for routing, so a nominal endpoint is acceptable.\n      if (input.request.managedTunnelsEnabled && !isSecureManagedEndpoint(endpoint)) {\n        return yield* new EnvironmentLinkProofInvalid({\n          userId: input.userId,\n          environmentId: verified.environmentId,\n          reason: \"endpoint_not_secure\",\n          stage: \"validate_endpoint\",\n        });\n      }\n      yield* links.upsert({ ...input, proof: verified, endpoint });\n      const environmentCredential = yield* credentials.create({\n        environmentId: verified.environmentId,\n        environmentPublicKey: verified.environmentPublicKey,\n      });\n      return {\n        environmentId: verified.environmentId,\n        endpoint,\n        endpointRuntime: provisioned?.runtime ?? null,\n        environmentCredential,\n      };",
    "checksum": "34db35e5e050fa71891b31226f004cdc587587676000e7a21ed897494fe0fcf0"
  },
  "connect-managed-tunnel-provision": {
    "id": "connect-managed-tunnel-provision",
    "path": "infra/relay/src/environments/ManagedEndpointProvider.ts",
    "start": 604,
    "end": 855,
    "language": "typescript",
    "label": "Cloudflare tunnel allocation, ingress, DNS, and connector runtime",
    "code": "    provision: Effect.fn(\"relay.managed_endpoint_provider.provision\")(function* (input) {\n      yield* Effect.annotateCurrentSpan({\n        \"relay.user_id\": input.userId,\n        \"relay.environment_id\": input.environmentId,\n        \"relay.managed_endpoint.origin_host\": input.origin.localHttpHost,\n        \"relay.managed_endpoint.origin_port\": input.origin.localHttpPort,\n      });\n      if (!isLoopbackOrigin(input.origin)) {\n        return yield* new ManagedEndpointOriginNotAllowed({\n          userId: input.userId,\n          environmentId: input.environmentId,\n          host: input.origin.localHttpHost,\n          port: input.origin.localHttpPort,\n        });\n      }\n      const cf = yield* requireCloudflareSettings(config, input);\n      const environmentHash = yield* crypto\n        .digest(\n          \"SHA-256\",\n          new TextEncoder().encode(\n            managedEndpointDigestInput(cf.namespace, input.userId, input.environmentId),\n          ),\n        )\n        .pipe(\n          Effect.map(Encoding.encodeHex),\n          Effect.mapError(\n            (cause) =>\n              new ManagedEndpointProvisioningFailed({\n                userId: input.userId,\n                environmentId: input.environmentId,\n                stage: \"derive-environment-hash\",\n                cause,\n              }),\n          ),\n        );\n      const requestedHostname = managedEndpointHostname(\n        cf.namespace,\n        cf.baseDomain,\n        environmentHash,\n      );\n      const requestedTunnelName = managedEndpointTunnelName(cf.namespace, environmentHash);\n      yield* tunnelLimits\n        .ensureCapacity({\n          userId: input.userId,\n          environmentId: input.environmentId,\n        })\n        .pipe(\n          Effect.catchTags({\n            ManagedTunnelLimitPersistenceError: (cause) =>\n              Effect.fail(\n                new ManagedEndpointProvisioningFailed({\n                  userId: input.userId,\n                  environmentId: input.environmentId,\n                  stage: \"check-tunnel-limit\",\n                  hostname: requestedHostname,\n                  tunnelName: requestedTunnelName,\n                  cause,\n                }),\n              ),\n          }),\n        );\n      const allocation = yield* allocations\n        .reserve({\n          userId: input.userId,\n          environmentId: input.environmentId,\n          hostname: requestedHostname,\n          tunnelName: requestedTunnelName,\n        })\n        .pipe(\n          Effect.mapError(\n            (cause) =>\n              new ManagedEndpointProvisioningFailed({\n                userId: input.userId,\n                environmentId: input.environmentId,\n                stage: \"reserve-allocation\",\n                hostname: requestedHostname,\n                tunnelName: requestedTunnelName,\n                cause,\n              }),\n          ),\n        );\n      const { hostname, tunnelName } = allocation;\n\n      const tunnelResponse = yield* tunnels.list({ name: tunnelName, isDeleted: false }).pipe(\n        Effect.map((tunnels) => tunnels.result),\n        Effect.map(Arr.findFirst((tunnel) => tunnel.name === tunnelName)),\n        Effect.flatMap(\n          Option.match({\n            onSome: (tunnel) => Effect.succeed(tunnel),\n            onNone: () => tunnels.create({ name: tunnelName, configSrc: \"cloudflare\" }),\n          }),\n        ),\n        Effect.mapError(\n          (cause) =>\n            new ManagedEndpointProvisioningFailed({\n              userId: input.userId,\n              environmentId: input.environmentId,\n              stage: \"ensure-tunnel\",\n              hostname,\n              tunnelName,\n              cause,\n            }),\n        ),\n      );\n      if (!tunnelResponse.id || tunnelResponse.name !== tunnelName) {\n        return yield* new ManagedEndpointProvisioningFailed({\n          userId: input.userId,\n          environmentId: input.environmentId,\n          stage: \"validate-tunnel-response\",\n          hostname,\n          tunnelName,\n          ...(tunnelResponse.id ? { returnedTunnelId: tunnelResponse.id } : {}),\n          ...(tunnelResponse.name ? { returnedTunnelName: tunnelResponse.name } : {}),\n        });\n      }\n      const tunnel = { id: tunnelResponse.id, name: tunnelResponse.name };\n      yield* allocations\n        .recordTunnel({\n          userId: input.userId,\n          environmentId: input.environmentId,\n          tunnelId: tunnel.id,\n        })\n        .pipe(\n          Effect.mapError(\n            (cause) =>\n              new ManagedEndpointProvisioningFailed({\n                userId: input.userId,\n                environmentId: input.environmentId,\n                stage: \"record-tunnel\",\n                hostname,\n                tunnelName,\n                tunnelId: tunnel.id,\n                cause,\n              }),\n          ),\n        );\n\n      yield* tunnels\n        .putConfiguration(tunnel.id, {\n          ingress: [\n            {\n              hostname,\n              service: formatOriginService(input.origin),\n            },\n            { service: \"http_status:404\" },\n          ],\n        })\n        .pipe(\n          Effect.mapError(\n            (cause) =>\n              new ManagedEndpointProvisioningFailed({\n                userId: input.userId,\n                environmentId: input.environmentId,\n                stage: \"configure-tunnel\",\n                hostname,\n                tunnelName,\n                tunnelId: tunnel.id,\n                cause,\n              }),\n          ),\n        );\n\n      const dnsRecord = {\n        type: \"CNAME\",\n        name: hostname,\n        content: `${tunnel.id}.cfargotunnel.com`,\n        ttl: 1,\n        proxied: true,\n      } as const;\n\n      const dnsRecordId = yield* ensureDnsRecord(hostname, allocation.dnsRecordId, dnsRecord).pipe(\n        Effect.mapError(\n          (cause) =>\n            new ManagedEndpointProvisioningFailed({\n              userId: input.userId,\n              environmentId: input.environmentId,\n              stage: \"ensure-dns-record\",\n              hostname,\n              tunnelName,\n              tunnelId: tunnel.id,\n              ...(allocation.dnsRecordId === null ? {} : { dnsRecordId: allocation.dnsRecordId }),\n              cause,\n            }),\n        ),\n      );\n      yield* allocations\n        .recordDns({\n          userId: input.userId,\n          environmentId: input.environmentId,\n          dnsRecordId,\n        })\n        .pipe(\n          Effect.mapError(\n            (cause) =>\n              new ManagedEndpointProvisioningFailed({\n                userId: input.userId,\n                environmentId: input.environmentId,\n                stage: \"record-dns\",\n                hostname,\n                tunnelName,\n                tunnelId: tunnel.id,\n                dnsRecordId,\n                cause,\n              }),\n          ),\n        );\n\n      const connectorToken = yield* tunnels.getToken(tunnel.id).pipe(\n        Effect.mapError(\n          (cause) =>\n            new ManagedEndpointProvisioningFailed({\n              userId: input.userId,\n              environmentId: input.environmentId,\n              stage: \"get-tunnel-token\",\n              hostname,\n              tunnelName,\n              tunnelId: tunnel.id,\n              dnsRecordId,\n              cause,\n            }),\n        ),\n      );\n      yield* allocations\n        .markReady({\n          userId: input.userId,\n          environmentId: input.environmentId,\n        })\n        .pipe(\n          Effect.mapError(\n            (cause) =>\n              new ManagedEndpointProvisioningFailed({\n                userId: input.userId,\n                environmentId: input.environmentId,\n                stage: \"mark-allocation-ready\",\n                hostname,\n                tunnelName,\n                tunnelId: tunnel.id,\n                dnsRecordId,\n                cause,\n              }),\n          ),\n        );\n\n      return {\n        endpoint: managedEndpointForHostname(hostname),\n        runtime: {\n          providerKind: \"cloudflare_tunnel\",\n          connectorToken,\n          tunnelId: tunnel.id,\n          tunnelName: tunnel.name,\n        },\n      } satisfies ManagedEndpointProvisioningResult;",
    "checksum": "d9dfb0d6ddc6c065244090282008cc23ad237b8f854c37b6ae395981feaef571"
  },
  "connect-environment-runtime-tunnel": {
    "id": "connect-environment-runtime-tunnel",
    "path": "apps/server/src/cloud/ManagedEndpointRuntime.ts",
    "start": 187,
    "end": 287,
    "language": "typescript",
    "label": "Environment-owned managed tunnel child supervision",
    "code": "  reconcileConfig = Effect.fn(\"CloudManagedEndpointRuntime.reconcileConfig\")(function* (config) {\n    if (!config || config.providerKind !== \"cloudflare_tunnel\") {\n      yield* stopActive;\n      return config\n        ? { status: \"unsupported\", providerKind: config.providerKind }\n        : { status: \"disabled\" };\n    }\n\n    const nextConfigKey = runtimeConfigKey(config);\n    const active = yield* Ref.get(activeRef);\n    if (active?.configKey === nextConfigKey) {\n      const isRunning = yield* active.child.isRunning.pipe(Effect.orElseSucceed(() => false));\n      if (isRunning) {\n        return {\n          status: \"running\",\n          providerKind: \"cloudflare_tunnel\",\n          pid: Number(active.child.pid),\n          ...(active.config.tunnelId ? { tunnelId: active.config.tunnelId } : {}),\n          ...(active.config.tunnelName ? { tunnelName: active.config.tunnelName } : {}),\n        } satisfies CloudManagedEndpointRuntimeStatus;\n      }\n    }\n\n    yield* stopActive;\n\n    const executable = yield* relayClient.resolve;\n    if (executable.status !== \"available\") {\n      return {\n        status: \"failed\",\n        providerKind: \"cloudflare_tunnel\",\n        reason:\n          executable.status === \"unsupported\"\n            ? `Relay client is unsupported on ${executable.platform}-${executable.arch}.`\n            : \"The relay client is not installed.\",\n        ...(config.tunnelId ? { tunnelId: config.tunnelId } : {}),\n        ...(config.tunnelName ? { tunnelName: config.tunnelName } : {}),\n      } satisfies CloudManagedEndpointRuntimeStatus;\n    }\n\n    const connectorScope = yield* Scope.make(\"sequential\");\n    const child = yield* spawner\n      .spawn(\n        ChildProcess.make(executable.executablePath, [\"tunnel\", \"run\"], {\n          detached: false,\n          env: {\n            ...process.env,\n            TUNNEL_TOKEN: config.connectorToken,\n          },\n          shell: false,\n          stderr: \"pipe\",\n          stdout: \"pipe\",\n        }),\n      )\n      .pipe(\n        Effect.provideService(Scope.Scope, connectorScope),\n        Effect.tap((child) =>\n          Effect.logInfo(\"Relay client process started; waiting for tunnel connection\", {\n            pid: Number(child.pid),\n            tunnelId: config.tunnelId,\n            tunnelName: config.tunnelName,\n          }),\n        ),\n        Effect.catch((cause) =>\n          Effect.logWarning(\"Failed to start relay client\", {\n            cause,\n            tunnelId: config.tunnelId,\n            tunnelName: config.tunnelName,\n          }).pipe(\n            Effect.andThen(Scope.close(connectorScope, Exit.void).pipe(Effect.ignore)),\n            Effect.as({\n              status: \"failed\",\n              providerKind: \"cloudflare_tunnel\",\n              reason: String(cause),\n              ...(config.tunnelId ? { tunnelId: config.tunnelId } : {}),\n              ...(config.tunnelName ? { tunnelName: config.tunnelName } : {}),\n            } satisfies CloudManagedEndpointRuntimeStatus),\n          ),\n        ),\n      );\n\n    if (\"status\" in child && child.status === \"failed\") {\n      return child;\n    }\n\n    if (!(\"status\" in child)) {\n      const connector = {\n        child,\n        scope: connectorScope,\n        configKey: nextConfigKey,\n        config,\n      } satisfies ActiveConnector;\n      yield* Ref.set(activeRef, connector);\n      yield* Effect.forkIn(observeConnectorOutput(connector), connectorScope);\n      yield* Effect.forkIn(superviseConnector(connector), connectorScope);\n      return {\n        status: \"running\",\n        providerKind: \"cloudflare_tunnel\",\n        pid: Number(child.pid),\n        ...(config.tunnelId ? { tunnelId: config.tunnelId } : {}),\n        ...(config.tunnelName ? { tunnelName: config.tunnelName } : {}),\n      } satisfies CloudManagedEndpointRuntimeStatus;",
    "checksum": "15a5736f8e3481d7117acb0331cf0d9969a2bf86bf2755734a1f3af6036df8b2"
  },
  "connect-relay-environment-mint": {
    "id": "connect-relay-environment-mint",
    "path": "infra/relay/src/environments/EnvironmentConnector.ts",
    "start": 541,
    "end": 670,
    "language": "typescript",
    "label": "Proof-key-bound relay mint request and environment bootstrap credential",
    "code": "    connect: Effect.fn(\"relay.environment_connector.connect\")(function* (input) {\n      yield* Effect.annotateCurrentSpan({\n        \"relay.environment_id\": input.environmentId,\n        \"relay.operation\": \"connect\",\n        \"relay.connect.has_device_id\": input.deviceId !== undefined,\n        ...(input.deviceId ? { \"relay.mobile.device_id\": input.deviceId } : {}),\n      });\n      if (input.clientProofKeyThumbprint.trim().length === 0) {\n        return yield* new EnvironmentConnectNotAuthorized({\n          environmentId: input.environmentId,\n          operation: \"connect\",\n          reason: \"client_proof_key_thumbprint_missing\",\n        });\n      }\n      const { link, allocation } = yield* Effect.all(\n        {\n          link: links.getForUser(input),\n          allocation: allocations.get(input),\n        },\n        { concurrency: 2 },\n      );\n      if (!link) {\n        return yield* new EnvironmentConnectNotAuthorized({\n          environmentId: input.environmentId,\n          operation: \"connect\",\n          reason: \"environment_link_not_found\",\n        });\n      }\n      const endpoint = yield* resolveManagedEndpoint({\n        operation: \"connect\",\n        link,\n        allocation,\n      });\n      const now = yield* DateTime.now;\n      const expiresAt = DateTime.add(now, { minutes: 2 });\n      const nonce = yield* crypto.randomUUIDv4.pipe(\n        Effect.mapError(\n          (cause) =>\n            new EnvironmentMintRequestFailed({\n              environmentId: input.environmentId,\n              operation: \"connect\",\n              cause,\n            }),\n        ),\n      );\n      const payload = {\n        iss: relayIssuer,\n        aud: `t3-env:${link.environmentId}`,\n        sub: input.userId,\n        jti: yield* crypto.randomUUIDv4.pipe(\n          Effect.mapError(\n            (cause) =>\n              new EnvironmentMintRequestFailed({\n                environmentId: input.environmentId,\n                operation: \"connect\",\n                cause,\n              }),\n          ),\n        ),\n        iat: Math.floor(now.epochMilliseconds / 1_000),\n        exp: Math.floor(expiresAt.epochMilliseconds / 1_000),\n        environmentId: link.environmentId,\n        clientProofKeyThumbprint: input.clientProofKeyThumbprint,\n        cnf: { jkt: input.clientProofKeyThumbprint },\n        ...(input.deviceId ? { deviceId: input.deviceId } : {}),\n        nonce,\n        scope: [\"environment:connect\"],\n      } satisfies RelayCloudMintCredentialProofPayload;\n      const proof = yield* signRelayJwt({\n        privateKey: Redacted.value(settings.cloudMintPrivateKey),\n        typ: RELAY_MINT_REQUEST_TYP,\n        payload,\n      }).pipe(\n        Effect.mapError(\n          (cause) =>\n            new EnvironmentMintRequestFailed({\n              environmentId: input.environmentId,\n              operation: \"connect\",\n              cause,\n            }),\n        ),\n      );\n      const environmentClient = yield* makeEnvironmentClient(endpoint.httpBaseUrl);\n      const decoded = yield* environmentClient.connect\n        .t3MintCredential({ payload: { proof } })\n        .pipe(\n          withoutRedirects,\n          Effect.mapError(\n            (cause) =>\n              new EnvironmentMintRequestFailed({\n                environmentId: input.environmentId,\n                operation: \"connect\",\n                cause,\n              }),\n          ),\n          Effect.timeoutOption(Duration.millis(ENVIRONMENT_MINT_REQUEST_TIMEOUT_MS)),\n          Effect.flatMap(\n            Option.match({\n              onNone: () =>\n                Effect.fail(\n                  new EnvironmentMintRequestTimedOut({\n                    environmentId: input.environmentId,\n                    timeoutMs: ENVIRONMENT_MINT_REQUEST_TIMEOUT_MS,\n                  }),\n                ),\n              onSome: Effect.succeed,\n            }),\n          ),\n        );\n      const verified = yield* verifyEnvironmentResponse({\n        response: decoded,\n        environmentId: input.environmentId,\n        requestNonce: nonce,\n        clientProofKeyThumbprint: input.clientProofKeyThumbprint,\n        environmentPublicKeys: [link.environmentPublicKey],\n        relayIssuer,\n        nowEpochSeconds: Math.floor(now.epochMilliseconds / 1_000),\n      });\n      if (!verified) {\n        return yield* new EnvironmentMintResponseInvalid({\n          environmentId: input.environmentId,\n          operation: \"connect\",\n        });\n      }\n      return {\n        environmentId: link.environmentId,\n        endpoint,\n        credential: decoded.credential,\n        expiresAt: decoded.expiresAt,\n      };",
    "checksum": "87e768757d71f7890b3a25324faae60572ccb16545a28d7fe42df583c9eebd6b"
  },
  "dpop-validation": {
    "id": "dpop-validation",
    "path": "packages/shared/src/dpop.ts",
    "start": 1,
    "end": 175,
    "language": "typescript",
    "label": "DPoP signature, target, token hash, and time validation",
    "code": "import { p256 } from \"@noble/curves/nist\";\nimport { sha256 } from \"@noble/hashes/sha2\";\nimport * as Encoding from \"effect/Encoding\";\nimport * as Option from \"effect/Option\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\n\nimport { DpopPublicJwk as DpopPublicJwkSchema, normalizeDpopHtu } from \"./dpopCommon.ts\";\nimport type { DpopPublicJwk as DpopPublicJwkType } from \"./dpopCommon.ts\";\nimport { stableStringify } from \"./relaySigning.ts\";\n\nconst DPOP_TYP = \"dpop+jwt\";\nconst DPOP_ALG = \"ES256\";\nconst DEFAULT_MAX_AGE_SECONDS = 300;\n\nexport const DpopPublicJwk = DpopPublicJwkSchema;\nexport type DpopPublicJwk = DpopPublicJwkType;\nexport { normalizeDpopHtu };\n\nconst DpopJwtHeaderPublicJwk = Schema.Struct({\n  ...DpopPublicJwkSchema.fields,\n  d: Schema.optionalKey(Schema.Never),\n});\n\nconst DpopJwtHeaderJson = Schema.fromJsonString(\n  Schema.Struct({\n    typ: Schema.Literal(DPOP_TYP),\n    alg: Schema.Literal(DPOP_ALG),\n    jwk: DpopJwtHeaderPublicJwk,\n  }),\n);\nconst decodeDpopJwtHeaderJson = Schema.decodeUnknownOption(DpopJwtHeaderJson);\n\nconst DpopJwtPayloadJson = Schema.fromJsonString(\n  Schema.Struct({\n    htm: Schema.String.check(Schema.isNonEmpty()),\n    htu: Schema.String.check(Schema.isNonEmpty()),\n    jti: Schema.String.check(Schema.isNonEmpty()),\n    iat: Schema.Int,\n    ath: Schema.optionalKey(Schema.String),\n  }),\n);\nconst decodeDpopJwtPayloadJson = Schema.decodeUnknownOption(DpopJwtPayloadJson);\n\nexport type DpopVerificationResult =\n  | {\n      readonly ok: true;\n      readonly thumbprint: string;\n      readonly jti: string;\n      readonly iat: number;\n    }\n  | {\n      readonly ok: false;\n      readonly reason: string;\n    };\n\nfunction base64UrlToBytes(value: string): Uint8Array {\n  return Result.getOrThrow(Encoding.decodeBase64Url(value));\n}\n\nfunction decodeBase64UrlDpopJwtHeader(value: string) {\n  return decodeDpopJwtHeaderJson(Result.getOrThrow(Encoding.decodeBase64UrlString(value)));\n}\n\nfunction decodeBase64UrlDpopJwtPayload(value: string) {\n  return decodeDpopJwtPayloadJson(Result.getOrThrow(Encoding.decodeBase64UrlString(value)));\n}\n\nfunction dpopThumbprintInput(jwk: DpopPublicJwkType): string {\n  return stableStringify({\n    crv: jwk.crv,\n    kty: jwk.kty,\n    x: jwk.x,\n    y: jwk.y,\n  });\n}\n\nexport function computeDpopJwkThumbprint(jwk: DpopPublicJwkType): string {\n  return Encoding.encodeBase64Url(sha256(new TextEncoder().encode(dpopThumbprintInput(jwk))));\n}\n\nexport function computeDpopAccessTokenHash(accessToken: string): string {\n  return Encoding.encodeBase64Url(sha256(new TextEncoder().encode(accessToken)));\n}\n\nfunction publicKeyBytesFromJwk(jwk: DpopPublicJwkType): Uint8Array {\n  const x = base64UrlToBytes(jwk.x);\n  const y = base64UrlToBytes(jwk.y);\n  if (x.length !== 32 || y.length !== 32) {\n    throw new Error(\"Invalid P-256 public key coordinate length.\");\n  }\n  const publicKey = new Uint8Array(65);\n  publicKey[0] = 0x04;\n  publicKey.set(x, 1);\n  publicKey.set(y, 33);\n  return publicKey;\n}\n\nexport function verifyDpopProof(input: {\n  readonly proof: string | null | undefined;\n  readonly method: string;\n  readonly url: string;\n  readonly nowEpochSeconds: number;\n  readonly expectedThumbprint?: string;\n  readonly expectedAccessToken?: string;\n  readonly maxAgeSeconds?: number;\n}): DpopVerificationResult {\n  if (!input.proof?.trim()) {\n    return { ok: false, reason: \"Missing DPoP proof.\" };\n  }\n\n  const parts = input.proof.split(\".\");\n  if (parts.length !== 3 || !parts[0] || !parts[1] || !parts[2]) {\n    return { ok: false, reason: \"Invalid DPoP compact JWT.\" };\n  }\n\n  try {\n    const header = decodeBase64UrlDpopJwtHeader(parts[0]);\n    const payload = decodeBase64UrlDpopJwtPayload(parts[1]);\n    if (Option.isNone(header)) {\n      return { ok: false, reason: \"Invalid DPoP JWT header.\" };\n    }\n    if (Option.isNone(payload)) {\n      return { ok: false, reason: \"Invalid DPoP JWT payload.\" };\n    }\n\n    const thumbprint = computeDpopJwkThumbprint(header.value.jwk);\n    if (input.expectedThumbprint && thumbprint !== input.expectedThumbprint) {\n      return { ok: false, reason: \"DPoP key thumbprint mismatch.\" };\n    }\n    if (payload.value.htm.toUpperCase() !== input.method.toUpperCase()) {\n      return { ok: false, reason: \"DPoP method mismatch.\" };\n    }\n    const normalizedHtu = normalizeDpopHtu(input.url);\n    if (normalizedHtu === null || payload.value.htu !== normalizedHtu) {\n      return { ok: false, reason: \"DPoP URL mismatch.\" };\n    }\n    if (input.expectedAccessToken) {\n      const expectedAth = computeDpopAccessTokenHash(input.expectedAccessToken);\n      if (payload.value.ath !== expectedAth) {\n        return { ok: false, reason: \"DPoP access token hash mismatch.\" };\n      }\n    }\n\n    const maxAgeSeconds = input.maxAgeSeconds ?? DEFAULT_MAX_AGE_SECONDS;\n    if (\n      payload.value.iat > input.nowEpochSeconds + 5 ||\n      input.nowEpochSeconds - payload.value.iat > maxAgeSeconds\n    ) {\n      return { ok: false, reason: \"DPoP proof is outside the allowed time window.\" };\n    }\n\n    const signature = base64UrlToBytes(parts[2]);\n    const signatureInputHash = sha256(new TextEncoder().encode(`${parts[0]}.${parts[1]}`));\n    const verified = p256.verify(\n      signature,\n      signatureInputHash,\n      publicKeyBytesFromJwk(header.value.jwk),\n      {\n        prehash: false,\n        format: \"compact\",\n      },\n    );\n    return verified\n      ? {\n          ok: true,\n          thumbprint,\n          jti: payload.value.jti,\n          iat: payload.value.iat,\n        }\n      : { ok: false, reason: \"Invalid DPoP signature.\" };\n  } catch {\n    return { ok: false, reason: \"Invalid DPoP proof.\" };\n  }\n}",
    "checksum": "a201cbe8739a6da8f782df3f52c70e27b8ff61b5dcdf9de50075955966c8bf43"
  },
  "managed-relay-dpop-authorization": {
    "id": "managed-relay-dpop-authorization",
    "path": "packages/client-runtime/src/authorization/service.ts",
    "start": 180,
    "end": 299,
    "language": "typescript",
    "label": "Managed relay bootstrap becomes a distinct DPoP-bound environment session",
    "code": "  const authorizeDpop = Effect.fn(\"clientRuntime.connection.remote.authorizeDpop\")(\n    function* (input: {\n      readonly expectedEnvironmentId: Parameters<\n        RemoteEnvironmentAuthorization[\"Service\"][\"authorizeDpop\"]\n      >[0][\"expectedEnvironmentId\"];\n      readonly obtainBootstrap: Parameters<\n        RemoteEnvironmentAuthorization[\"Service\"][\"authorizeDpop\"]\n      >[0][\"obtainBootstrap\"];\n    }) {\n      const thumbprint = yield* signer.thumbprint.pipe(\n        Effect.mapError(\n          () =>\n            new ConnectionBlockedError({\n              reason: \"configuration\",\n              detail: \"Could not load the environment authorization key.\",\n            }),\n        ),\n        Effect.withSpan(\"environment.authorization.dpopKey.resolve\"),\n      );\n      const now = yield* Clock.currentTimeMillis;\n      const cached = yield* tokenStore\n        .get(input.expectedEnvironmentId)\n        .pipe(Effect.withSpan(\"environment.authorization.accessToken.cache\"));\n      if (\n        Option.isSome(cached) &&\n        cached.value.environmentId === input.expectedEnvironmentId &&\n        cached.value.dpopThumbprint === thumbprint &&\n        cached.value.expiresAtEpochMs > now + TOKEN_EXPIRY_SAFETY_MARGIN_MS\n      ) {\n        yield* Effect.annotateCurrentSpan({\n          \"connection.remote_token_cache\": \"hit\",\n        });\n        const cachedSocket = yield* createDpopSocketUrl(\n          cached.value,\n          CACHED_ENDPOINT_SOCKET_TIMEOUT_MS,\n        ).pipe(Effect.result);\n        if (Result.isSuccess(cachedSocket)) {\n          return {\n            environmentId: cached.value.environmentId,\n            label: cached.value.label,\n            httpBaseUrl: cached.value.endpoint.httpBaseUrl,\n            socketUrl: cachedSocket.success,\n            httpAuthorization: {\n              _tag: \"Dpop\" as const,\n              accessToken: cached.value.accessToken,\n            },\n          };\n        }\n        if (cachedSocket.failure._tag === \"ConnectionBlockedError\") {\n          return yield* mapDpopSocketError(cachedSocket.failure);\n        }\n        yield* tokenStore\n          .remove(input.expectedEnvironmentId)\n          .pipe(Effect.withSpan(\"environment.authorization.accessToken.remove\"));\n      }\n\n      yield* Effect.annotateCurrentSpan({\n        \"connection.remote_token_cache\": \"miss\",\n      });\n      const bootstrap = yield* input.obtainBootstrap;\n      const descriptor = yield* fetchDescriptor(bootstrap.endpoint.httpBaseUrl).pipe(\n        Effect.provideService(HttpClient.HttpClient, httpClient),\n        Effect.withSpan(\"environment.authorization.descriptor\"),\n      );\n      if (descriptor.environmentId !== input.expectedEnvironmentId) {\n        return yield* environmentMismatchError({\n          expected: input.expectedEnvironmentId,\n          actual: descriptor.environmentId,\n        });\n      }\n      const bootstrapProof = yield* signer\n        .createProof({\n          method: \"POST\",\n          url: environmentEndpointUrl(bootstrap.endpoint.httpBaseUrl, \"/oauth/token\"),\n        })\n        .pipe(\n          Effect.mapError(\n            () =>\n              new ConnectionBlockedError({\n                reason: \"configuration\",\n                detail: \"Could not create the environment authorization proof.\",\n              }),\n          ),\n        );\n      const access = yield* exchangeRemoteDpopAccessToken({\n        httpBaseUrl: bootstrap.endpoint.httpBaseUrl,\n        credential: bootstrap.credential,\n        dpopProof: bootstrapProof,\n        scopes: presentation.scopes,\n        clientMetadata: presentation.metadata,\n      }).pipe(\n        Effect.mapError(mapRemoteEnvironmentError),\n        Effect.provideService(HttpClient.HttpClient, httpClient),\n        Effect.withSpan(\"environment.authorization.accessToken.exchange\"),\n      );\n      const issuedAt = yield* Clock.currentTimeMillis;\n      const token = new TokenStore.RemoteDpopAccessToken({\n        environmentId: descriptor.environmentId,\n        label: descriptor.label,\n        endpoint: bootstrap.endpoint,\n        accessToken: access.access_token,\n        expiresAtEpochMs: issuedAt + access.expires_in * 1_000,\n        dpopThumbprint: thumbprint,\n      });\n      const socketUrl = yield* createDpopSocketUrl(token).pipe(Effect.mapError(mapDpopSocketError));\n      yield* tokenStore\n        .put(token)\n        .pipe(Effect.withSpan(\"environment.authorization.accessToken.persist\"));\n      return {\n        environmentId: descriptor.environmentId,\n        label: descriptor.label,\n        httpBaseUrl: bootstrap.endpoint.httpBaseUrl,\n        socketUrl,\n        httpAuthorization: {\n          _tag: \"Dpop\" as const,\n          accessToken: token.accessToken,\n        },\n      };\n    },\n  );",
    "checksum": "6815918aa0e64771f373da90aa947033e4b180c8a4d9c6308afdacebd6880dbb"
  },
  "reconnect-environment-registry": {
    "id": "reconnect-environment-registry",
    "path": "packages/client-runtime/src/connection/registry.ts",
    "start": 156,
    "end": 289,
    "language": "typescript",
    "label": "Environment-scoped runtime registry and lease replacement",
    "code": "  const entries =\n    yield* SubscriptionRef.make<ReadonlyMap<EnvironmentId, ConnectionCatalogEntry>>(initialEntries);\n  const networkStatus = yield* SubscriptionRef.make(yield* connectivity.status);\n  const serviceScopes = yield* SubscriptionRef.make<\n    ReadonlyMap<EnvironmentId, EnvironmentServiceScope>\n  >(new Map());\n  const platformEnvironmentIds = yield* Ref.make<ReadonlySet<EnvironmentId>>(new Set());\n  const persistedTargetsByEnvironment = yield* Ref.make<\n    ReadonlyMap<EnvironmentId, ConnectionTarget>\n  >(new Map(persistedTargets.map((target) => [target.environmentId, target])));\n  interface LeaseLock {\n    readonly semaphore: Semaphore.Semaphore;\n    readonly users: number;\n  }\n\n  const leaseLocks = yield* Ref.make<ReadonlyMap<EnvironmentId, LeaseLock>>(new Map());\n  const leaseLocksGuard = yield* Semaphore.make(1);\n  const started = yield* Ref.make(false);\n\n  const withLeaseLock = <A, E, R>(\n    environmentId: EnvironmentId,\n    effect: Effect.Effect<A, E, R>,\n  ): Effect.Effect<A, E, R> =>\n    Effect.acquireUseRelease(\n      leaseLocksGuard.withPermits(1)(\n        Effect.gen(function* () {\n          const current = yield* Ref.get(leaseLocks);\n          const existing = current.get(environmentId);\n          if (existing !== undefined) {\n            yield* Ref.set(\n              leaseLocks,\n              new Map(current).set(environmentId, {\n                semaphore: existing.semaphore,\n                users: existing.users + 1,\n              }),\n            );\n            return existing.semaphore;\n          }\n          const semaphore = yield* Semaphore.make(1);\n          yield* Ref.set(leaseLocks, new Map(current).set(environmentId, { semaphore, users: 1 }));\n          return semaphore;\n        }),\n      ),\n      (semaphore) => semaphore.withPermits(1)(effect),\n      (semaphore) =>\n        leaseLocksGuard.withPermits(1)(\n          Ref.update(leaseLocks, (current) => {\n            const existing = current.get(environmentId);\n            if (existing === undefined || existing.semaphore !== semaphore) {\n              return current;\n            }\n            const next = new Map(current);\n            if (existing.users === 1) {\n              next.delete(environmentId);\n            } else {\n              next.set(environmentId, {\n                semaphore,\n                users: existing.users - 1,\n              });\n            }\n            return next;\n          }),\n        ),\n    ).pipe(Effect.withSpan(\"EnvironmentRegistry.withLeaseLock\"));\n\n  const getEntry = Effect.fn(\"EnvironmentRegistry.getEntry\")(function* (\n    environmentId: EnvironmentId,\n  ) {\n    const entry = (yield* SubscriptionRef.get(entries)).get(environmentId);\n    if (entry === undefined) {\n      return yield* new EnvironmentNotRegisteredError({\n        environmentId,\n      });\n    }\n    return entry;\n  });\n\n  const closeServiceScope = Effect.fn(\"EnvironmentRegistry.closeServiceScope\")(function* (\n    environmentId: EnvironmentId,\n  ) {\n    const current = yield* SubscriptionRef.get(serviceScopes);\n    const lease = current.get(environmentId);\n    if (lease === undefined) {\n      return;\n    }\n    const next = new Map(current);\n    next.delete(environmentId);\n    yield* SubscriptionRef.set(serviceScopes, next);\n    yield* Scope.close(lease.scope, Exit.void);\n  });\n\n  const createServiceScope = Effect.fn(\"EnvironmentRegistry.createServiceScope\")(\n    (entry: ConnectionCatalogEntry) =>\n      Effect.uninterruptible(\n        Effect.gen(function* () {\n          const environmentId = entry.target.environmentId;\n          const scope = yield* Scope.make();\n          const supervisor = yield* EnvironmentSupervisor.make(entry, {\n            initiallyDesired: false,\n          }).pipe(\n            Effect.provideService(Connectivity.Connectivity, connectivity),\n            Effect.provideService(ConnectionDriver.ConnectionDriver, driver),\n            Effect.provideService(ConnectionWakeups.ConnectionWakeups, wakeups),\n            Scope.provide(scope),\n            Effect.onError(() => Scope.close(scope, Exit.void)),\n          );\n          yield* supervisor.connect;\n          yield* SubscriptionRef.update(serviceScopes, (current) => {\n            const next = new Map(current);\n            next.set(environmentId, { entry, supervisor, scope });\n            return next;\n          });\n          return supervisor;\n        }),\n      ),\n  );\n\n  const acquireSupervisor = Effect.fn(\"EnvironmentRegistry.acquireSupervisor\")(function* (\n    environmentId: EnvironmentId,\n  ) {\n    return yield* withLeaseLock(\n      environmentId,\n      Effect.gen(function* () {\n        const entry = yield* getEntry(environmentId);\n        const existing = (yield* SubscriptionRef.get(serviceScopes)).get(environmentId);\n        if (existing !== undefined) {\n          if (Equal.equals(existing.entry, entry)) {\n            return existing.supervisor;\n          }\n          yield* closeServiceScope(environmentId);\n        }\n        return yield* createServiceScope(entry);\n      }),\n    );",
    "checksum": "12b74a7bf02c25c818e09218075f7ada2c45fbc08ff74ec48531c05611264fd3"
  },
  "reconnect-scoped-environment-refs": {
    "id": "reconnect-scoped-environment-refs",
    "path": "packages/contracts/src/environment.ts",
    "start": 31,
    "end": 130,
    "language": "typescript",
    "label": "Environment descriptors and scoped project and thread references",
    "code": "/** How a server can replace itself with another version when asked over RPC.\n    New servers only advertise the stable launcher-backed \"boot-service\" path;\n    \"respawn\" remains decodable for compatibility with older servers. */\nexport const ServerSelfUpdateMethod = Schema.Literals([\"boot-service\", \"respawn\"]);\nexport type ServerSelfUpdateMethod = typeof ServerSelfUpdateMethod.Type;\n\n/** What update path a client should offer for a server: one of the RPC\n    self-update methods above, or \"desktop-managed\" when the backend's\n    version belongs to the T3 Code desktop app supervising it — updating the\n    app on that machine is the only way to update the server. */\nexport const ServerSelfUpdateCapability = Schema.Literals([\n  \"boot-service\",\n  \"respawn\",\n  \"desktop-managed\",\n]);\nexport type ServerSelfUpdateCapability = typeof ServerSelfUpdateCapability.Type;\n\nexport const ExecutionEnvironmentCapabilities = Schema.Struct({\n  repositoryIdentity: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),\n  connectionProbe: Schema.optionalKey(Schema.Boolean),\n  /** Server exposes the pull-request list, detail, activity, diff, and mutation APIs. Absent on\n      servers from before the pull-request workspace shipped, so clients must not probe them. */\n  pullRequests: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.settle / thread.unsettle commands. Absent on\n      pre-settlement servers, so clients treat missing as unsupported and\n      never send the commands under version skew. */\n  threadSettlement: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.snooze / thread.unsnooze commands. Same\n      version-skew contract as threadSettlement. */\n  threadSnooze: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.pin / thread.unpin commands. Same\n      version-skew contract as threadSettlement. */\n  threadPinning: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.pin.reorder (and orderKey on thread.pin).\n      Same version-skew contract as threadSettlement. */\n  threadPinReorder: Schema.optionalKey(Schema.Boolean),\n  /** Server understands regenerateTitle on thread.meta.update. Absent on\n      older servers, so clients hide the action instead of sending it. */\n  threadTitleRegeneration: Schema.optionalKey(Schema.Boolean),\n  /** The update path clients should offer for this server. Absent on\n      servers that must be relaunched manually (dev checkouts, Windows\n      foreground runs, pre-update servers). */\n  serverSelfUpdate: Schema.optionalKey(ServerSelfUpdateCapability),\n  /** Server can stream self-update progress before acknowledging the\n      restart. Clients fall back to server.updateServer when absent. */\n  serverSelfUpdateProgress: Schema.optionalKey(Schema.Boolean),\n  /** Agent-activity publishes (push notifications and Live Activities)\n      currently leave this environment: the publish opt-in is enabled and the\n      relay link credentials exist. Clients skip seeding a Live Activity when\n      this is false — no update would ever repaint it. Absent on older\n      servers, which may still publish, so only an explicit false skips. */\n  agentActivityPublishing: Schema.optionalKey(Schema.Boolean),\n});\nexport type ExecutionEnvironmentCapabilities = typeof ExecutionEnvironmentCapabilities.Type;\n\nexport const ExecutionEnvironmentDescriptor = Schema.Struct({\n  environmentId: EnvironmentId,\n  label: TrimmedNonEmptyString,\n  platform: ExecutionEnvironmentPlatform,\n  serverVersion: TrimmedNonEmptyString,\n  capabilities: ExecutionEnvironmentCapabilities,\n});\nexport type ExecutionEnvironmentDescriptor = typeof ExecutionEnvironmentDescriptor.Type;\n\nexport const EnvironmentConnectionState = Schema.Literals([\n  \"connecting\",\n  \"connected\",\n  \"disconnected\",\n  \"error\",\n]);\nexport type EnvironmentConnectionState = typeof EnvironmentConnectionState.Type;\n\nexport const RepositoryIdentityLocator = Schema.Struct({\n  source: Schema.Literal(\"git-remote\"),\n  remoteName: TrimmedNonEmptyString,\n  remoteUrl: TrimmedNonEmptyString,\n});\nexport type RepositoryIdentityLocator = typeof RepositoryIdentityLocator.Type;\n\nexport const RepositoryIdentity = Schema.Struct({\n  canonicalKey: TrimmedNonEmptyString,\n  locator: RepositoryIdentityLocator,\n  rootPath: Schema.optionalKey(TrimmedNonEmptyString),\n  displayName: Schema.optionalKey(TrimmedNonEmptyString),\n  provider: Schema.optionalKey(TrimmedNonEmptyString),\n  owner: Schema.optionalKey(TrimmedNonEmptyString),\n  name: Schema.optionalKey(TrimmedNonEmptyString),\n});\nexport type RepositoryIdentity = typeof RepositoryIdentity.Type;\n\nexport const ScopedProjectRef = Schema.Struct({\n  environmentId: EnvironmentId,\n  projectId: ProjectId,\n});\nexport type ScopedProjectRef = typeof ScopedProjectRef.Type;\n\nexport const ScopedThreadRef = Schema.Struct({\n  environmentId: EnvironmentId,\n  threadId: ThreadId,\n});",
    "checksum": "8adc3eeb2048647115e388b4fc57aea27ff94e4eeb613ad4a0bd5727d0c63d7e"
  },
  "reconnect-supervisor-active-lease": {
    "id": "reconnect-supervisor-active-lease",
    "path": "packages/client-runtime/src/connection/supervisor.ts",
    "start": 490,
    "end": 615,
    "language": "typescript",
    "label": "Active prepared connection and RPC session lease lifecycle",
    "code": "  const runAttempt = Effect.fnUntraced(function* (\n    attempt: number,\n    generation: number,\n    lastFailure: ConnectionAttemptError | null,\n    pendingRetry: Option.Option<PendingRetryTrace>,\n  ) {\n    yield* SubscriptionRef.set(prepared, Option.none());\n    const establishment = yield* Effect.raceAllFirst([\n      exitUnlessInterrupted(\n        establishTracedConnection(attempt, generation, lastFailure, pendingRetry),\n      ).pipe(\n        Effect.map(\n          (exit): EstablishmentEvent => ({\n            _tag: \"Completed\",\n            exit,\n          }),\n        ),\n      ),\n      waitForEstablishmentInterrupt().pipe(\n        Effect.map(\n          (resetRetry): EstablishmentEvent => ({\n            _tag: \"Interrupted\",\n            resetRetry,\n          }),\n        ),\n      ),\n      Effect.sleep(CONNECTION_ESTABLISHMENT_TIMEOUT).pipe(\n        Effect.as<EstablishmentEvent>({ _tag: \"TimedOut\" }),\n      ),\n    ]);\n\n    if (establishment._tag === \"Interrupted\") {\n      return {\n        _tag: \"Interrupted\",\n        established: false,\n        stable: false,\n        resetRetry: establishment.resetRetry,\n      } satisfies AttemptOutcome;\n    }\n    if (establishment._tag === \"TimedOut\") {\n      return {\n        _tag: \"Failure\",\n        established: false,\n        stable: false,\n        failure: {\n          error: new ConnectionTransientError({\n            reason: \"timeout\",\n            detail: `${target.label} did not respond during connection setup.`,\n          }),\n          attemptSpan: Option.none(),\n        },\n      } satisfies AttemptOutcome;\n    }\n    if (Exit.isFailure(establishment.exit)) {\n      const isUnexpectedDefect =\n        !Cause.hasInterruptsOnly(establishment.exit.cause) &&\n        !establishment.exit.cause.reasons.some(Cause.isFailReason);\n      const outcome = failureFromExit(target, establishment.exit, false, false);\n      if (isUnexpectedDefect) {\n        const defect = establishment.exit.cause.reasons.find(Cause.isDieReason)?.defect;\n        yield* Effect.logError(\"Connection attempt failed with an unexpected defect.\").pipe(\n          Effect.annotateLogs({\n            \"environment.id\": target.environmentId,\n            \"environment.label\": target.label,\n            \"cause.reason_count\": establishment.exit.cause.reasons.length,\n            ...safeErrorLogAttributes(defect),\n          }),\n        );\n      }\n      return outcome;\n    }\n\n    const active = establishment.exit.value;\n    const currentIntent = yield* Ref.get(intent);\n    if (!currentIntent.desired || currentIntent.network === \"offline\") {\n      return {\n        _tag: \"Interrupted\",\n        established: false,\n        stable: false,\n        resetRetry: false,\n      } satisfies AttemptOutcome;\n    }\n\n    const connectedAt = yield* Clock.currentTimeMillis;\n    yield* SubscriptionRef.set(prepared, Option.some(active.lease.prepared));\n    yield* SubscriptionRef.set(session, Option.some(active.lease.session));\n    yield* setState({\n      desired: true,\n      network: currentIntent.network,\n      phase: \"connected\",\n      stage: null,\n      attempt,\n      generation,\n      lastFailure: null,\n      retryAt: null,\n    });\n\n    const connectedExit = yield* Effect.raceFirst(\n      active.lease.session.closed.pipe(\n        Effect.mapError(\n          (error): TracedAttemptFailure => ({\n            error,\n            attemptSpan: active.attemptSpan,\n          }),\n        ),\n      ),\n      monitorConnectedLease(active.lease).pipe(\n        Effect.mapError(\n          (error): TracedAttemptFailure => ({\n            error,\n            attemptSpan: active.attemptSpan,\n          }),\n        ),\n      ),\n    ).pipe(exitUnlessInterrupted);\n    const connectedForMs = (yield* Clock.currentTimeMillis) - connectedAt;\n    if (Exit.isSuccess(connectedExit)) {\n      return {\n        _tag: \"Interrupted\",\n        established: true,\n        stable: connectedForMs >= BACKOFF_RESET_AFTER_MS,\n        resetRetry: connectedExit.value,\n      } satisfies AttemptOutcome;\n    }\n    return failureFromExit(target, connectedExit, true, connectedForMs >= BACKOFF_RESET_AFTER_MS);\n  }, Effect.ensuring(clearLease));",
    "checksum": "8c24ef212e1baf658eabc67c2a00996ebc7dae1354bb2d441368ff58e4b90f15"
  },
  "reconnect-supervisor-generation-loop": {
    "id": "reconnect-supervisor-generation-loop",
    "path": "packages/client-runtime/src/connection/supervisor.ts",
    "start": 643,
    "end": 755,
    "language": "typescript",
    "label": "Environment supervisor generation, offline, retry, and backoff loop",
    "code": "  const run = Effect.fnUntraced(function* () {\n    let failureCount = 0;\n    let generation = 0;\n    let latestFailure: ConnectionAttemptError | null = null;\n    let pendingRetry = Option.none<PendingRetryTrace>();\n    const resetRetryLadder = () => {\n      failureCount = 0;\n      pendingRetry = Option.none();\n    };\n\n    for (;;) {\n      if (yield* Ref.getAndSet(resetRetryState, false)) {\n        failureCount = 0;\n        latestFailure = null;\n        pendingRetry = Option.none();\n      }\n      const currentIntent = yield* Ref.get(intent);\n      if (!currentIntent.desired) {\n        resetRetryLadder();\n        latestFailure = null;\n        yield* clearLease;\n        yield* setState(availableState(currentIntent, generation));\n        yield* waitForSignal;\n        continue;\n      }\n      if (currentIntent.network === \"offline\") {\n        yield* clearLease;\n        yield* setState(offlineState(currentIntent, generation, failureCount + 1, latestFailure));\n        const applicationActivated = yield* waitForSignal;\n        if (applicationActivated) {\n          resetRetryLadder();\n        }\n        continue;\n      }\n\n      const attempt = failureCount + 1;\n      const nextGeneration = generation + 1;\n      const outcome: AttemptOutcome = yield* Effect.scoped(\n        runAttempt(attempt, nextGeneration, latestFailure, pendingRetry),\n      );\n      // Consumed on every iteration so a stale marker can never leak into a\n      // later, unrelated failure.\n      const failedWakeProbe = yield* Ref.getAndSet(wakeProbeFailed, false);\n      if (outcome.established) {\n        generation = nextGeneration;\n        if (outcome.stable) {\n          resetRetryLadder();\n          latestFailure = null;\n        }\n      }\n      if (outcome._tag === \"Interrupted\") {\n        if (outcome.resetRetry) {\n          resetRetryLadder();\n        }\n        continue;\n      }\n\n      const attemptSpan: Option.Option<Tracer.Span> = outcome.failure.attemptSpan;\n      const error: ConnectionAttemptError = outcome.failure.error;\n      latestFailure = error;\n      if (error._tag === \"ConnectionBlockedError\") {\n        const blockedIntent = yield* Ref.get(intent);\n        yield* setState({\n          desired: blockedIntent.desired,\n          network: blockedIntent.network,\n          phase: \"blocked\",\n          stage: null,\n          attempt,\n          generation,\n          lastFailure: error,\n          retryAt: null,\n        });\n        const applicationActivated = yield* waitForSignal;\n        if (applicationActivated) {\n          resetRetryLadder();\n        }\n        continue;\n      }\n\n      if (failedWakeProbe) {\n        // The wake probe found a dead transport while the user is returning to\n        // the app, so reconnect immediately instead of sleeping the first\n        // backoff rung. Only this first attempt skips the ladder; if it fails\n        // too, normal backoff resumes.\n        resetRetryLadder();\n        yield* setState(connectingState(yield* Ref.get(intent), generation, 1, error));\n        continue;\n      }\n\n      failureCount += 1;\n      const delayMs = retryDelayMs(failureCount - 1);\n      pendingRetry = Option.map(attemptSpan, (previousAttempt) => ({\n        previousAttempt,\n        failureCount,\n        delayMs,\n        reason: error.reason,\n      }));\n      const failedIntent = yield* Ref.get(intent);\n      yield* setState({\n        desired: failedIntent.desired,\n        network: failedIntent.network,\n        phase: \"backoff\",\n        stage: null,\n        attempt,\n        generation,\n        lastFailure: error,\n        retryAt: (yield* Clock.currentTimeMillis) + delayMs,\n      });\n      const applicationActivated = yield* waitForRetrySignal(delayMs);\n      if (applicationActivated) {\n        resetRetryLadder();\n      }\n    }",
    "checksum": "c05d5d84a1e4a46eb365fbb096528c45b5defa3f110b2d0e7c7a56f19d0e21e5"
  },
  "reconnect-shell-authoritative-refresh": {
    "id": "reconnect-shell-authoritative-refresh",
    "path": "packages/client-runtime/src/state/shell.ts",
    "start": 138,
    "end": 254,
    "language": "typescript",
    "label": "Shell cache, authoritative refresh, cursor, and synchronization boundary",
    "code": "  const applyItem = Effect.fn(\"EnvironmentShellState.applyItem\")(function* (\n    item: OrchestrationShellStreamItem,\n  ) {\n    if (item.kind === \"synchronized\") {\n      yield* Ref.set(awaitingCompletion, false);\n      yield* SubscriptionRef.update(state, (current) =>\n        Option.isSome(current.snapshot)\n          ? { ...current, status: \"live\" as const, error: Option.none() }\n          : current,\n      );\n      return;\n    }\n\n    const current = yield* SubscriptionRef.get(state);\n    const nextSnapshot =\n      item.kind === \"snapshot\"\n        ? item.snapshot\n        : Option.match(current.snapshot, {\n            onNone: () => null,\n            onSome: (snapshot) =>\n              item.sequence > snapshot.snapshotSequence\n                ? applyShellStreamEvent(snapshot, item)\n                : snapshot,\n          });\n    if (nextSnapshot === null) {\n      return;\n    }\n\n    const waiting = yield* Ref.get(awaitingCompletion);\n    yield* SubscriptionRef.set(state, {\n      snapshot: Option.some(nextSnapshot),\n      status: waiting ? \"synchronizing\" : \"live\",\n      error: Option.none(),\n    });\n    if (item.kind === \"snapshot\") {\n      const session = yield* Ref.get(activeSubscriptionSession);\n      if (session !== null) {\n        yield* Ref.set(lastAuthoritativeSession, session);\n      }\n    }\n    yield* Queue.offer(persistence, nextSnapshot);\n  });\n\n  const foregroundResubscriptions = Option.match(wakeups, {\n    onNone: () => Stream.never,\n    onSome: (service) =>\n      service.changes.pipe(Stream.filter(ConnectionWakeups.shouldResubscribeAfterWakeup)),\n  });\n\n  yield* setSynchronizing;\n  yield* Effect.forkScoped(\n    subscribeDynamic(\n      ORCHESTRATION_WS_METHODS.subscribeShell,\n      Effect.fn(\"EnvironmentShellState.makeSubscribeInput\")(function* (session) {\n        yield* Ref.set(activeSubscriptionSession, session);\n        const supportsCompletionMarker = yield* session.initialConfig.pipe(\n          Effect.map((config) => config.shellResumeCompletionMarker === true),\n          Effect.orElseSucceed(() => false),\n        );\n        yield* Ref.set(awaitingCompletion, supportsCompletionMarker);\n        yield* setSynchronizing;\n\n        // Foreground resubscriptions on the same live session can resume from\n        // the in-memory cursor. A new session reloads the authoritative HTTP\n        // snapshot so a valid cursor cannot preserve incomplete cached data.\n        const hasAuthoritativeSnapshot = (yield* Ref.get(lastAuthoritativeSession)) === session;\n        let canResume = hasAuthoritativeSnapshot;\n        let current = yield* SubscriptionRef.get(state);\n        if (!hasAuthoritativeSnapshot || Option.isNone(current.snapshot)) {\n          const prepared = yield* SubscriptionRef.get(supervisor.prepared).pipe(\n            Effect.flatMap(\n              Option.match({\n                onSome: Effect.succeed,\n                onNone: () =>\n                  SubscriptionRef.changes(supervisor.prepared).pipe(\n                    Stream.filter(Option.isSome),\n                    Stream.map((value) => value.value),\n                    Stream.runHead,\n                    Effect.map(Option.getOrThrow),\n                  ),\n              }),\n            ),\n          );\n          const httpSnapshot = yield* snapshotLoader.load(prepared);\n          if (Option.isSome(httpSnapshot)) {\n            yield* applyItem({ kind: \"snapshot\", snapshot: httpSnapshot.value });\n            canResume = true;\n            current = yield* SubscriptionRef.get(state);\n          }\n        }\n\n        // If the authoritative refresh failed, omit the cached cursor so the\n        // socket fallback sends a complete snapshot for this new session.\n        if (!canResume || Option.isNone(current.snapshot)) {\n          return supportsCompletionMarker ? { requestCompletionMarker: true as const } : {};\n        }\n        if (!supportsCompletionMarker) {\n          // Without a completion marker there is no synchronized signal for a\n          // resumed subscription, so report live immediately, like threads.\n          yield* SubscriptionRef.update(state, (value) => ({\n            ...value,\n            status: \"live\" as const,\n            error: Option.none(),\n          }));\n        }\n        return {\n          afterSequence: current.snapshot.value.snapshotSequence,\n          ...(supportsCompletionMarker ? { requestCompletionMarker: true as const } : {}),\n        };\n      }),\n      {\n        onExpectedFailure: (cause) => setStreamError(Cause.squash(cause)),\n        retryExpectedFailureAfter: \"250 millis\",\n        resubscribe: foregroundResubscriptions,\n      },\n    ).pipe(Stream.runForEach(applyItem)),\n  );",
    "checksum": "1d9311e98f9edc09e36d4c35e425a45c477d9c51739b382efed42b285d41f19d"
  },
  "reconnect-thread-snapshot-epoch": {
    "id": "reconnect-thread-snapshot-epoch",
    "path": "packages/client-runtime/src/state/threads.ts",
    "start": 212,
    "end": 338,
    "language": "typescript",
    "label": "Thread snapshot replacement and stale history epoch guard",
    "code": "  const setSynchronizing = SubscriptionRef.update(state, (current) =>\n    current.status === \"deleted\"\n      ? current\n      : {\n          ...current,\n          status: \"synchronizing\" as const,\n          error: Option.none(),\n        },\n  );\n  const setReady = SubscriptionRef.update(state, (current) =>\n    current.status === \"live\" || current.status === \"deleted\"\n      ? current\n      : {\n          ...current,\n          status: \"synchronizing\" as const,\n          error: Option.none(),\n        },\n  );\n  const setDisconnected = Effect.gen(function* () {\n    yield* Ref.set(awaitingCompletion, false);\n    // The capability belongs to the session that advertised it. During a\n    // reconnect, a new prepared connection can exist before the new session's\n    // config arrives; leaving the old value would let loadOlderTurns send\n    // window parameters to a server that may not accept them (review\n    // finding). makeSubscribeInput re-sets it from the next session's config.\n    yield* Ref.set(paginationSupported, false);\n    yield* SubscriptionRef.update(state, (current) => ({\n      ...current,\n      status: current.status === \"deleted\" ? current.status : statusWithoutLiveData(current.data),\n    }));\n  });\n  const setStreamError = (cause: Cause.Cause<unknown>) =>\n    Ref.set(awaitingCompletion, false).pipe(\n      Effect.andThen(\n        SubscriptionRef.update(state, (current) => ({\n          ...current,\n          status:\n            current.status === \"deleted\" ? current.status : statusWithoutLiveData(current.data),\n          error: Option.some(formatThreadError(cause)),\n        })),\n      ),\n    );\n\n  const setThread = Effect.fn(\"EnvironmentThreadState.setThread\")(function* (\n    thread: OrchestrationThread,\n    // \"keep\" preserves the current page state (live events touch only loaded\n    // recent turns); a snapshot or merged page passes its own page state.\n    page: Option.Option<EnvironmentThreadPageState> | \"keep\",\n  ) {\n    const waiting = yield* Ref.get(awaitingCompletion);\n    yield* SubscriptionRef.update(state, (current) => ({\n      data: Option.some(thread),\n      status: waiting ? (\"synchronizing\" as const) : (\"live\" as const),\n      error: Option.none(),\n      page: page === \"keep\" ? current.page : page,\n    }));\n    // Active threads can update many times per second and retain large tool\n    // payloads. The server remains the source of truth while a turn is active;\n    // persist once it settles so cache encoding stays off the streaming path.\n    if (shouldPersistThread(thread)) {\n      const snapshotSequence = yield* SubscriptionRef.get(lastSequence);\n      const currentPage = yield* SubscriptionRef.get(state).pipe(Effect.map((value) => value.page));\n      yield* Queue.offer(persistence, {\n        snapshotSequence,\n        thread,\n        // Persist the window boundary with the window's content so a cache\n        // restore can keep paging from where the loaded history ends.\n        ...Option.match(currentPage, {\n          onNone: () => ({}),\n          onSome: (value) =>\n            ({\n              page: {\n                beforeCursor: value.beforeCursor,\n                hasMore: value.hasMore,\n                snapshotSequence,\n              },\n            }) as const,\n        }),\n      });\n    }\n  });\n\n  const setDeleted = Effect.fn(\"EnvironmentThreadState.setDeleted\")(function* () {\n    yield* Ref.set(awaitingCompletion, false);\n    yield* Ref.update(historyEpoch, (epoch) => epoch + 1);\n    yield* SubscriptionRef.set(state, {\n      data: Option.none(),\n      status: \"deleted\",\n      error: Option.none(),\n      page: Option.none(),\n    });\n    yield* cache.removeThread(environmentId, threadId).pipe(\n      Effect.catch((error) =>\n        Effect.logWarning(\"Could not remove the cached thread.\").pipe(\n          Effect.annotateLogs({\n            environmentId,\n            threadId,\n            error: error.message,\n          }),\n        ),\n      ),\n    );\n  });\n\n  // Body of applyItem, running under applyLock.\n  const applyItemLocked = Effect.fn(\"EnvironmentThreadState.applyItemLocked\")(function* (\n    item: OrchestrationThreadStreamItem,\n  ) {\n    if (item.kind === \"synchronized\") {\n      yield* Ref.set(awaitingCompletion, false);\n      yield* SubscriptionRef.update(state, (current) =>\n        Option.isSome(current.data) && current.status !== \"deleted\"\n          ? { ...current, status: \"live\" as const, error: Option.none() }\n          : current,\n      );\n      return;\n    }\n\n    if (item.kind === \"snapshot\") {\n      // A fresh snapshot replaces all loaded history, including older\n      // pages: a turn reverted while disconnected would otherwise survive\n      // in the preserved history with no event left to remove it. The\n      // epoch bump discards any older-page fetch racing this snapshot.\n      yield* Ref.update(historyEpoch, (epoch) => epoch + 1);\n      yield* SubscriptionRef.set(lastSequence, item.snapshot.snapshotSequence);\n      yield* setThread(item.snapshot.thread, pageStateFromSnapshot(item.snapshot.page));\n      return;",
    "checksum": "a0068277d9fe46a387efaa9dbd9414d8eb43bb6f0d99cc1a8e353269d62d4838"
  },
  "reconnect-mobile-background-demand": {
    "id": "reconnect-mobile-background-demand",
    "path": "apps/mobile/src/connection/background-activity.ts",
    "start": 44,
    "end": 115,
    "language": "typescript",
    "label": "Mobile background activity reports and retained environment demand",
    "code": "export const mobileBackgroundActivityReporterLayer = Layer.effectDiscard(\n  Effect.gen(function* () {\n    const registry = yield* EnvironmentRegistry;\n    const storage = yield* MobileStorage.MobileStorage;\n    const clientId = yield* storage.loadOrCreateAgentAwarenessDeviceId.pipe(\n      Effect.map((deviceId) => `mobile-${deviceId}`),\n      Effect.orElseSucceed(() => \"ephemeral-mobile-client\"),\n    );\n    const reportRequests = yield* Queue.sliding<void>(1);\n    const requestReport = () => Queue.offerUnsafe(reportRequests, undefined);\n    let appState = AppState.currentState;\n\n    const report = Effect.gen(function* () {\n      const observedAtMs = yield* Clock.currentTimeMillis;\n      const active = appState === \"active\";\n      const entries = yield* SubscriptionRef.get(registry.entries);\n      yield* Effect.forEach(\n        entries.keys(),\n        (environmentId) =>\n          registry\n            .run(\n              environmentId,\n              request(WS_METHODS.serverReportClientActivity, {\n                environmentId: environmentId as EnvironmentId,\n                clientId,\n                clientKind: \"mobile\",\n                visible: active,\n                focused: active,\n                recentlyInteracted: active,\n                appState: normalizeAppState(appState),\n                scopes: [\n                  ...BASELINE_SCOPES,\n                  ...retainedMobileBackgroundScopes(environmentId as EnvironmentId),\n                ],\n                ttlMs: LEASE_TTL_MS,\n                observedAt: DateTime.makeUnsafe(observedAtMs),\n              }),\n            )\n            .pipe(Effect.ignore),\n        { concurrency: \"unbounded\", discard: true },\n      );\n    }).pipe(Effect.withSpan(\"mobile.backgroundActivity.report\"));\n\n    yield* Effect.acquireRelease(\n      Effect.sync(() => {\n        const removeScopeListener = onRetainedMobileBackgroundScopesChange(requestReport);\n        const subscription = AppState.addEventListener(\"change\", (nextState) => {\n          appState = nextState;\n          requestReport();\n        });\n        return { removeScopeListener, subscription };\n      }),\n      ({ removeScopeListener, subscription }) =>\n        Effect.sync(() => {\n          removeScopeListener();\n          subscription.remove();\n        }),\n    );\n    yield* SubscriptionRef.changes(registry.entries).pipe(\n      Stream.runForEach(() => Effect.sync(requestReport)),\n      Effect.forkScoped,\n    );\n    yield* Stream.fromQueue(reportRequests).pipe(\n      Stream.debounce(\"250 millis\"),\n      Stream.runForEach(() => report),\n      Effect.forkScoped,\n    );\n    yield* Effect.sync(requestReport).pipe(\n      Effect.repeat(Schedule.spaced(`${REPORT_INTERVAL_MS} millis`)),\n      Effect.forkScoped,\n    );\n  }),",
    "checksum": "1ee6a99a5ee47b441952a1ce0fcd1ed9ae24e67ae35ce7d3af3ece7bc5e91b20"
  },
  "reconnect-mobile-background-scopes": {
    "id": "reconnect-mobile-background-scopes",
    "path": "apps/mobile/src/connection/background-activity-scopes.ts",
    "start": 24,
    "end": 84,
    "language": "typescript",
    "label": "Reference-counted environment background scopes",
    "code": "function stableScopeKey(environmentId: EnvironmentId, scope: BackgroundScope): string {\n  switch (scope.type) {\n    case \"server-config\":\n    case \"diagnostics\":\n      return JSON.stringify([environmentId, scope.type]);\n    case \"provider-status\":\n      return JSON.stringify([environmentId, scope.type, scope.instanceId ?? null]);\n    case \"vcs-status\":\n    case \"git-refs\":\n      return JSON.stringify([environmentId, scope.type, scope.cwd]);\n    case \"thread\":\n      return JSON.stringify([environmentId, scope.type, scope.threadId]);\n  }\n}\n\nfunction scopeForSubscription(\n  observation: EnvironmentRpcSubscriptionObservation,\n): BackgroundScope | null {\n  if (observation.method === WS_METHODS.subscribeResourceTelemetry) {\n    return { type: \"diagnostics\" };\n  }\n  if (observation.method !== WS_METHODS.subscribeVcsStatus) {\n    return null;\n  }\n  const input = observation.input as { readonly cwd?: unknown };\n  return typeof input.cwd === \"string\" ? { type: \"vcs-status\", cwd: input.cwd } : null;\n}\n\nexport function retainedMobileBackgroundScopes(\n  environmentId: EnvironmentId,\n): ReadonlyArray<BackgroundScope> {\n  return Array.from(retainedScopes.values(), (entry) =>\n    entry.environmentId === environmentId ? entry.scope : null,\n  ).filter((scope): scope is BackgroundScope => scope !== null);\n}\n\nexport function observeMobileBackgroundActivitySubscription(\n  observation: EnvironmentRpcSubscriptionObservation,\n): Effect.Effect<Effect.Effect<void>> {\n  const scope = scopeForSubscription(observation);\n  if (scope === null) return Effect.succeed(Effect.void);\n  return Effect.sync(() => {\n    const environmentId = observation.environmentId as EnvironmentId;\n    const key = stableScopeKey(environmentId, scope);\n    const current = retainedScopes.get(key);\n    if (current) {\n      current.refCount += 1;\n    } else {\n      retainedScopes.set(key, { environmentId, scope, refCount: 1 });\n      notify();\n    }\n    return Effect.sync(() => {\n      const retained = retainedScopes.get(key);\n      if (!retained) return;\n      retained.refCount -= 1;\n      if (retained.refCount <= 0) {\n        retainedScopes.delete(key);\n        notify();\n      }\n    });\n  });",
    "checksum": "068d56fe85a7b15f425609c38d6f76e6cbb5077ff55cbafe0cba73903a029f7e"
  },
  "awareness-relay-signal-filter": {
    "id": "awareness-relay-signal-filter",
    "path": "apps/server/src/relay/AgentAwarenessRelay.ts",
    "start": 69,
    "end": 133,
    "language": "typescript",
    "label": "Awareness event filtering and projected-state sanitization",
    "code": "export function shouldPublishAgentAwarenessEvent(event: OrchestrationEvent): boolean {\n  switch (event.type) {\n    case \"thread.message-sent\":\n    case \"thread.turn-start-requested\":\n      // These events express intent to start work, but the shell still contains\n      // the previous turn's terminal state until the provider acknowledges the\n      // new turn. Publishing that snapshot can queue a fresh \"Done\" alert just\n      // before the real running state arrives. Provider lifecycle events publish\n      // the authoritative starting/running state instead.\n      return false;\n    case \"thread.proposed-plan-upserted\":\n    case \"thread.runtime-mode-set\":\n    case \"thread.interaction-mode-set\":\n      return false;\n    case \"thread.activity-appended\":\n      return (\n        event.payload.activity.kind === \"approval.requested\" ||\n        event.payload.activity.kind === \"approval.resolved\" ||\n        event.payload.activity.kind === \"provider.approval.respond.failed\" ||\n        event.payload.activity.kind === \"user-input.requested\" ||\n        event.payload.activity.kind === \"user-input.resolved\" ||\n        event.payload.activity.kind === \"runtime.error\"\n      );\n    default:\n      return true;\n  }\n}\n\nexport function agentAwarenessPublishIdentity(state: RelayAgentActivityState | null): string {\n  if (state === null) {\n    return \"null\";\n  }\n  const { updatedAt: _updatedAt, ...meaningfulState } = state;\n  return JSON.stringify(meaningfulState);\n}\n\nexport function isAgentActivityPublishingEnabled(value: string | null): boolean {\n  return isAgentActivityPublishingEnabledValue(value);\n}\n\nexport function resolveAgentActivityPublishingStartupState(input: {\n  readonly relayConfigured: boolean;\n  readonly publishEnabled: boolean;\n}): \"waiting-for-link\" | \"disabled\" | \"enabled\" {\n  if (!input.relayConfigured) {\n    return \"waiting-for-link\";\n  }\n  return input.publishEnabled ? \"enabled\" : \"disabled\";\n}\n\nconst RELAY_AGENT_ACTIVITY_DETAIL_MAX_LENGTH = 160;\nconst REDACTED_RELAY_AGENT_FAILURE_DETAIL = \"The agent run failed.\";\n\nexport function sanitizeRelayAgentActivityState(\n  state: RelayAgentActivityState | null,\n): RelayAgentActivityState | null {\n  if (state === null) {\n    return null;\n  }\n  const { detail: _detail, ...rest } = state;\n  const detail = (state.phase === \"failed\" ? REDACTED_RELAY_AGENT_FAILURE_DETAIL : state.detail)\n    ?.trim()\n    .slice(0, RELAY_AGENT_ACTIVITY_DETAIL_MAX_LENGTH)\n    .trim();\n  return detail ? { ...rest, detail } : rest;",
    "checksum": "cf128f94bb354ee125fea15b45caa64e3fd9014530925e9164bc6530d11d9818"
  },
  "awareness-relay-projected-publish": {
    "id": "awareness-relay-projected-publish",
    "path": "apps/server/src/relay/AgentAwarenessRelay.ts",
    "start": 345,
    "end": 426,
    "language": "typescript",
    "label": "Signed awareness publish and unchanged-state suppression",
    "code": "  const publishThreadUnsafe = Effect.fn(\"publishThreadUnsafe\")(function* (threadId: ThreadId) {\n    const publishAgentActivity = yield* readPublishAgentActivityEnabled.pipe(\n      Effect.orElseSucceed(() => false),\n    );\n    if (!publishAgentActivity) {\n      yield* Effect.logDebug(\"agent activity publish skipped; publication disabled\", {\n        threadId,\n      });\n      return;\n    }\n    const relayConfig = yield* readRelayConfig.pipe(Effect.orElseSucceed(() => null));\n    if (!relayConfig) {\n      yield* Effect.logDebug(\"agent activity publish skipped; relay link credentials unavailable\", {\n        threadId,\n      });\n      return;\n    }\n    const relayClient = yield* makeRelayClient(relayConfig);\n    const environmentId = yield* serverEnvironment.getEnvironmentId;\n\n    const publishState = (input: {\n      readonly projectId: string | null;\n      readonly state: RelayAgentActivityState | null;\n      readonly reason: string;\n    }) =>\n      Effect.gen(function* () {\n        const proof = yield* makePublishProof({\n          privateKey: cloudLinkKeyPair.privateKey,\n          relayIssuer: relayConfig.issuer,\n          environmentId,\n          threadId,\n          state: input.state,\n          jti: yield* crypto.randomUUIDv4,\n        });\n\n        yield* Effect.logInfo(\"publishing agent activity for thread\", {\n          environmentId,\n          threadId,\n          projectId: input.projectId,\n          statePhase: input.state?.phase ?? null,\n          hasState: input.state !== null,\n          reason: input.reason,\n        });\n\n        const response = yield* relayClient.server.publishAgentActivity({\n          params: {\n            environmentId,\n            threadId,\n          },\n          payload: {\n            state: input.state,\n            proof,\n          },\n        });\n\n        yield* Effect.logInfo(\"agent activity publish completed\", {\n          environmentId,\n          threadId,\n          ok: response.ok,\n          deliveries: deliveryStats(response.deliveries),\n        });\n      });\n\n    const thread = yield* snapshotQuery.getThreadShellById(threadId);\n    const project = Option.isSome(thread)\n      ? yield* snapshotQuery.getProjectShellById(thread.value.projectId)\n      : Option.none<OrchestrationProjectShell>();\n    const snapshot = resolveAgentAwarenessRelayPublishSnapshot({\n      environmentId,\n      threadId,\n      thread,\n      project,\n    });\n    const publishIdentity = agentAwarenessPublishIdentity(snapshot.state);\n    const publishedStateByThread = yield* Ref.get(publishedStateByThreadRef);\n    if (publishedStateByThread.get(threadId) === publishIdentity) {\n      // The projection is back at (or never left) the last published state, so\n      // any pending deferred confirmation is moot. Leaving the deadline in\n      // place would let a much later transient null find it already expired\n      // and publish a tombstone immediately, skipping the deferral window.\n      publishConfirmDeadlines.delete(threadId);\n      yield* Effect.logDebug(\"agent activity publish skipped; projected state unchanged\", {",
    "checksum": "6d030e7bb0a96b730ec457746e28f39d9a868e1065b4e67bc59a0e5329c576f5"
  },
  "awareness-apns-delivery-policy": {
    "id": "awareness-apns-delivery-policy",
    "path": "infra/relay/src/agentActivity/ApnsDeliveries.ts",
    "start": 143,
    "end": 326,
    "language": "typescript",
    "label": "APNs alert gating and Live Activity delivery cadence",
    "code": "function aggregateNeedsAttention(aggregate: RelayAgentActivityAggregateState): boolean {\n  return aggregate.activities.some(\n    (row) => row.phase === \"waiting_for_approval\" || row.phase === \"waiting_for_input\",\n  );\n}\n\nfunction isAttentionPhase(phase: string): boolean {\n  return phase === \"waiting_for_approval\" || phase === \"waiting_for_input\";\n}\n\n// Honors the same per-event notification switches the push channel uses; a\n// missing/corrupt preferences blob only disables nothing (matching how the\n// liveActivitiesEnabled check treats it), since every registration writes one.\nfunction alertAllowedForPhase(\n  preferences: RelayAgentAwarenessPreferences | null,\n  phase: string,\n): boolean {\n  if (preferences === null) {\n    return true;\n  }\n  switch (phase) {\n    case \"waiting_for_approval\":\n      return preferences.notifyOnApproval;\n    case \"waiting_for_input\":\n      return preferences.notifyOnInput;\n    case \"completed\":\n      return preferences.notifyOnCompletion;\n    case \"failed\":\n      return preferences.notifyOnFailure;\n    default:\n      return false;\n  }\n}\n\n// Alert copy for an update whose aggregate contains threads that were NOT in an\n// attention phase in the previously delivered aggregate. A null previous\n// aggregate means there is no known baseline (fresh registration, replay after\n// data loss) — alerting there would buzz on reconnect, not on a transition.\nexport function alertForAttentionTransition(input: {\n  readonly previousAggregate: RelayAgentActivityAggregateState | null;\n  readonly nextAggregate: RelayAgentActivityAggregateState;\n  readonly preferences: RelayAgentAwarenessPreferences | null;\n}): ApnsLiveActivityAlert | null {\n  if (input.previousAggregate === null) {\n    return null;\n  }\n  const previouslyAttention = new Set(\n    input.previousAggregate.activities\n      .filter((row) => isAttentionPhase(row.phase))\n      .map((row) => row.threadId),\n  );\n  const newlyAttention = input.nextAggregate.activities.filter(\n    (row) =>\n      isAttentionPhase(row.phase) &&\n      !previouslyAttention.has(row.threadId) &&\n      alertAllowedForPhase(input.preferences, row.phase),\n  );\n  const first = newlyAttention[0];\n  if (!first) {\n    return null;\n  }\n  if (newlyAttention.length === 1) {\n    return { title: first.threadTitle, body: `${first.status}: ${first.projectTitle}` };\n  }\n  return {\n    title: `${newlyAttention.length} agents need attention`,\n    body: newlyAttention.map((row) => row.threadTitle).join(\", \"),\n  };\n}\n\n// Alert copy for an update whose aggregate contains threads that finished\n// (Done/Failed) since the previously delivered aggregate — the mid-flight\n// completion buzz while other agents keep the activity alive. Requires the\n// thread to have been present and non-terminal before, so a baseline-less\n// replay or a row that merely fell off the display cap never rings.\nfunction newlyTerminalRows(\n  previousAggregate: RelayAgentActivityAggregateState | null,\n  nextAggregate: RelayAgentActivityAggregateState,\n): ReadonlyArray<RelayAgentActivityAggregateState[\"activities\"][number]> {\n  if (previousAggregate === null) {\n    return [];\n  }\n  const previousPhases = new Map(\n    previousAggregate.activities.map((row) => [row.threadId, row.phase]),\n  );\n  return nextAggregate.activities.filter((row) => {\n    if (row.phase !== \"completed\" && row.phase !== \"failed\") {\n      return false;\n    }\n    const previousPhase = previousPhases.get(row.threadId);\n    return (\n      previousPhase !== undefined && previousPhase !== \"completed\" && previousPhase !== \"failed\"\n    );\n  });\n}\n\nfunction isFreshTerminalRow(\n  row: RelayAgentActivityAggregateState[\"activities\"][number],\n  nowMs: number,\n): boolean {\n  const updatedAtMs = Option.match(DateTime.make(row.updatedAt), {\n    onNone: () => null,\n    onSome: (dt) => dt.epochMilliseconds,\n  });\n  return updatedAtMs !== null && nowMs - updatedAtMs <= TERMINAL_NOTIFICATION_FRESHNESS_MS;\n}\n\nexport function alertForNewlyTerminal(input: {\n  readonly previousAggregate: RelayAgentActivityAggregateState | null;\n  readonly nextAggregate: RelayAgentActivityAggregateState;\n  readonly preferences: RelayAgentAwarenessPreferences | null;\n  readonly nowMs: number;\n}): ApnsLiveActivityAlert | null {\n  const newlyTerminal = newlyTerminalRows(input.previousAggregate, input.nextAggregate).filter(\n    (row) =>\n      alertAllowedForPhase(input.preferences, row.phase) &&\n      // Replays of old aggregates (server restarts, redeliveries) repaint\n      // state without ringing; only fresh completions buzz.\n      isFreshTerminalRow(row, input.nowMs),\n  );\n  const first = newlyTerminal[0];\n  if (!first) {\n    return null;\n  }\n  if (newlyTerminal.length === 1) {\n    return { title: first.threadTitle, body: `${first.status}: ${first.projectTitle}` };\n  }\n  return {\n    title: `${newlyTerminal.length} agents finished`,\n    body: newlyTerminal.map((row) => row.threadTitle).join(\", \"),\n  };\n}\n\n// Alert copy for an end event carrying a terminal (Done/Failed) aggregate.\nexport function alertForTerminalAggregate(input: {\n  readonly aggregate: RelayAgentActivityAggregateState | null;\n  readonly preferences: RelayAgentAwarenessPreferences | null;\n}): ApnsLiveActivityAlert | null {\n  const row = input.aggregate?.activities[0];\n  if (!row || (row.phase !== \"completed\" && row.phase !== \"failed\")) {\n    return null;\n  }\n  if (!alertAllowedForPhase(input.preferences, row.phase)) {\n    return null;\n  }\n  return { title: row.threadTitle, body: `${row.status}: ${row.projectTitle}` };\n}\n\nfunction shouldUpdateLiveActivity(input: {\n  readonly previousAggregate: RelayAgentActivityAggregateState | null;\n  readonly nextAggregate: RelayAgentActivityAggregateState;\n  readonly lastDeliveryAt: string | null;\n  readonly nowMs: number;\n}): boolean {\n  if (!input.previousAggregate) {\n    return true;\n  }\n  if (JSON.stringify(input.previousAggregate) === JSON.stringify(input.nextAggregate)) {\n    return false;\n  }\n  if (input.previousAggregate.activeCount !== input.nextAggregate.activeCount) {\n    return true;\n  }\n  if (aggregateNeedsAttention(input.nextAggregate)) {\n    return true;\n  }\n  // A thread finishing must never be throttled away: when a completion and a\n  // new start land in the same window, activeCount is unchanged and the Done\n  // transition (and its alert) would otherwise be suppressed.\n  if (newlyTerminalRows(input.previousAggregate, input.nextAggregate).length > 0) {\n    return true;\n  }\n  const lastDeliveryAtMs =\n    input.lastDeliveryAt === null\n      ? null\n      : Option.match(DateTime.make(input.lastDeliveryAt), {\n          onNone: () => Number.NaN,\n          onSome: (dt) => dt.epochMilliseconds,\n        });\n  return (\n    lastDeliveryAtMs === null ||\n    Number.isNaN(lastDeliveryAtMs) ||\n    input.nowMs - lastDeliveryAtMs >= MIN_LIVE_ACTIVITY_UPDATE_INTERVAL_MS\n  );",
    "checksum": "50723205408ac50c442297f150778cbc2e74d222107af1646291a50932203a8e"
  },
  "awareness-mobile-registration-gate": {
    "id": "awareness-mobile-registration-gate",
    "path": "apps/mobile/src/features/agent-awareness/remoteRegistration.ts",
    "start": 69,
    "end": 90,
    "language": "typescript",
    "label": "Relay-accepted mobile registration and replay repair boundary",
    "code": "const environmentConnections = new Map<EnvironmentId, SavedRemoteConnection>();\nconst activityPushTokenListeners = new WeakSet<LiveActivity<AgentActivityProps>>();\n// Activity tokens the relay recently accepted, by acceptance time. The refresh\n// runs on sign-in, every app foreground, and every environment-connection\n// update, which arrive in bursts and spammed identical registrations. But the\n// registration is not a pure no-op: the relay replays the current aggregate to\n// this device on every accepted registration, and that replay is the\n// foreground reconciliation that repairs drifted or orphaned activities. So\n// dedupe only within a short window — bursts collapse to one request, while a\n// foreground after real time away still triggers a replay. Cleared on\n// sign-out/identity change alongside the device registration state.\nconst ACTIVITY_TOKEN_REREGISTER_INTERVAL_MS = 60_000;\nconst registeredActivityPushTokens = new Map<string, number>();\nlet pushTokenSubscription: { remove: () => void } | null = null;\nlet appStateSubscription: { remove: () => void } | null = null;\n\n// Whether the relay has actually accepted this device's registration. The\n// notification/Live Activity settings toggles must reflect this rather than\n// only local iOS permission or saved preferences: if the registration request\n// never succeeded, the device cannot receive anything, so the switches must\n// not read as enabled.\nexport type AgentAwarenessRegistrationStatus = \"unknown\" | \"pending\" | \"registered\" | \"failed\";",
    "checksum": "20d6bf8e2a049ae450c3958d6c8e90cdbcaff94bb0cc90602bed5aeee8b0b3a1"
  },
  "awareness-notification-navigation": {
    "id": "awareness-notification-navigation",
    "path": "apps/mobile/src/features/agent-awareness/notificationPayload.ts",
    "start": 37,
    "end": 105,
    "language": "typescript",
    "label": "Notification payload normalization, deduplication, and navigation",
    "code": "function encodeThreadDeepLink(input: {\n  readonly environmentId: string;\n  readonly threadId: string;\n}): string | null {\n  if (input.environmentId.length === 0 || input.threadId.length === 0) {\n    return null;\n  }\n  return `/threads/${encodeURIComponent(input.environmentId)}/${encodeURIComponent(input.threadId)}`;\n}\n\nfunction normalizeThreadDeepLink(value: string): string | null {\n  if (\n    value.trim() !== value ||\n    value.startsWith(\"//\") ||\n    value.includes(\"?\") ||\n    value.includes(\"#\")\n  ) {\n    return null;\n  }\n\n  const parts = value.split(\"/\");\n  if (parts.length !== 4 || parts[0] !== \"\" || parts[1] !== \"threads\") {\n    return null;\n  }\n\n  try {\n    return encodeThreadDeepLink({\n      environmentId: decodeURIComponent(parts[2] ?? \"\"),\n      threadId: decodeURIComponent(parts[3] ?? \"\"),\n    });\n  } catch {\n    return null;\n  }\n}\n\nexport function extractAgentNotificationDeepLink(response: unknown): string | null {\n  const data = dataFromNotificationResponse(response);\n  const deepLink = data?.deepLink;\n  if (typeof deepLink === \"string\") {\n    const normalizedDeepLink = normalizeThreadDeepLink(deepLink);\n    if (normalizedDeepLink) {\n      return normalizedDeepLink;\n    }\n  }\n\n  const environmentId = data?.environmentId;\n  const threadId = data?.threadId;\n  if (typeof environmentId === \"string\" && typeof threadId === \"string\") {\n    return encodeThreadDeepLink({ environmentId, threadId });\n  }\n  return null;\n}\n\nexport function routeAgentNotificationResponseOnce(input: {\n  readonly handledResponseIds: Set<string>;\n  readonly response: unknown;\n  readonly navigate: (deepLink: string) => void;\n}): void {\n  const responseId = identifierFromNotificationResponse(input.response);\n  if (responseId && input.handledResponseIds.has(responseId)) {\n    return;\n  }\n  if (responseId) {\n    input.handledResponseIds.add(responseId);\n  }\n  const deepLink = extractAgentNotificationDeepLink(input.response);\n  if (deepLink) {\n    input.navigate(deepLink);\n  }",
    "checksum": "2fad0a887c90a1d5575437758a8f2935fae5c4d77aba4e728221391123165783"
  },
  "reconnect-capability-descriptor": {
    "id": "reconnect-capability-descriptor",
    "path": "packages/contracts/src/environment.ts",
    "start": 31,
    "end": 92,
    "language": "typescript",
    "label": "Environment version and optional capability descriptor",
    "code": "/** How a server can replace itself with another version when asked over RPC.\n    New servers only advertise the stable launcher-backed \"boot-service\" path;\n    \"respawn\" remains decodable for compatibility with older servers. */\nexport const ServerSelfUpdateMethod = Schema.Literals([\"boot-service\", \"respawn\"]);\nexport type ServerSelfUpdateMethod = typeof ServerSelfUpdateMethod.Type;\n\n/** What update path a client should offer for a server: one of the RPC\n    self-update methods above, or \"desktop-managed\" when the backend's\n    version belongs to the T3 Code desktop app supervising it — updating the\n    app on that machine is the only way to update the server. */\nexport const ServerSelfUpdateCapability = Schema.Literals([\n  \"boot-service\",\n  \"respawn\",\n  \"desktop-managed\",\n]);\nexport type ServerSelfUpdateCapability = typeof ServerSelfUpdateCapability.Type;\n\nexport const ExecutionEnvironmentCapabilities = Schema.Struct({\n  repositoryIdentity: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),\n  connectionProbe: Schema.optionalKey(Schema.Boolean),\n  /** Server exposes the pull-request list, detail, activity, diff, and mutation APIs. Absent on\n      servers from before the pull-request workspace shipped, so clients must not probe them. */\n  pullRequests: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.settle / thread.unsettle commands. Absent on\n      pre-settlement servers, so clients treat missing as unsupported and\n      never send the commands under version skew. */\n  threadSettlement: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.snooze / thread.unsnooze commands. Same\n      version-skew contract as threadSettlement. */\n  threadSnooze: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.pin / thread.unpin commands. Same\n      version-skew contract as threadSettlement. */\n  threadPinning: Schema.optionalKey(Schema.Boolean),\n  /** Server understands thread.pin.reorder (and orderKey on thread.pin).\n      Same version-skew contract as threadSettlement. */\n  threadPinReorder: Schema.optionalKey(Schema.Boolean),\n  /** Server understands regenerateTitle on thread.meta.update. Absent on\n      older servers, so clients hide the action instead of sending it. */\n  threadTitleRegeneration: Schema.optionalKey(Schema.Boolean),\n  /** The update path clients should offer for this server. Absent on\n      servers that must be relaunched manually (dev checkouts, Windows\n      foreground runs, pre-update servers). */\n  serverSelfUpdate: Schema.optionalKey(ServerSelfUpdateCapability),\n  /** Server can stream self-update progress before acknowledging the\n      restart. Clients fall back to server.updateServer when absent. */\n  serverSelfUpdateProgress: Schema.optionalKey(Schema.Boolean),\n  /** Agent-activity publishes (push notifications and Live Activities)\n      currently leave this environment: the publish opt-in is enabled and the\n      relay link credentials exist. Clients skip seeding a Live Activity when\n      this is false — no update would ever repaint it. Absent on older\n      servers, which may still publish, so only an explicit false skips. */\n  agentActivityPublishing: Schema.optionalKey(Schema.Boolean),\n});\nexport type ExecutionEnvironmentCapabilities = typeof ExecutionEnvironmentCapabilities.Type;\n\nexport const ExecutionEnvironmentDescriptor = Schema.Struct({\n  environmentId: EnvironmentId,\n  label: TrimmedNonEmptyString,\n  platform: ExecutionEnvironmentPlatform,\n  serverVersion: TrimmedNonEmptyString,\n  capabilities: ExecutionEnvironmentCapabilities,\n});",
    "checksum": "5dbb79216344a256d038ab70c0befe0773721b63fa7d60caef52901ed5fa7cca"
  },
  "reconnect-version-skew-guidance": {
    "id": "reconnect-version-skew-guidance",
    "path": "apps/web/src/versionSkew.ts",
    "start": 21,
    "end": 130,
    "language": "typescript",
    "label": "Exact client-server version comparison and update guidance",
    "code": "function normalizeVersion(version: string | null | undefined): string | null {\n  const trimmed = version?.trim();\n  return trimmed && trimmed.length > 0 ? trimmed : null;\n}\n\nexport function resolveVersionMismatch(\n  serverVersion: string | null | undefined,\n): VersionMismatch | null {\n  const normalizedClientVersion = normalizeVersion(APP_VERSION);\n  const normalizedServerVersion = normalizeVersion(serverVersion);\n  if (\n    !normalizedClientVersion ||\n    !normalizedServerVersion ||\n    normalizedClientVersion === normalizedServerVersion\n  ) {\n    return null;\n  }\n\n  return {\n    clientVersion: normalizedClientVersion,\n    serverVersion: normalizedServerVersion,\n    hint: \"Version mismatch. Try syncing the client and server to the same T3 Code version.\",\n  };\n}\n\nexport function resolveServerConfigVersionMismatch(\n  serverConfig: Pick<ServerConfig, \"environment\"> | null | undefined,\n): VersionMismatch | null {\n  return resolveVersionMismatch(serverConfig?.environment.serverVersion);\n}\n\n/** The update path the connected server offers, or null when it only\n    supports a manual relaunch (older servers, dev checkouts, Windows). */\nexport function resolveServerSelfUpdateCapability(\n  serverConfig: Pick<ServerConfig, \"environment\"> | null | undefined,\n): ServerSelfUpdateCapability | null {\n  return serverConfig?.environment.capabilities.serverSelfUpdate ?? null;\n}\n\n/** The command to hand users whose server cannot update itself. */\nexport function manualServerUpdateCommand(targetVersion: string): string {\n  return `npx t3@${targetVersion}`;\n}\n\n/** One sentence telling the user how to resolve version skew for a server,\n    matched to the update path it offers. */\nexport function serverUpdateGuidance(\n  capability: ServerSelfUpdateCapability | null,\n  serverLabel: string,\n): string {\n  switch (capability) {\n    case \"boot-service\":\n    case \"respawn\":\n      return `Update the ${serverLabel} so they stay in sync.`;\n    case \"desktop-managed\":\n      return `Update the desktop app that runs the ${serverLabel}.`;\n    default:\n      return `Relaunch the ${serverLabel} with the copied command to sync them.`;\n  }\n}\n\nexport function buildVersionMismatchDismissalKey(\n  environmentId: EnvironmentId,\n  mismatch: Pick<VersionMismatch, \"clientVersion\" | \"serverVersion\">,\n): string {\n  return `${environmentId}:${mismatch.clientVersion}:${mismatch.serverVersion}`;\n}\n\nfunction readVersionMismatchDismissals(): VersionMismatchDismissals {\n  try {\n    return (\n      getLocalStorageItem(\n        VERSION_MISMATCH_DISMISSALS_STORAGE_KEY,\n        VersionMismatchDismissalsSchema,\n      ) ?? { keys: [] }\n    );\n  } catch (error) {\n    console.error(\"Could not read version-mismatch dismissals.\", error);\n    return { keys: [] };\n  }\n}\n\nfunction writeVersionMismatchDismissals(document: VersionMismatchDismissals): void {\n  try {\n    setLocalStorageItem(\n      VERSION_MISMATCH_DISMISSALS_STORAGE_KEY,\n      document,\n      VersionMismatchDismissalsSchema,\n    );\n  } catch (error) {\n    console.error(\"Could not persist version-mismatch dismissals.\", error);\n  }\n}\n\nexport function isVersionMismatchDismissed(dismissalKey: string | null | undefined): boolean {\n  if (!dismissalKey) {\n    return false;\n  }\n  return readVersionMismatchDismissals().keys.includes(dismissalKey);\n}\n\nexport function dismissVersionMismatch(dismissalKey: string | null | undefined): void {\n  if (!dismissalKey) {\n    return;\n  }\n  const document = readVersionMismatchDismissals();\n  if (document.keys.includes(dismissalKey)) {\n    return;\n  }\n  writeVersionMismatchDismissals({",
    "checksum": "493e23986ed26727ea268f4e5ebc7a939ca984654515b3fccfad44cc899386f0"
  },
  "reconnect-exact-version-update": {
    "id": "reconnect-exact-version-update",
    "path": "apps/server/src/cloud/selfUpdate.ts",
    "start": 30,
    "end": 190,
    "language": "typescript",
    "label": "Exact-version staging, preflight, and launcher activation handoff",
    "code": "export function resolveServerSelfUpdateCapability(input: {\n  readonly desktopManaged: boolean;\n  readonly launcherManaged: boolean;\n}): ServerSelfUpdateCapability | null {\n  if (input.desktopManaged) return \"desktop-managed\" as const;\n  return input.launcherManaged ? (\"boot-service\" as const) : null;\n}\n\nexport class ServerSelfUpdate extends Context.Service<\n  ServerSelfUpdate,\n  {\n    readonly update: (\n      input: ServerSelfUpdateInput,\n      reportProgress?: (stage: ServerSelfUpdateProgressStage) => Effect.Effect<void>,\n    ) => Effect.Effect<ServerSelfUpdateResult, ServerSelfUpdateError>;\n  }\n>()(\"t3/cloud/selfUpdate/ServerSelfUpdate\") {}\n\nexport const make = Effect.fn(\"cloud.server_self_update.make\")(function* () {\n  const serverConfig = yield* ServerConfig.ServerConfig;\n  const launcher = yield* ServiceLauncherClient.ServiceLauncherClient;\n  const runner = yield* ProcessRunner.ProcessRunner;\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const execPath = yield* HostProcessExecutablePath;\n  const inFlight = yield* Ref.make(false);\n\n  const capability: ServerSelfUpdateCapability | null =\n    serverConfig.mode === \"desktop\" ? \"desktop-managed\" : launcher.managed ? \"boot-service\" : null;\n  const failWith = (reason: string, cause?: unknown) =>\n    cause === undefined\n      ? new ServerSelfUpdateError({ reason })\n      : new ServerSelfUpdateError({ reason, cause });\n\n  const update: ServerSelfUpdate[\"Service\"][\"update\"] = Effect.fn(\n    \"cloud.server_self_update.update\",\n  )(function* (input, reportProgress = () => Effect.void) {\n    if (capability === \"desktop-managed\") {\n      return yield* failWith(\n        \"This server is managed by the T3 Code desktop app on its machine; update the desktop app to update it.\",\n      );\n    }\n    if (capability === null) {\n      return yield* failWith(\n        \"Remote updates require the T3 Code background service. Run `t3 service install` on the server machine.\",\n      );\n    }\n\n    const targetVersion = input.targetVersion.trim();\n    if (!isExactServiceVersion(targetVersion)) {\n      return yield* failWith(`'${targetVersion}' is not an exact t3 version.`);\n    }\n    if (yield* Ref.getAndSet(inFlight, true)) {\n      return yield* failWith(\"A server update is already in progress.\");\n    }\n\n    return yield* Effect.gen(function* () {\n      yield* reportProgress(\"downloading\");\n      const paths = yield* ensurePinnedRuntimeInstalled({\n        baseDir: serverConfig.baseDir,\n        version: targetVersion,\n        fs,\n        path,\n        runner,\n        validate: (runtime) =>\n          runner\n            .run({\n              command: execPath,\n              args: [\n                runtime.entryPath,\n                \"__service-preflight\",\n                \"--database-path\",\n                serverConfig.dbPath,\n                \"--launcher-protocol\",\n                String(SERVICE_LAUNCHER_PROTOCOL),\n              ],\n              timeout: PREFLIGHT_TIMEOUT,\n            })\n            .pipe(\n              Effect.mapError(\n                (cause) =>\n                  new PinnedRuntimeInstallError({\n                    step: \"running the staged service preflight\",\n                    cause,\n                  }),\n              ),\n              Effect.flatMap(\n                (\n                  result,\n                ): Effect.Effect<\n                  void,\n                  PinnedRuntimeInstallError | PinnedRuntimePreflightBlockedError\n                > => {\n                  if (result.code !== 0) {\n                    return Effect.fail(\n                      new PinnedRuntimeInstallError({\n                        step: \"running the staged service preflight\",\n                        exitCode: Number(result.code),\n                        stdoutLength: result.stdout.length,\n                        stderrLength: result.stderr.length,\n                      }),\n                    );\n                  }\n                  let parsed: unknown;\n                  try {\n                    parsed = JSON.parse(result.stdout.trim());\n                  } catch (cause) {\n                    return Effect.fail(\n                      new PinnedRuntimeInstallError({\n                        step: \"decoding the staged service preflight\",\n                        cause,\n                      }),\n                    );\n                  }\n                  const preflight = decodeServicePreflightResult(parsed);\n                  if (preflight === undefined || preflight.version !== targetVersion) {\n                    return Effect.fail(\n                      new PinnedRuntimeInstallError({\n                        step: \"verifying the staged service preflight\",\n                      }),\n                    );\n                  }\n                  return preflight.status === \"ready\"\n                    ? Effect.void\n                    : Effect.fail(\n                        new PinnedRuntimePreflightBlockedError({\n                          version: targetVersion,\n                          reason: preflight.reason,\n                        }),\n                      );\n                },\n              ),\n            ),\n      }).pipe(\n        Effect.mapError((error) =>\n          error._tag === \"PinnedRuntimePreflightBlockedError\"\n            ? failWith(error.reason, error)\n            : failWith(`Could not prepare t3@${targetVersion}.`, error),\n        ),\n      );\n\n      yield* reportProgress(\"installing\");\n      const updateId = yield* launcher\n        .requestUpdate({ targetVersion, dbPath: serverConfig.dbPath })\n        .pipe(\n          Effect.mapError((error) =>\n            failWith(\n              error._tag === \"ServiceLauncherRejectedError\"\n                ? error.reason\n                : \"Could not ask the service launcher to activate the prepared update.\",\n              error,\n            ),\n          ),\n        );\n\n      yield* Effect.logInfo(\"Server update prepared; handing off to the service launcher.\", {\n        updateId,\n        targetVersion,\n        runtimePath: paths.entryPath,\n      });\n      return { targetVersion, method: \"boot-service\" as const, updateId };",
    "checksum": "1cde992413bb70e3aa3870a47b638f195f71bea15ad23b31c52f713e142bcc06"
  }
}