infra-kit 0.1.124 → 0.1.126

package/src/.omc/state/sessions/2ccbd177-0d5d-4d4a-ab94-a22464786221/pre-tool-advisory-throttle.json

@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "entries": {
+    "466399dafa2d20f60587180bad0a07358eb7f2bce724df0ff682f038ad33f5ad": {
+      "last_emitted_at_ms": 1782817961585,
+      "message": "Read multiple files in parallel when possible for faster analysis."
+    },
+    "445ed27a3872b681d98190bae61ccb84954e1bc4e140df5370be958dee776b3a": {
+      "last_emitted_at_ms": 1782817799580,
+      "message": "Verify changes work after editing. Test functionality before marking complete."
+    },
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1782817772318,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    },
+    "a353cb6bbc54e52818d87f20d3e405a3b424eea973fb85201083ef0dac4defab": {
+      "last_emitted_at_ms": 1782817459860,
+      "message": "Spawning agent: oh-my-claudecode:executor (opus) | Task: Implement env-autoload bug fixes"
+    }
+  },
+  "updated_at": "2026-06-30T11:12:41.585Z"
+}

package/src/.omc/state/sessions/2ccbd177-0d5d-4d4a-ab94-a22464786221/subagent-tracking-state.json

@@ -0,0 +1,17 @@
+{
+  "agents": [
+    {
+      "agent_id": "aa0bc2493749f11ee",
+      "agent_type": "oh-my-claudecode:executor",
+      "started_at": "2026-06-30T11:04:20.002Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-06-30T11:13:43.458Z",
+      "duration_ms": 563456
+    }
+  ],
+  "total_spawned": 1,
+  "total_completed": 1,
+  "total_failed": 0,
+  "last_updated": "2026-06-30T11:13:43.560Z"
+}

package/src/commands/env-clear/env-clear.ts

@@ -10,6 +10,7 @@ import {
   INFRA_KIT_ENV_CLEARED_VAR,
   INFRA_KIT_ENV_CONFIG_VAR,
   INFRA_KIT_ENV_LOADED_AT_VAR,
+  INFRA_KIT_ENV_PROJECT_ROOT_VAR,
   INFRA_KIT_ENV_PROJECT_VAR,
   atomicWriteFileSync,
   getSessionCacheDir,
@@ -30,6 +31,7 @@ export const buildEnvClearLines = (varNames: string[]): string[] => {
     }),
     `unset ${INFRA_KIT_ENV_CONFIG_VAR}`,
     `unset ${INFRA_KIT_ENV_PROJECT_VAR}`,
+    `unset ${INFRA_KIT_ENV_PROJECT_ROOT_VAR}`,
     `unset ${INFRA_KIT_ENV_LOADED_AT_VAR}`,
     `unset ${INFRA_KIT_ENV_AUTOLOADED_VAR}`,
     `export ${INFRA_KIT_ENV_CLEARED_VAR}='1'`,
@@ -63,7 +65,8 @@ export const envClear = async () => {
   process.stdout.write(`${clearFilePath}\n`)
 
   // Remove env load file so the next env-clear call correctly reports "no env loaded".
-  fs.unlinkSync(envLoadPath)
+  // `force` so concurrent clears don't throw ENOENT when another already removed it.
+  fs.rmSync(envLoadPath, { force: true })
 
   const structuredContent = {
     filePath: clearFilePath,

package/src/commands/env-load/__tests__/env-load.test.ts

@@ -3,8 +3,8 @@ import { describe, expect, it } from 'vitest'
 import {
   DOPPLER_MAX_OUTPUT_BYTES,
   assertDopplerOutputSize,
-  assertValidEnvContent,
   buildEnvLoadFileLines,
+  parseDopplerSecretsJson,
   shellSingleQuote,
 } from '../env-load'
 
@@ -34,68 +34,6 @@ describe('shellSingleQuote', () => {
   })
 })
 
