Fixed missing session directory errorPublic

Pi is restoring the session's original cwd from the JSONL header, then chdiring into it.

What happened:

• You launched pi from:
  • /Users/badlogic/workspaces/pi-session-redactor
• The session file you passed contains a header with:
  • cwd: "/Users/user/workspaces/pi-mono"
• During startup, pi does this:
  1. SessionManager.open(...) reads the session header and takes header.cwd
  2. createAgentSessionRuntime(...) calls process.chdir(sessionCwd)
• Node then tries:
  • from /Users/badlogic/workspaces/pi-session-redactor
  • to /Users/user/workspaces/pi-mono
• That target path does not exist on your machine, so Node throws ENOENT

So the key point is this:

--session does not mean "open this file but stay in my current directory". It means "open this session and restore its original working directory".

Why this is especially likely here:

• Your session file is under pi-sessions/redacted/...
• The stored cwd points at /Users/user/...
• That looks like a session copied from another machine or redacted from a different home path

Relevant code paths in packages/coding-agent:

• src/core/session-manager.ts
  • SessionManager.open() reads header.cwd
• src/core/agent-session-runtime.ts
  • createAgentSessionRuntime() does process.chdir(result.services.cwd)

So yes, the behavior is real, not your shell being weird.

Practical workarounds:

1. If you just want to inspect/replay it in your current repo, change the session header cwd to a real local path.
2. If your installed pi supports it, use --fork <session-file> from the directory you want. Forking rewrites the session header to the current cwd.
3. Create the missing path as a symlink, if you want a quick dirty compatibility hack.

What looks wrong in pi itself:

• It should not hard crash on a missing stored cwd
• It should probably either:
  • show a clear error and offer to fork into the current cwd, or
  • fall back to the current cwd for explicit --session loads

If you want, I can point you at the exact patch to make pi handle this gracefully.

You invoked it wrong.

--fork takes an argument. It is not a boolean flag.

So this:

pi --fork --session ./pi-sessions/redacted/2026-01-16T02-23-12-010Z_d7892a86-ae30-4b5d-8bbd-06b3afaba4a0.jsonl

gets parsed as:

• --fork argument = --session
• then pi tries to find a session named --session
• result:
  • No session found matching '--session'

Also, --fork and --session are mutually exclusive.

Use this instead, from the directory you want as the new cwd:

pi --fork ./pi-sessions/redacted/2026-01-16T02-23-12-010Z_d7892a86-ae30-4b5d-8bbd-06b3afaba4a0.jsonl

What that should do:

• open the source session file
• copy it into a new session under your current project
• rewrite the session header cwd to your current directory
• avoid the bad /Users/user/workspaces/pi-mono chdir

So the two errors were different:

1. --session <file>

   • tries to restore original cwd from the session header
   • crashes because that cwd does not exist locally

2. --fork --session <file>

   • invalid CLI usage
   • --session got consumed as the argument to --fork

If pi --fork ./pi-sessions/redacted/...jsonl still fails, paste that output.

Agreed.

Current behavior is wrong in two ways:

• interactive mode hard-crashes inside Node before pi can render anything useful
• non-interactive modes fail via an uncaught chdir path instead of a controlled pi error

Your proposed split makes sense:

Interactive mode

If session header cwd does not exist:

• do not call process.chdir() yet
• start a minimal TUI in current cwd
• show a warning like:
  • session was created in <missing-cwd>
  • that directory does not exist on this machine
  • run in current cwd <process.cwd()>?
• actions:
  • continue in current cwd
  • cancel
  • optionally fork into current cwd if you want to make the state explicit

Print / JSON / RPC modes

Fail deterministically with a pi-managed error, for example:

• print/text mode: human-readable stderr + exit code 1
• json mode: structured error event + nonzero exit
• rpc mode: protocol-level error response, not a Node stack trace

Why this is the right boundary

Interactive mode can ask the user to resolve ambiguity. Non-interactive modes cannot safely guess, especially RPC.

Likely implementation shape

The fix probably belongs before the runtime does process.chdir():

• detect missing sessionManager.getCwd()
• branch on app mode
• interactive:
  • defer cwd switch
  • surface a TUI prompt
  • if accepted, rebuild runtime against current cwd or forked session
• non-interactive:
  • emit controlled error and exit

One subtle point

--session currently means "resume this exact session", including its stored cwd semantics. If interactive mode falls back to current cwd, it should be explicit to the user that this changes path resolution, context discovery, settings, and project-local resources.

So yes, this should be fixed, and your mode split is the right behavior. If you want, I can turn this into a concrete issue description or patch plan.

Because SessionManager.open() is the point where pi turns a session file into runtime state.

Right now that method does this:

• read session header
• take header.cwd
• store it as the session manager's cwd

Everything downstream uses sessionManager.getCwd():

• runtime cwd selection
• project settings lookup
• AGENTS.md/context discovery
• tool path resolution
• footer/title/session metadata

