typeclaw 0.36.0 → 0.36.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeclaw",
-  "version": "0.36.0",
+  "version": "0.36.2",
   "homepage": "https://github.com/typeclaw/typeclaw#readme",
   "bugs": {
     "url": "https://github.com/typeclaw/typeclaw/issues"
@@ -48,7 +48,7 @@
     "@mariozechner/pi-tui": "^0.67.3",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
-    "agent-messenger": "2.19.1",
+    "agent-messenger": "2.19.2",
     "cheerio": "^1.2.0",
     "citty": "^0.2.2",
     "cron-parser": "^5.5.0",

package/src/agent/index.ts

@@ -383,6 +383,7 @@ export async function createSessionWithDispose(options: CreateSessionOptions = {
                     originatingSessionId: sessionManager.getSessionId(),
                     ...(options.stream ? { stream: options.stream } : {}),
                     ...buildRestartHandoffWiring(options, sessionManager),
+                    triggeringAuthorIdProvider: () => currentChannelAuthor(getOrigin),
                   }),
                 ]
               : []),
@@ -523,6 +524,16 @@ export function buildRestartHandoffWiring(
   return { agentDir, originatingSessionFile: sessionFile, handoffOrigin }
 }
 
+// Reads the LIVE turn author at restart time, not the session-creation
+// snapshot. A channel session is long-lived and multi-principal: the
+// self-restart tool fires on whatever turn triggered it, so the handoff must
+// carry that turn's author (originRef.current), not whoever first opened the
+// session. Returns undefined for non-channel/no-author origins.
+export function currentChannelAuthor(getOrigin: () => SessionOrigin | undefined): string | undefined {
+  const origin = getOrigin()
+  return origin?.kind === 'channel' ? origin.lastInboundAuthorId : undefined
+}
+
 function restartHandoffOriginFor(origin: SessionOrigin): RestartHandoffOrigin | null {
   if (origin.kind === 'tui') return { kind: 'tui' }
   if (origin.kind === 'channel') {

package/src/agent/plugin-tools.ts

@@ -38,6 +38,7 @@ import type {
 import {
   buildSandboxedCommand,
   canMountRealProc,
+  commandNeedsRealProc,
   DEFAULT_SANDBOX_ENV,
   ensureBwrapAvailable,
   ensureSessionTmpDir,
@@ -51,6 +52,7 @@ import {
   resolveProtectedZones,
   resolveSandboxSymlinks,
   resolveWritableZones,
+  SandboxDegradedProcError,
   type SandboxProcStrategy,
   subtractMasked,
 } from '@/sandbox'
@@ -643,6 +645,15 @@ async function applyBashSandbox(
   // it would never reach the sandboxed process (the non-sandboxed spawnHook
   // path does not run when the command is rewritten to a bwrap invocation).
   const proc = await resolveProcStrategy()
+  // Fail fast with an actionable error when /proc degraded to tmpfs AND the
+  // command needs a real /proc: under tmpfs Bun would otherwise abort deep in its
+  // pipeline with the opaque "NotDir", which the model retries forever. The
+  // SandboxDegradedProcError message tells it this is an environment limit, not
+  // the command's fault. Guarded on the command so non-bun bash still runs in the
+  // degraded mode (it does not touch /proc/self/{fd,maps}).
+  if (proc === 'tmpfs' && commandNeedsRealProc(command)) {
+    throw new SandboxDegradedProcError()
+  }
   const { commandString } = buildSandboxedCommand(command, {
     mounts: [
       { type: 'ro-bind', source: agentDir, dest: agentDir },

package/src/agent/restart/index.ts

@@ -35,6 +35,10 @@ export type RequestContainerRestartOptions = {
   // startup). Required alongside agentDir + originatingSessionFile for the
   // handoff to be written; omitting it skips the handoff entirely.
   handoffOrigin?: RestartHandoffOrigin
+  // Author of the inbound that owned the restarting session, carried so the
+  // reopened channel session re-seeds the requester's identity on its resume
+  // turn (see RestartHandoff.triggeringAuthorId).
+  triggeringAuthorId?: string
   restartedAt?: string
 }
 
@@ -54,6 +58,7 @@ export async function requestContainerRestart({
   originatingSessionId,
   originatingSessionFile,
   handoffOrigin,
+  triggeringAuthorId,
   restartedAt,
 }: RequestContainerRestartOptions): Promise<RequestContainerRestartResult> {
   const request = { kind: 'restart' as const, containerName, build: build === true }
@@ -103,6 +108,7 @@ export async function requestContainerRestart({
         originatingSessionId,
         originatingSessionFile: basename(originatingSessionFile),
         origin: handoffOrigin,
+        ...(triggeringAuthorId !== undefined ? { triggeringAuthorId } : {}),
       })
     } catch {
       // intentional swallow — see the post-ACK rationale above

package/src/agent/restart-handoff/index.ts

@@ -35,6 +35,13 @@ export type RestartHandoff = {
   originatingSessionId: string
   originatingSessionFile: string
   origin: RestartHandoffOrigin
+  // Author of the inbound that owned the originating session at restart time.
+  // The synthetic resume turn has no inbound of its own, so without this a
+  // multi-principal channel session re-seeds its turn author from nothing and
+  // an author-scoped role (`discord:* author:U_OWNER`) silently demotes to
+  // whatever bare-channel rule matches on every "I'm back" turn. Optional and
+  // additive: pre-field v2 handoffs and tui handoffs omit it.
+  triggeringAuthorId?: string
 }
 
 // Atomic write via `.tmp` + rename so a crash mid-write never leaves the
@@ -158,6 +165,9 @@ function parseHandoff(raw: string): RestartHandoff | null {
     originatingSessionId: obj.originatingSessionId,
     originatingSessionFile: obj.originatingSessionFile,
     origin,
+    ...(typeof obj.triggeringAuthorId === 'string' && obj.triggeringAuthorId !== ''
+      ? { triggeringAuthorId: obj.triggeringAuthorId }
+      : {}),
   }
 }
 

package/src/agent/tools/restart.ts

@@ -57,6 +57,12 @@ export type CreateRestartToolOptions = {
   // alongside `originatingSessionFile` for the handoff to be written; omit to
   // skip the handoff. See buildRestartHandoffWiring in src/agent/index.ts.
   handoffOrigin?: RestartHandoffOrigin
+  // Resolves the LIVE turn author at execute time (not session-creation), so a
+  // channel self-restart in a long-lived multi-principal session resumes under
+  // the author of the turn that triggered the restart — not whoever opened the
+  // session. Called inside execute(); returns undefined for tui/no-author
+  // origins. See RestartHandoff.triggeringAuthorId.
+  triggeringAuthorIdProvider?: () => string | undefined
 }
 
 export type RestartToolDetails = { ok: boolean; containerName: string; reason?: string }
@@ -75,6 +81,7 @@ export function createRestartTool({
   agentDir,
   originatingSessionFile,
   handoffOrigin,
+  triggeringAuthorIdProvider,
 }: CreateRestartToolOptions) {
   const doExit = exit ?? ((code: number) => process.exit(code))
 
@@ -103,6 +110,7 @@ export function createRestartTool({
     }),
     async execute(_toolCallId, params) {
       const build = params.build === true
+      const triggeringAuthorId = triggeringAuthorIdProvider?.()
       // requestContainerRestart owns the post-ACK broadcast->handoff ordering:
       // on a successful ACK it publishes the container-restarting notice (which
       // every live session's subscribeRestartNotice turns into a transcript
@@ -121,6 +129,7 @@ export function createRestartTool({
         ...(agentDir !== undefined ? { agentDir } : {}),
         ...(originatingSessionFile !== undefined ? { originatingSessionFile } : {}),
         ...(handoffOrigin !== undefined ? { handoffOrigin } : {}),
+        ...(triggeringAuthorId !== undefined ? { triggeringAuthorId } : {}),
       })
       if (!result.ok) {
         const details: RestartToolDetails = { ok: false, containerName, reason: result.reason }

package/src/bundled-plugins/backup/README.md

@@ -45,7 +45,15 @@ Commit message comes from the `backup-message` subagent, which sees a truncated
 
 ## What it pushes
 
-When `pushToOrigin: true` and the current branch has an upstream (`git rev-parse --abbrev-ref --symbolic-full-name @{upstream}` succeeds), the runner runs `git push`. On non-fast-forward rejection, it runs `git fetch` then `git rebase <upstream>` then `git push` again.
+When `pushToOrigin: true`, the runner picks a push plan after committing:
+
+- **Branch has an upstream** (`git rev-parse --abbrev-ref --symbolic-full-name @{upstream}` succeeds): run `git push`.
+- **No upstream, but `origin` exists and `HEAD` is a real branch**: run `git push -u origin HEAD:<branch>`, which pushes _and_ establishes tracking in one shot. This is the common case for a fresh agent folder nobody ran `git push -u` on by hand — previously the runner committed forever and never pushed here. Every later cycle then takes the plain-upstream path.
+- **No `origin`, or detached `HEAD`**: commit only (a legitimate offline / no-remote state). No push is attempted and no diagnostics are written.
+
+On non-fast-forward rejection (either push shape), the runner runs `git fetch` then `git rebase <remote-branch>` then re-pushes with the same args. Only `origin` is ever acted on for the set-upstream case — the runner never guesses a destination the operator didn't configure.
+
+**Credentials.** The runner spawns `git` directly (not via the `bash` tool), so the `github-cli-auth` plugin's `tool.before` credential injection does **not** fire for it. For **GitHub App auth** the backup plugin mints a per-repo installation token for `origin`'s github.com slug and injects it into the runner's git env via the same `GIT_ASKPASS` helper the bash path uses (token in `TYPECLAW_GIT_TOKEN`, never in argv/config; ssh remotes rewritten to https via `insteadOf`). Classic/fine-grained PATs, SSH-key, and credential-helper setups are left untouched — the runner uses its inherited process env. Non-github origins are never minted for.
 
 If any network step fails (rebase conflict, auth failure, network timeout), the runner aborts cleanly and spawns the `backup-diagnose` subagent. That subagent has `bash`, `read`, and `write` tools and writes a short human-readable report to `<agentDir>/sessions/backup-diagnostics.log`. The diagnose subagent is explicitly forbidden from force-pushing or resolving merge conflicts itself.
 
@@ -77,5 +85,6 @@ This feature came up as: "periodically check for dirty files and commit; LLM pic
 
 ## Tests
 
-- `runner.test.ts` — deterministic runner unit tests (status parsing, force-add of `sessions/`, push-only-with-upstream, rebase-on-non-fast-forward, diagnose-on-rebase-conflict, advisory-throw isolation, sanitize-commit-message).
+- `runner.test.ts` — deterministic runner unit tests (status parsing, force-add of `sessions/`, push-with-upstream, push-and-set-upstream when origin exists but tracking is absent, commit-only on no-origin / detached-HEAD, rebase-on-non-fast-forward for both push shapes, diagnose-on-rebase-conflict, advisory-throw isolation, sanitize-commit-message).
+- `git-auth.test.ts` — credential-env resolution (App-auth mints for the origin slug; PAT/SSH/non-github/unavailable-token all fall back to inherited env).
 - `index.test.ts` — plugin composition tests (subagent/hook surface, config schema defaults and validation, debounce, active-turn gating, self-induced-turn exclusion, coalescing).

package/src/bundled-plugins/backup/git-auth.ts

@@ -0,0 +1,58 @@
+import type { GithubTokenResolveResult } from '@/channels/github-token-bridge'
+
+import { ensureGitAskPassHelper } from '../github-cli-auth/git-askpass'
+import { parseGithubRepoFromGitUrl } from '../github-cli-auth/git-command'
+import { shouldMintAppToken } from '../github-cli-auth/token-class'
+
+export type BackupGitAuthEnv = Record<string, string>
+
+export type BackupPushAuthDeps = {
+  hasAppTokenResolver: () => boolean
+  ghToken: string | undefined
+  resolveTokenForRepo: (repoSlug: string) => Promise<GithubTokenResolveResult>
+  resolveOriginPushUrl: (cwd: string) => Promise<string | null>
+  ensureAskPassHelper: () => Promise<string>
+}
+
+// The backup runner spawns git directly (not via the bash tool), so the
+// `github-cli-auth` plugin's `tool.before` credential injection never fires for
+// its push. Without this, App-auth agents push with no credentials and fail.
+// We mirror that plugin exactly: only mint for App auth, only for a github.com
+// origin, scoped to the origin's own repo slug. PAT/SSH/credential-helper setups
+// return null and keep using the runner's inherited process env.
+export async function resolveBackupPushAuthEnv(
+  cwd: string,
+  deps: BackupPushAuthDeps,
+): Promise<BackupGitAuthEnv | null> {
+  if (!shouldMintAppToken(deps.ghToken, deps.hasAppTokenResolver())) return null
+
+  const originUrl = await deps.resolveOriginPushUrl(cwd)
+  if (originUrl === null) return null
+
+  const slug = parseGithubRepoFromGitUrl(originUrl)
+  if (slug === null) return null
+
+  const token = await deps.resolveTokenForRepo(slug)
+  if (token.kind !== 'token') return null
+
+  const askpass = await deps.ensureAskPassHelper()
+
+  // Token rides in TYPECLAW_GIT_TOKEN (read by the askpass helper), never in
+  // argv/config. The insteadOf rewrites map ssh/scp github remotes to https so
+  // the askpass credential applies; GIT_TERMINAL_PROMPT=0 fails fast instead of
+  // hanging on a prompt. Mirrors github-cli-auth/index.ts.
+  return {
+    GIT_ASKPASS: askpass,
+    TYPECLAW_GIT_TOKEN: token.token,
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_CONFIG_COUNT: '2',
+    GIT_CONFIG_KEY_0: 'url.https://github.com/.insteadOf',
+    GIT_CONFIG_VALUE_0: 'git@github.com:',
+    GIT_CONFIG_KEY_1: 'url.https://github.com/.insteadOf',
+    GIT_CONFIG_VALUE_1: 'ssh://git@github.com/',
+  }
+}
+
+export function makeDefaultAskPassEnsurer(): () => Promise<string> {
+  return () => ensureGitAskPassHelper()
+}

package/src/bundled-plugins/backup/index.ts

@@ -3,6 +3,7 @@ import { z } from 'zod'
 import { withGitLock } from '@/git/mutex'
 import { definePlugin, type PluginContext, type SpawnSubagentOptions, type Subagent } from '@/plugin'
 
+import { type BackupPushAuthDeps, makeDefaultAskPassEnsurer, resolveBackupPushAuthEnv } from './git-auth'
 import { COMMIT_TIMEOUT_MS, makeDefaultGitSpawn, NETWORK_TIMEOUT_MS, runBackup, type BackupResult } from './runner'
 import {
   cleanupMessageFile,
@@ -163,6 +164,7 @@ async function runBackupOnce(
     agentDir: string
     logger: { info: (m: string) => void; warn: (m: string) => void }
     spawnSubagent: PluginContext['spawnSubagent']
+    github: PluginContext['github']
   },
 ): Promise<BackupResult> {
   const messagePath = messageFilePath(payload.agentDir)
@@ -175,11 +177,21 @@ async function runBackupOnce(
     spawnedByOrigin: { kind: 'tui', sessionId: 'backup-runner' },
   }
 
+  // App-auth agents need a minted per-repo token for the runner's push (it
+  // bypasses the bash tool's credential hook). Only computed when we'll push;
+  // PAT/SSH/non-github fall back to null. Passed as `pushEnv` so the runner
+  // applies it to push/fetch ONLY — never to local commands like `git commit`,
+  // which can run repo-controlled hooks that would otherwise see the token.
+  const pushEnv = payload.pushToOrigin
+    ? ((await resolveBackupAuthEnv(payload.agentDir, ctx.github, ctx.logger)) ?? undefined)
+    : undefined
+
   const result = await withGitLock(payload.agentDir, () =>
     runBackup(
       { cwd: payload.agentDir, pushToOrigin: payload.pushToOrigin },
       {
         gitSpawn: makeDefaultGitSpawn(),
+        pushEnv,
         pickCommitMessage: async ({ status, diffstat }) => {
           await cleanupMessageFile(messagePath)
           const messagePayload: CommitMessagePayload = {
@@ -221,6 +233,48 @@ async function runBackupOnce(
   return result
 }
 
+async function resolveBackupAuthEnv(
+  agentDir: string,
+  github: PluginContext['github'],
+  logger: { warn: (m: string) => void },
+): Promise<Record<string, string> | null> {
+  const deps: BackupPushAuthDeps = {
+    hasAppTokenResolver: github.hasAppTokenResolver,
+    ghToken: process.env.GH_TOKEN,
+    resolveTokenForRepo: github.resolveTokenForRepo,
+    resolveOriginPushUrl,
+    ensureAskPassHelper: makeDefaultAskPassEnsurer(),
+  }
+  try {
+    return await resolveBackupPushAuthEnv(agentDir, deps)
+  } catch {
+    // Credential prep is best-effort: a resolver failure must not abort the
+    // backup. Falls back to the runner's inherited env (commit still happens),
+    // and the push's own failure path diagnoses if it then can't authenticate.
+    // No slug/token/error detail is logged — those are credential-adjacent.
+    logger.warn('GitHub backup auth unavailable; continuing with inherited git credentials')
+    return null
+  }
+}
+
+async function resolveOriginPushUrl(cwd: string): Promise<string | null> {
+  const bun = (globalThis as { Bun?: { spawn: typeof Bun.spawn } }).Bun
+  if (!bun) return null
+  try {
+    const proc = bun.spawn({
+      cmd: ['git', '-C', cwd, 'remote', 'get-url', '--push', 'origin'],
+      stdout: 'pipe',
+      stderr: 'ignore',
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0' },
+    })
+    if ((await proc.exited) !== 0) return null
+    const out = (await new Response(proc.stdout).text()).trim()
+    return out === '' ? null : out
+  } catch {
+    return null
+  }
+}
+
 function describeResult(r: BackupResult): string {
   if (r.ok) return r.kind
   return `failed (${r.kind}): ${r.reason}`

package/src/bundled-plugins/backup/runner.ts

@@ -21,12 +21,20 @@ export type GitSpawnResult = {
   timedOut: boolean
 }
 
-export type GitSpawn = (args: readonly string[], opts: { cwd: string; timeoutMs: number }) => Promise<GitSpawnResult>
+export type GitSpawn = (
+  args: readonly string[],
+  opts: { cwd: string; timeoutMs: number; env?: Record<string, string> },
+) => Promise<GitSpawnResult>
 
 export type BackupRunnerDeps = {
   gitSpawn: GitSpawn
   pickCommitMessage: (input: { status: string; diffstat: string }) => Promise<string>
   diagnoseFailure?: (input: BackupFailureInput) => Promise<void>
+  // Credential env (GIT_ASKPASS/TYPECLAW_GIT_TOKEN/insteadOf) applied ONLY to
+  // network git invocations (push/fetch). It is deliberately NOT given to local
+  // commands — `git commit` can run repo-controlled hooks, which must never see
+  // the minted token.
+  pushEnv?: Record<string, string>
   now?: () => number
 }
 
@@ -44,9 +52,15 @@ export type BackupFailureInput = {
 }
 
 export type BackupResult =
-  | { ok: true; kind: 'no-repo' | 'clean' | 'committed' | 'pushed' | 'rebased-and-pushed' }
+  | { ok: true; kind: 'no-repo' | 'clean' | 'committed' | 'pushed' | 'pushed-set-upstream' | 'rebased-and-pushed' }
   | { ok: false; kind: 'commit-failed' | 'push-failed' | 'rebase-failed' | 'aborted'; reason: string }
 
+type ActivePushPlan =
+  | { kind: 'upstream'; upstreamRef: string }
+  | { kind: 'set-upstream'; remote: string; branch: string }
+
+type PushPlan = ActivePushPlan | { kind: 'skip' }
+
 export async function runBackup(options: BackupRunnerOptions, deps: BackupRunnerDeps): Promise<BackupResult> {
   const { cwd, pushToOrigin } = options
 
@@ -113,24 +127,70 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
 
   if (!pushToOrigin) return { ok: true, kind: 'committed' }
 
+  const plan = await resolvePushPlan(cwd, deps)
+  if (plan.kind === 'skip') return { ok: true, kind: 'committed' }
+
+  return pushWithRecovery(cwd, deps, plan)
+}
+
+// `@{upstream}` resolution failing was previously treated as "no push" — but a
+// fresh agent repo that nobody ran `git push -u` on has a configured `origin`
+// and no tracking ref, so the runner committed forever and never pushed. The
+// correct gate when `pushToOrigin` is on is "origin exists and HEAD is a real
+// branch": then we push AND set the upstream in one shot, and every later run
+// takes the plain-upstream path. No remote / detached HEAD stays commit-only
+// (a legitimate offline state), so it returns `skip` rather than diagnosing.
+async function resolvePushPlan(cwd: string, deps: BackupRunnerDeps): Promise<PushPlan> {
   const upstream = await deps.gitSpawn(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], {
     cwd,
     timeoutMs: COMMIT_TIMEOUT_MS,
   })
-  if (upstream.exitCode !== 0) return { ok: true, kind: 'committed' }
+  if (upstream.exitCode === 0 && upstream.stdout.trim().length > 0) {
+    return { kind: 'upstream', upstreamRef: upstream.stdout.trim() }
+  }
 
-  const upstreamRef = upstream.stdout.trim()
-  if (upstreamRef.length === 0) return { ok: true, kind: 'committed' }
+  // Only `origin` is acted on: picking "the first remote" when origin is absent
+  // would guess a destination the operator never configured. `get-url` (not
+  // `get-url --push`) is enough here — we only need to know origin EXISTS and
+  // is named `origin`; the push targets `origin` by name regardless of pushurl.
+  const origin = await deps.gitSpawn(['remote', 'get-url', 'origin'], { cwd, timeoutMs: COMMIT_TIMEOUT_MS })
+  if (origin.exitCode !== 0 || origin.stdout.trim().length === 0) return { kind: 'skip' }
 
-  const push = await deps.gitSpawn(['push'], { cwd, timeoutMs: NETWORK_TIMEOUT_MS })
-  if (push.exitCode === 0) return { ok: true, kind: 'pushed' }
+  // `symbolic-ref --short HEAD` fails on a detached HEAD (no branch to set an
+  // upstream for); `rev-parse --abbrev-ref HEAD` would have returned the literal
+  // "HEAD" and we'd have tried to push a branch named HEAD. Skip cleanly.
+  const branch = await deps.gitSpawn(['symbolic-ref', '--short', 'HEAD'], { cwd, timeoutMs: COMMIT_TIMEOUT_MS })
+  if (branch.exitCode !== 0 || branch.stdout.trim().length === 0) return { kind: 'skip' }
+
+  return { kind: 'set-upstream', remote: 'origin', branch: branch.stdout.trim() }
+}
+
+// Both entry points (plain push and first-time set-upstream push) share the
+// non-fast-forward recovery: fetch, rebase onto the intended remote branch,
+// re-push. Keeping one helper stops the set-upstream path from silently becoming
+// a weaker duplicate that skips recovery.
+async function pushWithRecovery(cwd: string, deps: BackupRunnerDeps, plan: ActivePushPlan): Promise<BackupResult> {
+  const pushArgs = pushArgsFor(plan)
+  const rebaseRef = plan.kind === 'upstream' ? plan.upstreamRef : `${plan.remote}/${plan.branch}`
+  // In the set-upstream case there is no tracking ref yet, so a bare `git fetch`
+  // has no configured remote to default to — fetch the same remote we rebase
+  // onto. The upstream case keeps bare `fetch` (its tracking config resolves it).
+  const fetchArgs = plan.kind === 'upstream' ? ['fetch'] : ['fetch', plan.remote]
+  const pushedKind: BackupResult = { ok: true, kind: plan.kind === 'upstream' ? 'pushed' : 'pushed-set-upstream' }
+  // Credentials ride ONLY on the network calls (push/fetch). The rebase is
+  // local (it replays onto an already-fetched remote-tracking ref), so it runs
+  // token-free like every other local command.
+  const net = { cwd, timeoutMs: NETWORK_TIMEOUT_MS, env: deps.pushEnv }
+
+  const push = await deps.gitSpawn(pushArgs, net)
+  if (push.exitCode === 0) return pushedKind
 
   if (!isNonFastForward(push)) {
     await maybeDiagnose(deps, { cwd, stage: 'push', exitCode: push.exitCode, stderr: push.stderr, stdout: push.stdout })
     return { ok: false, kind: 'push-failed', reason: shortErr(push) }
   }
 
-  const fetch = await deps.gitSpawn(['fetch'], { cwd, timeoutMs: NETWORK_TIMEOUT_MS })
+  const fetch = await deps.gitSpawn(fetchArgs, net)
   if (fetch.exitCode !== 0) {
     await maybeDiagnose(deps, {
       cwd,
@@ -142,7 +202,7 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
     return { ok: false, kind: 'push-failed', reason: `git fetch failed: ${shortErr(fetch)}` }
   }
 
-  const rebase = await deps.gitSpawn(['rebase', upstreamRef], { cwd, timeoutMs: NETWORK_TIMEOUT_MS })
+  const rebase = await deps.gitSpawn(['rebase', rebaseRef], { cwd, timeoutMs: NETWORK_TIMEOUT_MS })
   if (rebase.exitCode !== 0) {
     await deps.gitSpawn(['rebase', '--abort'], { cwd, timeoutMs: COMMIT_TIMEOUT_MS })
     await maybeDiagnose(deps, {
@@ -155,7 +215,7 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
     return { ok: false, kind: 'rebase-failed', reason: `git rebase failed: ${shortErr(rebase)}` }
   }
 
-  const push2 = await deps.gitSpawn(['push'], { cwd, timeoutMs: NETWORK_TIMEOUT_MS })
+  const push2 = await deps.gitSpawn(pushArgs, net)
   if (push2.exitCode !== 0) {
     await maybeDiagnose(deps, {
       cwd,
@@ -169,6 +229,13 @@ export async function runBackup(options: BackupRunnerOptions, deps: BackupRunner
   return { ok: true, kind: 'rebased-and-pushed' }
 }
 
+function pushArgsFor(plan: ActivePushPlan): string[] {
+  if (plan.kind === 'upstream') return ['push']
+  // `HEAD:<branch>` is explicit about pushing the current commit to the named
+  // remote branch, avoiding any reliance on local refspec defaults.
+  return ['push', '-u', plan.remote, `HEAD:${plan.branch}`]
+}
+
 async function maybeDiagnose(deps: BackupRunnerDeps, input: BackupFailureInput): Promise<void> {
   if (!deps.diagnoseFailure) return
   try {
@@ -217,7 +284,7 @@ function sanitizeCommitMessage(raw: string): string {
 }
 
 export function makeDefaultGitSpawn(): GitSpawn {
-  return withIndexLockRetry(async (args, { cwd, timeoutMs }) => {
+  return withIndexLockRetry(async (args, { cwd, timeoutMs, env }) => {
     const bun = (globalThis as { Bun?: { spawn: typeof Bun.spawn } }).Bun
     if (!bun) {
       return { exitCode: 127, stdout: '', stderr: 'Bun runtime not available', timedOut: false }
@@ -225,12 +292,15 @@ export function makeDefaultGitSpawn(): GitSpawn {
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), timeoutMs)
     try {
+      // Per-call `env` (credentials for push/fetch) is applied LAST so its
+      // GIT_TERMINAL_PROMPT wins; NONINTERACTIVE_ENV's pager/GCM settings still
+      // apply to every call. Local commands pass no `env` and stay token-free.
       const proc = bun.spawn({
         cmd: ['git', ...args],
         cwd,
         stdout: 'pipe',
         stderr: 'pipe',
-        env: { ...process.env, ...NONINTERACTIVE_ENV },
+        env: { ...process.env, ...NONINTERACTIVE_ENV, ...env },
         signal: controller.signal,
       })
       const exitCode = await proc.exited

package/src/channels/adapters/discord-bot-reactions.ts

@@ -75,6 +75,7 @@ const EMOJI_UNICODE: Record<string, string> = {
   fire: '🔥',
   eye: '👁️',
   raised_hands: '🙌',
+  zipper_mouth_face: '🤐',
 }
 
 function resolveEmoji(emoji: string): string | null {

package/src/channels/manager.ts

@@ -297,10 +297,22 @@ export function createChannelManager(options: ChannelManagerOptions): ChannelMan
 
     async start(): Promise<void> {
       const cfg = options.channelsConfigRef()
-      for (const name of ADAPTER_IDS) {
+      // Safe to fan out: `live` and every router registry are keyed by adapter
+      // name, so concurrent starts never collide. Serial start would otherwise pay
+      // the sum of each adapter's connect latency instead of just the slowest.
+      const starts = ADAPTER_IDS.flatMap((name) => {
         const adapterCfg = cfg[name]
-        if (adapterCfg !== undefined) await runSerially(name, () => startAdapter(name, adapterCfg))
-      }
+        return adapterCfg === undefined ? [] : [runSerially(name, () => startAdapter(name, adapterCfg))]
+      })
+      // Await every launched start to settle BEFORE surfacing a failure.
+      // `startAdapter` converts expected per-adapter failures to `false`, so a
+      // rejection is an unexpected throw (e.g. `buildAdapter`) that must still
+      // fail-fast. But bailing on the first rejection (plain `Promise.all`) would
+      // leave sibling starts in flight, letting a late `live.set` orphan an adapter
+      // that the caller's subsequent `stop()` never sees. Settle all, then rethrow.
+      const results = await Promise.allSettled(starts)
+      const failure = results.find((r): r is PromiseRejectedResult => r.status === 'rejected')
+      if (failure !== undefined) throw failure.reason
     },
 
     async stop(): Promise<void> {