-describe('assertValidEnvContent', () => {
-  it('throws on empty content', () => {
-    expect(() => {
-      return assertValidEnvContent('')
-    }).toThrow(/empty output/)
-  })
-
-  it('throws on whitespace-only content', () => {
-    expect(() => {
-      return assertValidEnvContent('   \n\n  ')
-    }).toThrow(/empty output/)
-  })
-
-  it('accepts a single KEY=value line', () => {
-    expect(() => {
-      return assertValidEnvContent('FOO=bar')
-    }).not.toThrow()
-  })
-
-  it('accepts multiple KEY=value lines', () => {
-    expect(() => {
-      return assertValidEnvContent('FOO=bar\nBAZ=qux\nQUUX=123')
-    }).not.toThrow()
-  })
-
-  it('ignores `set -a` / `set +a` directives', () => {
-    expect(() => {
-      return assertValidEnvContent('set -a\nFOO=bar\nset +a')
-    }).not.toThrow()
-  })
-
-  it('ignores blank lines between KEY=value lines', () => {
-    expect(() => {
-      return assertValidEnvContent('FOO=bar\n\nBAZ=qux')
-    }).not.toThrow()
-  })
-
-  it('throws when first non-blank line is not KEY=value', () => {
-    expect(() => {
-      return assertValidEnvContent('<html>error</html>\nFOO=bar')
-    }).toThrow(/unexpected output/)
-  })
-
-  it('throws when a later line is garbage (not only first-line validation)', () => {
-    expect(() => {
-      return assertValidEnvContent('FOO=bar\n<html>error</html>')
-    }).toThrow(/unexpected output/)
-  })
-
-  it('throws when a line looks like a shell command rather than an assignment', () => {
-    expect(() => {
-      return assertValidEnvContent('FOO=bar\nunset BAR')
-    }).toThrow(/unexpected output/)
-  })
-
-  it('accepts values containing = characters (connection strings)', () => {
-    expect(() => {
-      return assertValidEnvContent('DB_URL=host=db;user=admin\nFOO=bar')
-    }).not.toThrow()
-  })
-})
-
 describe('assertDopplerOutputSize', () => {
   it('accepts empty output (shape is validated separately)', () => {
     expect(() => {
@@ -138,15 +76,27 @@ describe('assertDopplerOutputSize', () => {
 })
 
 describe('buildEnvLoadFileLines', () => {
-  const args = { envContent: 'A=1\nB=2', config: 'dev', project: 'proj', loadedAt: '2026-01-01T00:00:00.000Z' }
-
-  it('wraps the body in set -a / set +a and records config/project/loadedAt', () => {
+  const args = {
+    pairs: [
+      ['A', '1'],
+      ['B', '2'],
+    ] as Array<[string, string]>,
+    config: 'dev',
+    project: 'proj',
+    projectRoot: '/repo',
+    loadedAt: '2026-01-01T00:00:00.000Z',
+  }
+
+  it('wraps the body in set -a / set +a and records config/project/projectRoot/loadedAt', () => {
     const lines = buildEnvLoadFileLines({ ...args, autoLoaded: false })
 
     expect(lines[0]).toBe('set -a')
     expect(lines.at(-1)).toBe('set +a')
+    expect(lines).toContain("A='1'")
+    expect(lines).toContain("B='2'")
     expect(lines).toContain("INFRA_KIT_ENV_CONFIG='dev'")
     expect(lines).toContain("INFRA_KIT_ENV_PROJECT='proj'")
+    expect(lines).toContain("INFRA_KIT_ENV_PROJECT_ROOT='/repo'")
     expect(lines).toContain("INFRA_KIT_ENV_LOADED_AT='2026-01-01T00:00:00.000Z'")
   })
 
@@ -165,3 +115,86 @@ describe('buildEnvLoadFileLines', () => {
     expect(lines).not.toContain("INFRA_KIT_ENV_AUTOLOADED='1'")
   })
 })
+
+describe('buildEnvLoadFileLines — injection neutralization (single-quoting)', () => {
+  const baseArgs = {
+    config: 'dev',
+    project: 'proj',
+    projectRoot: '/repo',
+    loadedAt: '2026-01-01T00:00:00.000Z',
+    autoLoaded: false as const,
+  }
+
+  it('single-quotes shell-active values so nothing expands or executes on source', () => {
+    const pairs: Array<[string, string]> = [
+      ['CMD', 'a$(id)b'],
+      ['VAR', 'x$HOME'],
+      ['TICK', '`whoami`'],
+      ['Q', "it's"],
+      ['NL', 'line1\nline2'],
+    ]
+
+    const lines = buildEnvLoadFileLines({ ...baseArgs, pairs })
+
+    // Each value line is exactly KEY=<posix-single-quoted value>.
+    expect(lines).toContain("CMD='a$(id)b'")
+    expect(lines).toContain("VAR='x$HOME'")
+    expect(lines).toContain("TICK='`whoami`'")
+    expect(lines).toContain(String.raw`Q='it'\''s'`)
+    // The newline stays literal inside the single quotes.
+    expect(lines).toContain("NL='line1\nline2'")
+
+    // The load-bearing guarantee: no emitted value line carries an unescaped
+    // command substitution, backtick, or a double-quote-wrapped value.
+    const valueLines = lines.filter((line) => {
+      return /^(?:CMD|VAR|TICK|Q|NL)=/.test(line)
+    })
+
+    for (const line of valueLines) {
+      const value = line.slice(line.indexOf('=') + 1)
+
+      expect(value.startsWith("'")).toBe(true)
+      expect(value.endsWith("'")).toBe(true)
+      expect(value).not.toMatch(/^"/)
+    }
+  })
+})
+
+describe('parseDopplerSecretsJson', () => {
+  it('parses a flat KEY:value object into ordered pairs (values returned raw)', () => {
+    expect(parseDopplerSecretsJson('{"FOO":"bar","BAZ":"a$(x)"}')).toEqual([
+      ['FOO', 'bar'],
+      ['BAZ', 'a$(x)'],
+    ])
+  })
+
+  it('throws on non-JSON output', () => {
+    expect(() => {
+      return parseDopplerSecretsJson('<html>nope</html>')
+    }).toThrow(/non-JSON output/)
+  })
+
+  it('throws on a JSON array (wrong shape)', () => {
+    expect(() => {
+      return parseDopplerSecretsJson('["FOO","bar"]')
+    }).toThrow(/unexpected JSON shape/)
+  })
+
+  it('throws on an empty object', () => {
+    expect(() => {
+      return parseDopplerSecretsJson('{}')
+    }).toThrow(/empty output/)
+  })
+
+  it('throws on an invalid env var name', () => {
+    expect(() => {
+      return parseDopplerSecretsJson('{"1BAD":"x"}')
+    }).toThrow(/invalid env var name/)
+  })
+
+  it('throws on a non-string value', () => {
+    expect(() => {
+      return parseDopplerSecretsJson('{"FOO":123}')
+    }).toThrow(/non-string value/)
+  })
+})

package/src/commands/env-load/env-load.ts

@@ -17,16 +17,17 @@ import {
 import { commandEcho } from 'src/lib/command-echo'
 import {
   ENV_LOAD_FILE,
-  ENV_VAR_LINE_PATTERN,
   INFRA_KIT_ENV_AUTOLOADED_VAR,
   INFRA_KIT_ENV_CLEARED_VAR,
   INFRA_KIT_ENV_CONFIG_VAR,
   INFRA_KIT_ENV_LOADED_AT_VAR,
+  INFRA_KIT_ENV_PROJECT_ROOT_VAR,
   INFRA_KIT_ENV_PROJECT_VAR,
   atomicWriteFileSync,
   getSessionCacheDir,
 } from 'src/lib/constants'
 import { extractStderr } from 'src/lib/errors/operation-error'
+import { getProjectRoot } from 'src/lib/git-utils'
 import { getInfraKitConfig } from 'src/lib/infra-kit-config'
 import { defineMcpTool, textContent } from 'src/types'
 
@@ -43,6 +44,12 @@ interface WriteEnvLoadFileArgs {
    * marker and lifts any clear suppression so a deliberate load wins.
    */
   autoLoaded?: boolean
+  /**
+   * Auto-load only: re-checked AFTER the Doppler download, immediately before the
+   * atomic write. Return false to abort (a clear or a manual load landed during the
+   * slow download). Manual loads omit it and always write.
+   */
+  beforeWrite?: () => boolean
 }
 
 export interface EnvLoadFileResult {
@@ -53,9 +60,10 @@ export interface EnvLoadFileResult {
 }
 
 interface EnvLoadFileLinesArgs {
-  envContent: string
+  pairs: Array<[string, string]>
   config: string
   project: string
+  projectRoot: string
   loadedAt: string
   autoLoaded: boolean
 }
@@ -84,23 +92,41 @@ const buildAutoLoadMarkerLines = (autoLoaded: boolean): string[] => {
  * assignment when the file is sourced.
  */
 export const buildEnvLoadFileLines = ({
-  envContent,
+  pairs,
   config,
   project,
+  projectRoot,
   loadedAt,
   autoLoaded,
 }: EnvLoadFileLinesArgs): string[] => {
   return [
     'set -a',
-    envContent,
+    ...pairs.map(([key, value]) => {
+      return `${key}=${shellSingleQuote(value)}`
+    }),
     `${INFRA_KIT_ENV_CONFIG_VAR}=${shellSingleQuote(config)}`,
     `${INFRA_KIT_ENV_PROJECT_VAR}=${shellSingleQuote(project)}`,
+    `${INFRA_KIT_ENV_PROJECT_ROOT_VAR}=${shellSingleQuote(projectRoot)}`,
     `${INFRA_KIT_ENV_LOADED_AT_VAR}=${shellSingleQuote(loadedAt)}`,
     ...buildAutoLoadMarkerLines(autoLoaded),
     'set +a',
   ]
 }
 
+/**
+ * Project root (git top-level) the loaded env belongs to, for the cross-project
+ * shell gate. Returns '' when this isn't a git checkout so a non-git infra-kit
+ * project still loads — the shell gate then fails open (spawns rather than skips)
+ * instead of breaking the whole load on `git rev-parse` throwing.
+ */
+const resolveProjectRootSafe = async (): Promise<string> => {
+  try {
+    return await getProjectRoot()
+  } catch {
+    return ''
+  }
+}
+
 /**
  * Download Doppler secrets for a resolved config and atomically write env-load.sh
  * to the session cache dir. Does NOT print to stdout — shared by the CLI/MCP
@@ -110,27 +136,31 @@ export const buildEnvLoadFileLines = ({
 export const writeEnvLoadFile = async ({
   config,
   autoLoaded = false,
-}: WriteEnvLoadFileArgs): Promise<EnvLoadFileResult> => {
+  beforeWrite,
+}: WriteEnvLoadFileArgs): Promise<EnvLoadFileResult | null> => {
   await validateDopplerCliAndAuth()
 
   const project = await getDopplerProject()
+  const projectRoot = await resolveProjectRootSafe()
 
-  const envContent = await downloadDopplerSecrets(project, config)
-
-  assertValidEnvContent(envContent)
+  const pairs = await downloadDopplerSecrets(project, config)
 
   const loadedAt = new Date().toISOString()
-  const envFileLines = buildEnvLoadFileLines({ envContent, config, project, loadedAt, autoLoaded })
+  const envFileLines = buildEnvLoadFileLines({ pairs, config, project, projectRoot, loadedAt, autoLoaded })
 
   const cacheDir = getSessionCacheDir()
   const envFilePath = path.resolve(cacheDir, ENV_LOAD_FILE)
 
+  // Re-check suppression immediately before the atomic write: a clear or a manual
+  // load may have landed during the slow Doppler download (auto-load path only).
+  if (beforeWrite && !beforeWrite()) return null
+
   fs.mkdirSync(cacheDir, { recursive: true, mode: 0o700 })
   atomicWriteFileSync(envFilePath, `${envFileLines.join('\n')}\n`, 0o600)
 
   return {
     filePath: envFilePath,
-    variableCount: countEnvVarLines(envContent),
+    variableCount: pairs.length,
     project,
     config,
   }
@@ -175,6 +205,10 @@ export const envLoad = async (args: EnvLoadArgs) => {
   // A manual load is authoritative: autoLoaded=false drops the auto marker.
   const result = await writeEnvLoadFile({ config: selectedConfig, autoLoaded: false })
 
+  // A manual load passes no beforeWrite, so it always writes — this guards the
+  // invariant (and narrows the nullable result) rather than handling a real path.
+  if (!result) throw new Error('env-load: write was unexpectedly aborted')
+
   // REQUIRED
   process.stdout.write(`${result.filePath}\n`)
 
@@ -209,7 +243,7 @@ export const DOPPLER_MAX_OUTPUT_BYTES = 1024 * 1024
  */
 const DOPPLER_DOWNLOAD_TIMEOUT_MS = 30_000
 
-const downloadDopplerSecrets = async (project: string, config: string): Promise<string> => {
+const downloadDopplerSecrets = async (project: string, config: string): Promise<Array<[string, string]>> => {
   const prevQuiet = $.quiet
 
   $.quiet = true
@@ -217,16 +251,17 @@ const downloadDopplerSecrets = async (project: string, config: string): Promise<
     let result
 
     try {
-      result = await $`doppler secrets download --no-file --format env --project ${project} --config ${config}`.timeout(
-        DOPPLER_DOWNLOAD_TIMEOUT_MS,
-      )
+      result =
+        await $`doppler secrets download --no-file --format json --project ${project} --config ${config}`.timeout(
+          DOPPLER_DOWNLOAD_TIMEOUT_MS,
+        )
     } catch (error: unknown) {
       throw await translateDopplerDownloadError(error, project, config)
     }
 
     assertDopplerOutputSize(result.stdout)
 
-    return result.stdout.trim()
+    return parseDopplerSecretsJson(result.stdout)
   } finally {
     $.quiet = prevQuiet
   }
@@ -262,42 +297,59 @@ export const assertDopplerOutputSize = (stdout: string): void => {
   }
 }
 
-const countEnvVarLines = (content: string): number => {
-  return content.split('\n').filter((line) => {
-    return ENV_VAR_LINE_PATTERN.test(line)
-  }).length
-}
-
-const SHELL_DIRECTIVE_LINES = new Set(['set -a', 'set +a'])
-
 export const shellSingleQuote = (value: string): string => {
   const escaped = value.replaceAll("'", "'\\''")
 
   return `'${escaped}'`
 }
 
+/** A valid POSIX env-var name: a letter or underscore, then word characters. */
+const ENV_VAR_NAME_PATTERN = /^[A-Z_]\w*$/i
+
 /**
- * Guard against Doppler returning non-env output (auth warnings on stdout,
- * partial downloads, HTML error pages, etc.). Every non-blank, non-directive
- * line must match KEY=VALUE — skipping directives keeps future format tweaks
- * cheap without loosening the check.
+ * Parse the `doppler secrets download --format json` output (a flat
+ * `{"KEY":"value"}` map) into ordered `[key, value]` pairs, validating the shape
+ * and every name/value. Values are returned RAW — callers must single-quote them
+ * before emitting shell (an unquoted `a$(cmd)b` would execute on `source`).
+ *
+ * @example
+ * parseDopplerSecretsJson('{"FOO":"bar","BAZ":"a$(x)"}')
+ * // => [['FOO', 'bar'], ['BAZ', 'a$(x)']]
  */
-export const assertValidEnvContent = (content: string): void => {
-  if (content.trim().length === 0) {
-    throw new Error('doppler returned empty output for env-load')
+export const parseDopplerSecretsJson = (stdout: string): Array<[string, string]> => {
+  let parsed: unknown
+
+  try {
+    parsed = JSON.parse(stdout)
+  } catch {
+    throw new Error(`doppler returned non-JSON output for env-load (got: ${JSON.stringify(stdout.slice(0, 80))})`)
   }
 
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim()
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('doppler returned unexpected JSON shape for env-load (expected an object of KEY: value pairs)')
+  }
 
-    if (trimmed.length === 0 || SHELL_DIRECTIVE_LINES.has(trimmed)) continue
+  const pairs: Array<[string, string]> = []
 
-    if (!ENV_VAR_LINE_PATTERN.test(trimmed)) {
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!ENV_VAR_NAME_PATTERN.test(key)) {
       throw new Error(
-        `doppler returned unexpected output for env-load (expected KEY=value lines, got: ${JSON.stringify(trimmed.slice(0, 80))})`,
+        `doppler returned an invalid env var name for env-load (got: ${JSON.stringify(key.slice(0, 80))})`,
       )
     }
+
+    if (typeof value !== 'string') {
+      throw new TypeError(`doppler returned a non-string value for "${key}" (got ${typeof value})`)
+    }
+
+    pairs.push([key, value])
   }
+
+  if (pairs.length === 0) {
+    throw new Error('doppler returned empty output for env-load')
+  }
+
+  return pairs
 }
 
 // MCP Tool Registration

package/src/commands/init/__tests__/shell-body.test.ts

@@ -10,14 +10,14 @@ describe('buildShellBody — env auto-load shell-startup block', () => {
     expect(body).toContain('_infra_kit_startup_autoload\n')
   })
 
-  it('gates on a session and skips subshells that already inherited an env', () => {
+  it('gates on a session and skips the spawn only when the env is for THIS project root', () => {
     expect(body).toContain('[[ -z "$INFRA_KIT_SESSION" ]] && return')
-    expect(body).toContain('[[ -n "$INFRA_KIT_ENV_CONFIG" ]] && return')
+    expect(body).toContain('[[ -n "$INFRA_KIT_ENV_CONFIG" && "$dir" == "$INFRA_KIT_ENV_PROJECT_ROOT" ]] && return')
   })
 
-  it('walks up for infra-kit.json (project/worktree gate) before spawning node', () => {
+  it('walks up for infra-kit.json with a fixed-point break (no infinite loop on empty $PWD)', () => {
     expect(body).toContain('[[ -f "$dir/infra-kit.json" ]]')
-    expect(body).toContain('while [[ "$dir" != / ]]')
+    expect(body).toContain('while [[ -n "$dir" && "$dir" != "$prev" ]]')
   })
 
   it('spawns env-autoload backgrounded and silenced (precmd does the sourcing)', () => {

package/src/commands/init/init.ts

@@ -299,23 +299,19 @@ export const buildShellBody = (): string => {
     '  local dir="$cache_root/$INFRA_KIT_SESSION"',
     '  local load_file="$dir/env-load.sh"',
     '  local clear_file="$dir/env-clear.sh"',
-    '  local mtime',
-    '  if [[ -f "$load_file" ]]; then',
-    '    mtime=$(zstat +mtime -- "$load_file" 2>/dev/null || echo 0)',
-    '    if (( mtime > _INFRA_KIT_LAST_LOAD_MTIME && mtime >= _INFRA_KIT_SHELL_STARTED )); then',
-    '      source "$load_file"',
-    '      _INFRA_KIT_LAST_LOAD_MTIME=$mtime',
+    '  local load_mtime=0 clear_mtime=0',
+    '  [[ -f "$load_file" ]] && load_mtime=$(zstat +mtime -- "$load_file" 2>/dev/null || echo 0)',
+    '  [[ -f "$clear_file" ]] && clear_mtime=$(zstat +mtime -- "$clear_file" 2>/dev/null || echo 0)',
+    '  if (( load_mtime > _INFRA_KIT_LAST_LOAD_MTIME && load_mtime >= _INFRA_KIT_SHELL_STARTED && load_mtime >= clear_mtime )); then',
+    '    source "$load_file"',
+    '    _INFRA_KIT_LAST_LOAD_MTIME=$load_mtime',
     // eslint-disable-next-line no-template-curly-in-string
-    '      print -u2 "infra-kit: auto-loaded vars for ${INFRA_KIT_ENV_CONFIG:-?}"',
-    '    fi',
+    '    print -u2 "infra-kit: auto-loaded vars for ${INFRA_KIT_ENV_CONFIG:-?}"',
     '  fi',
-    '  if [[ -f "$clear_file" ]]; then',
-    '    mtime=$(zstat +mtime -- "$clear_file" 2>/dev/null || echo 0)',
-    '    if (( mtime > _INFRA_KIT_LAST_CLEAR_MTIME && mtime >= _INFRA_KIT_SHELL_STARTED )); then',
-    '      source "$clear_file"',
-    '      _INFRA_KIT_LAST_CLEAR_MTIME=$mtime',
-    '      print -u2 "infra-kit: auto-cleared env"',
-    '    fi',
+    '  if (( clear_mtime > _INFRA_KIT_LAST_CLEAR_MTIME && clear_mtime >= _INFRA_KIT_SHELL_STARTED && clear_mtime > load_mtime )); then',
+    '    source "$clear_file"',
+    '    _INFRA_KIT_LAST_CLEAR_MTIME=$clear_mtime',
+    '    print -u2 "infra-kit: auto-cleared env"',
     '  fi',
     '}',
     'autoload -Uz add-zsh-hook',
@@ -325,21 +321,24 @@ export const buildShellBody = (): string => {
     // One-shot env auto-load when a NEW shell opens inside an infra-kit project
     // or worktree (config: envAutoLoad.trigger "shell-startup"). Cheap pure-zsh
     // project gate (walk up for infra-kit.json) avoids spawning node in unrelated
-    // shells; the INFRA_KIT_ENV_CONFIG guard skips subshells that already inherited
-    // a loaded env. The spawn is DETACHED+backgrounded ( ... & ) so it never blocks
-    // the prompt; it only WRITES env-load.sh and the precmd hook above is the sole
-    // sourcer (picked up on a subsequent prompt). Trade-off: the gate can't read the
-    // merged JSON config, so a fresh shell in a project WITHOUT envAutoLoad still
-    // spawns one background process that resolves config, finds nothing, and exits.
+    // shells; the spawn is skipped only when the already-loaded env belongs to THIS
+    // project root (INFRA_KIT_ENV_PROJECT_ROOT), so cd'ing into a DIFFERENT project
+    // re-loads instead of silently keeping the previous project's secrets. The spawn
+    // is DETACHED+backgrounded ( ... & ) so it never blocks the prompt; it only
+    // WRITES env-load.sh and the precmd hook above is the sole sourcer (picked up on
+    // a subsequent prompt). Trade-off: the gate can't read the merged JSON config, so
+    // a fresh shell in a project WITHOUT envAutoLoad still spawns one background
+    // process that resolves config, finds nothing, and exits.
     '_infra_kit_startup_autoload() {',
     '  [[ -z "$INFRA_KIT_SESSION" ]] && return',
-    '  [[ -n "$INFRA_KIT_ENV_CONFIG" ]] && return',
-    '  local dir="$PWD"',
-    '  while [[ "$dir" != / ]]; do',
+    '  local dir="$PWD" prev=""',
+    '  while [[ -n "$dir" && "$dir" != "$prev" ]]; do',
     '    if [[ -f "$dir/infra-kit.json" ]]; then',
+    '      [[ -n "$INFRA_KIT_ENV_CONFIG" && "$dir" == "$INFRA_KIT_ENV_PROJECT_ROOT" ]] && return',
     `      ( ${runCmd} env-autoload & ) >/dev/null 2>&1`,
     '      return',
     '    fi',
+    '    prev="$dir"',
     // eslint-disable-next-line no-template-curly-in-string
     '    dir="${dir:h}"',
     '  done',

package/src/commands/worktrees-add/worktrees-add.ts

@@ -16,6 +16,7 @@ import { IDE_MODES, addIdeWorktreeFolders } from 'src/integrations/ide'
 import type { IdeMode } from 'src/integrations/ide'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
+import { isPromptCancellation } from 'src/lib/errors/is-prompt-cancellation'
 import { OperationError } from 'src/lib/errors/operation-error'
 import { assertManagementContext } from 'src/lib/git-guard'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
@@ -225,6 +226,11 @@ export const worktreesAdd = async (options: WorktreeManagementArgs) => {
       structuredContent,
     }
   } catch (error) {
+    // A cancelled prompt (Ctrl-C / Esc) is a user back-out, not a failure: let it
+    // reach the top-level boundary untouched so it exits cleanly, instead of being
+    // logged as an error with a misleading "branches already exist" remediation.
+    if (isPromptCancellation(error)) throw error
+
     logger.error({ error }, '❌ Error managing worktrees')
     throw new OperationError(error, {
       operation: 'create worktrees',

package/src/commands/worktrees-remove/worktrees-remove.ts

@@ -7,6 +7,7 @@ import { getReleasePRsWithInfo } from 'src/integrations/gh'
 import { removeIdeWorktreeFolders } from 'src/integrations/ide'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
+import { isPromptCancellation } from 'src/lib/errors/is-prompt-cancellation'
 import { OperationError } from 'src/lib/errors/operation-error'
 import { assertManagementContext } from 'src/lib/git-guard'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
@@ -143,6 +144,11 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
       structuredContent,
     }
   } catch (error) {
+    // A cancelled prompt (Ctrl-C / Esc) is a user back-out, not a failure: let it
+    // reach the top-level boundary untouched so it exits cleanly, instead of being
+    // logged as an error with a misleading remediation.
+    if (isPromptCancellation(error)) throw error
+
     logger.error({ error }, '❌ Error managing worktrees')
     throw new OperationError(error, {
       operation: 'remove worktrees',

package/src/commands/worktrees-sync/worktrees-sync.ts

@@ -8,6 +8,7 @@ import { getReleasePRs } from 'src/integrations/gh'
 import { removeIdeWorktreeFolders } from 'src/integrations/ide'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
+import { isPromptCancellation } from 'src/lib/errors/is-prompt-cancellation'
 import { OperationError } from 'src/lib/errors/operation-error'
 import { assertManagementContext } from 'src/lib/git-guard'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
@@ -96,6 +97,11 @@ export const worktreesSync = async (options: WorktreeSyncArgs) => {
       structuredContent,
     }
   } catch (error) {
+    // A cancelled prompt (Ctrl-C / Esc) is a user back-out, not a failure: let it
+    // reach the top-level boundary untouched so it exits cleanly, instead of being
+    // logged as an error with a misleading remediation.
+    if (isPromptCancellation(error)) throw error
+
     logger.error({ error }, '❌ Error managing worktrees')
     throw new OperationError(error, {
       operation: 'sync worktrees with remote',