For the fallback behavior, we need:

• keep the same session file
• keep the same session contents
• replace only the effective cwd for this run

An override on SessionManager.open() is the smallest place to express that.

Without it, the alternatives are worse:

1. Add a setCwd() mutator to SessionManager

• more dangerous
• makes cwd mutable after construction
• easier to misuse

2. Reimplement open() logic somewhere else

• duplicates file/header loading logic
• more error-prone

3. Fork/rewrite the session file/header immediately

• changes persisted data when the user only asked to run temporarily in current cwd

So the override is not about session persistence. It is about creating an in-memory SessionManager from an existing file while substituting the effective cwd.

If you want, I can switch it to a separate factory instead, for example:

• SessionManager.open(path, sessionDir?)
• SessionManager.openWithCwd(path, cwd, sessionDir?)

That is a bit clearer than adding a third optional parameter.

Not safely with the current architecture.

What you describe would mean:

• SessionManager.cwd = stored session cwd from header
• services.cwd = current cwd fallback chosen by user

That sounds nice, but pi currently assumes those are the same thing in a lot of places.

Problems if they diverge:

• InteractiveMode uses this.sessionManager.getCwd() for:
  • footer cwd
  • terminal title
  • /resume local session listing
  • bash extension event cwd
  • tool rendering paths
• SessionManager.newSession() and branching/forking use this.cwd when writing new headers
• session metadata and UI would still say the old missing cwd
• some code reads cwd from the runtime, some from the session manager, so behavior becomes inconsistent and hard to reason about

So yes, main can detect the missing cwd and prompt the user. But after the user says yes, we still need one coherent effective cwd object graph for that session runtime.

That means one of these has to happen:

1. create a session manager whose effective cwd is the fallback cwd
2. introduce a new first-class distinction everywhere:
   • stored session cwd
   • effective runtime cwd

Option 2 is architecturally cleaner, but much larger.

Option 1 is why I added the override. It does not rewrite the file. It only says:

• open this session file
• use this effective cwd for this runtime instance

So the override is not to change persistence semantics. It is to keep the runtime internally coherent.

That said, I agree the current API shape is ugly. A third optional arg on open() is not ideal.

Better options:

• SessionManager.openWithCwd(path, cwd, sessionDir?)
• or SessionManager.open(path, { sessionDir, cwdOverride })

That would make the intent explicit.

So the short answer is:

• yes, main should detect and prompt
• no, we should not keep SessionManager on the old cwd while services use a different cwd
• we need a coherent effective cwd after the prompt
• but that does not have to be a bare overrideCwd parameter on open()

If you want, I’ll rework the partial change into SessionManager.openWithCwd(...) instead.

Implemented.

Files changed:

• packages/coding-agent/src/main.ts
• packages/coding-agent/src/core/agent-session-runtime.ts
• packages/coding-agent/src/core/session-manager.ts
• packages/coding-agent/src/modes/interactive/interactive-mode.ts
• packages/coding-agent/src/cli/missing-session-cwd-prompt.ts
• packages/coding-agent/src/core/session-cwd.ts
• packages/coding-agent/test/session-cwd.test.ts

Behavior now:

• Interactive startup:
  • if a session's stored cwd is missing, pi shows a small TUI prompt
  • options are continue in current cwd or cancel
  • if continued, pi reopens the same session with an overridden effective cwd
• Non-interactive startup:
  • print, json, and rpc exit with a controlled error
  • no raw Node chdir crash
• Interactive /resume and /import:
  • same missing-cwd case is caught
  • user can continue in current cwd from inside the TUI

Implementation detail:

• SessionManager.open(..., cwdOverride?) is used to create a coherent runtime with a fallback cwd while keeping the same session file

Validation:

• packages/coding-agent/test/session-cwd.test.ts passed
• npm run check passed

If you want, I can also add a small changelog entry under packages/coding-agent/CHANGELOG.md.

Fixed.

Changes:

• startup prompt is now compact
• interactive fallback prompt uses the same short text

Prompt text:

• cwd from session file does not exist. Continue in current cwd?

Updated files:

• packages/coding-agent/src/core/session-cwd.ts
• packages/coding-agent/src/cli/missing-session-cwd-prompt.ts

Validation:

• npm run check passed

If you still want, I can replace the startup custom prompt with the shared selector-style confirm UI too. Right now it is compact, but still custom.

Done.

Changes:

• removed packages/coding-agent/src/cli/missing-session-cwd-prompt.ts
• startup prompt now reuses ExtensionSelectorComponent
• prompt text now includes both cwd values and stays compact

Current text:

• cwd from session file does not exist
• <stored cwd>
• blank line
• continue in current cwd
• <current cwd>

Validation:

• packages/coding-agent/test/session-cwd.test.ts passed
• npm run check passed

If you want, I can make the two path lines dim so the first line stands out more.

Committed and pushed.

Commit:

• 080af6fc fix(coding-agent): handle missing session cwd