@code-yeongyu/senpi 2026.10.24-3 → 2026.10.24-4

package/dist/core/extensions/builtin/mcp/elicitation.js

@@ -3,9 +3,9 @@
 // The client declares the capability as an EMPTY object — Spring-AI servers
 // reject richer shapes (FieldCoding lesson from the comparison corpus) — and
 // answers elicitation/create requests mid tool-call by walking the requested
-// flat-primitive schema through sequential ctx.ui primitives (input/select/
-// confirm; NEVER ctx.ui.custom, which is undefined in RPC mode). Without a UI
-// (print mode) the request is declined immediately — spec-correct, no hang.
+// flat-primitive schema through sequential ctx.ui primitives (input/select;
+// NEVER ctx.ui.custom, which is undefined in RPC mode). Without a UI
+// (print mode) the request fails with a processing error, never a user refusal.
 // The whole form is bounded by a timeout that resolves to cancel so a wedged
 // dialog can never wedge the tool-call pipeline. URL mode is deliberately not
 // implemented in v1.
@@ -14,28 +14,46 @@ import { loadMcpSdkTypes } from "./sdk.lazy.js";
 import { safeTimer } from "./wrap.js";
 /** Declared empty on purpose: maximum server compatibility (form mode only). */
 export const MCP_CLIENT_ELICITATION_CAPABILITY = { elicitation: {} };
+export function mcpClientCapabilities(elicitationEnabled = true) {
+    return elicitationEnabled ? MCP_CLIENT_ELICITATION_CAPABILITY : {};
+}
 export const MCP_ELICITATION_TIMEOUT_MS = 5 * 60 * 1000;
 let legacyUiProvider;
 /** Legacy classic-session seam. Session-owned services pass themselves directly. */
 export function setMcpElicitationUiProvider(provider) {
     legacyUiProvider = provider;
 }
+async function rejectElicitation() {
+    const { ErrorCode, McpError } = await loadMcpSdkTypes();
+    throw new McpError(ErrorCode.InternalError, "Elicitation cannot be processed");
+}
 /**
  * Wire the elicitation/create handler onto a fresh client. Async because the
  * request schema comes from the lazily loaded SDK; the caller (`buildMcpClient`
  * in `transport-sdk.ts`) awaits it before any connect, so a mid-call
  * elicitation still cannot race registration.
  */
-export async function configureMcpElicitation(client, owner = legacyUiProvider, timeoutMs = MCP_ELICITATION_TIMEOUT_MS) {
+export async function configureMcpElicitation(client, owner = legacyUiProvider, timeoutMs = MCP_ELICITATION_TIMEOUT_MS, elicitationEnabled = true) {
+    if (!elicitationEnabled) {
+        // The SDK requires an advertised capability for setRequestHandler.
+        // Its public fallback handles unsolicited requests without claiming UI support.
+        const { ErrorCode, McpError } = await loadMcpSdkTypes();
+        client.fallbackRequestHandler = async (request) => {
+            if (request.method === "elicitation/create")
+                return rejectElicitation();
+            throw new McpError(ErrorCode.MethodNotFound, "Method not found");
+        };
+        return;
+    }
     const { ElicitRequestSchema } = await loadMcpSdkTypes();
     client.setRequestHandler(ElicitRequestSchema, async (request) => {
         const params = request.params;
         // URL mode is deliberately unsupported in v1 (form mode only).
         if (!("requestedSchema" in params))
-            return { action: "decline" };
+            return rejectElicitation();
         const ui = typeof owner === "function" ? owner() : owner?.getMcpElicitationUi();
         if (ui === undefined)
-            return { action: "decline" };
+            return rejectElicitation();
         return await runElicitationForm(ui, params.message, params.requestedSchema, timeoutMs);
     });
 }
@@ -61,31 +79,59 @@ async function collectForm(ui, message, requestedSchema) {
     for (const [name, property] of Object.entries(requestedSchema.properties ?? {})) {
         const title = `${message} - ${property.title ?? name}`;
         if (property.type === "boolean") {
-            content[name] = await ui.confirm(title, property.description ?? name);
+            // confirm collapses cancellation into false, including automated RPC replies.
+            // A selection preserves dismissal separately from a human's explicit No.
+            const picked = await ui.select(property.description ? `${title}\n${property.description}` : title, [
+                "Yes",
+                "No",
+            ]);
+            if (picked === undefined)
+                return { action: "cancel" };
+            // The thread gateway also accepts y/n and true/false, ignoring case and whitespace.
+            switch (picked.trim().toLowerCase()) {
+                case "yes":
+                case "y":
+                case "true":
+                    content[name] = true;
+                    break;
+                case "no":
+                case "n":
+                case "false":
+                    content[name] = false;
+                    break;
+                default:
+                    return rejectElicitation();
+            }
             continue;
         }
         if (Array.isArray(property.enum) && property.enum.length > 0) {
             const picked = await ui.select(title, property.enum.map(String));
             if (picked === undefined)
-                return { action: "decline" };
+                return { action: "cancel" };
             content[name] = picked;
             continue;
         }
         const answer = await ui.input(title, property.description);
-        if (answer === undefined || answer.length === 0) {
+        if (answer === undefined)
+            return { action: "cancel" };
+        if (answer.length === 0) {
             if (required.has(name))
-                return { action: "decline" };
+                return rejectElicitation();
             continue;
         }
         if (property.type === "number" || property.type === "integer") {
             const parsed = Number(answer);
             if (!Number.isFinite(parsed))
-                return { action: "decline" };
+                return rejectElicitation();
             content[name] = parsed;
             continue;
         }
         content[name] = answer;
     }
+    // Even a fieldless form needs an explicit submission rather than an automatic accept.
+    if (Object.keys(content).length === 0 && (await ui.select(message, ["Submit"])) !== "Submit") {
+        return { action: "cancel" };
+    }
     return { action: "accept", content };
 }
 //# sourceMappingURL=elicitation.js.map

package/dist/core/extensions/builtin/mcp/index.js

@@ -123,7 +123,7 @@ export function createMcpExtension(service, sessionOwned = true) {
                 }
                 else {
                     // Elicitation (todo 41): point mid-call forms at this session's UI.
-                    service.setMcpElicitationUiProvider(() => ctx.ui);
+                    service.setMcpElicitationUiProvider(() => (ctx.hasUI ? ctx.ui : undefined));
                     await (attachPromise ?? attach({ type: "session_start", reason: "startup" }, ctx));
                 }
                 const skills = preview ? [] : (event.systemPromptOptions.skills ?? []);

package/dist/core/extensions/builtin/mcp/modern/dispatch.js

@@ -1,4 +1,4 @@
-import { configureMcpElicitation, MCP_CLIENT_ELICITATION_CAPABILITY } from "../elicitation.js";
+import { configureMcpElicitation, mcpClientCapabilities } from "../elicitation.js";
 import { ConnectError } from "../errors.js";
 import { loadMcpSdkClient } from "../sdk.lazy.js";
 import { materializeMcpTransport, } from "../transport-sdk.js";
@@ -9,13 +9,10 @@ import { probeStdioTransport } from "./stdio-probe.js";
 import { ModernHttpTransport } from "./transport.js";
 import { MODERN_PROTOCOL_VERSION } from "./wire.js";
 const clientInfo = { name: "senpi-mcp-client", version: "0.0.0" };
-const probeOptions = {
-    clientInfo,
-    clientCapabilities: MCP_CLIENT_ELICITATION_CAPABILITY,
-    supportedVersions: [MODERN_PROTOCOL_VERSION],
-};
 export async function materializeNegotiatedTransport(options, serverName, timeoutMs, signal) {
     signal.throwIfAborted();
+    const clientCapabilities = mcpClientCapabilities(options.elicitationEnabled);
+    const probeOptions = { clientInfo, clientCapabilities, supportedVersions: [MODERN_PROTOCOL_VERSION] };
     const { spec, logger } = options;
     let outcome = { kind: "legacy-fallback" };
     if (spec.kind === "http") {
@@ -32,13 +29,13 @@ export async function materializeNegotiatedTransport(options, serverName, timeou
                 });
             }
             const { Client } = await loadMcpSdkClient();
-            const client = new Client(clientInfo, { capabilities: MCP_CLIENT_ELICITATION_CAPABILITY });
-            await configureMcpElicitation(client, options.elicitationUiProvider);
+            const client = new Client(clientInfo, { capabilities: clientCapabilities });
+            await configureMcpElicitation(client, options.elicitationUiProvider, undefined, options.elicitationEnabled);
             const transport = new ModernSdkBridge(new ModernHttpTransport({
                 url: spec.url,
                 fetch,
                 clientInfo,
-                clientCapabilities: MCP_CLIENT_ELICITATION_CAPABILITY,
+                clientCapabilities,
                 protocolVersion: outcome.version,
             }), outcome.discovery, outcome.version);
             const version = outcome.version;

package/dist/core/extensions/builtin/mcp/service-connection.d.ts

@@ -14,6 +14,7 @@ interface SessionConnectionOptions {
     readonly generation: McpConfigGeneration;
     readonly declared: McpServerDeclaredConfig;
     readonly session: McpSessionOptions;
+    readonly elicitationEnabled: boolean;
     readonly cwd: string;
     readonly ui: McpElicitationUiProvider;
     readonly artifacts: McpOutputArtifacts;

package/dist/core/extensions/builtin/mcp/service-connection.js

@@ -38,6 +38,7 @@ export function createMcpSessionConnection(options) {
         config,
         env: projectPolicy?.initial.env ?? session.env,
         elicitationUiProvider: options.ui,
+        elicitationEnabled: options.elicitationEnabled,
         logger,
         serverName: name,
         ...(renewal === undefined ? {} : { resolveConfig: renewal.resolveConfig, onGenerationChanged: rekey }),

package/dist/core/extensions/builtin/mcp/service.js

@@ -709,6 +709,7 @@ export class McpService {
                     await this.#resyncToLiveSessions(owner);
                 },
                 session: options,
+                elicitationEnabled: declarer.context.mode !== "print" && declarer.context.mode !== "json",
                 cwd: declarer.context.cwd,
                 ui: () => this.getMcpElicitationUi(),
                 artifacts: this.#outputArtifacts,

package/dist/core/extensions/builtin/mcp/transport-sdk.d.ts

@@ -44,6 +44,7 @@ export interface MaterializeMcpTransportOptions {
     readonly logger: McpLogger;
     readonly sink: McpAsyncErrorSink;
     readonly elicitationUiProvider: McpElicitationUiProvider | undefined;
+    readonly elicitationEnabled?: boolean;
     /** Invoked once the stdio child has started, so the caller can capture its pid. */
     readonly onStart: () => void;
 }

package/dist/core/extensions/builtin/mcp/transport-sdk.js

@@ -1,9 +1,9 @@
-import { configureMcpElicitation, MCP_CLIENT_ELICITATION_CAPABILITY, } from "./elicitation.js";
+import { configureMcpElicitation, mcpClientCapabilities } from "./elicitation.js";
 import { ProjectStdioTransport } from "./project-stdio-transport.js";
 import { loadMcpSdkClient, loadMcpSdkStdioTransport, loadMcpSdkStreamableHttpTransport } from "./sdk.lazy.js";
 import { safeOn } from "./wrap.js";
 export async function materializeMcpTransport(options) {
-    const client = await buildMcpClient(options.elicitationUiProvider);
+    const client = await buildMcpClient(options.elicitationUiProvider, options.elicitationEnabled);
     if (options.spec.kind === "stdio")
         return materializeStdio(options.spec, options, client);
     return materializeHttp(options.spec, client);
@@ -48,13 +48,13 @@ async function materializeHttp(spec, client) {
         transport,
     };
 }
-async function buildMcpClient(elicitationUiProvider) {
+async function buildMcpClient(elicitationUiProvider, elicitationEnabled = true) {
     // Elicitation capability is declared EMPTY on purpose (form mode only;
     // Spring-AI servers reject richer shapes) and the create-handler is wired
     // before any connect so mid-call requests never race registration.
     const { Client: McpClient } = await loadMcpSdkClient();
-    const client = new McpClient({ name: "senpi-mcp-client", version: "0.0.0" }, { capabilities: MCP_CLIENT_ELICITATION_CAPABILITY });
-    await configureMcpElicitation(client, elicitationUiProvider);
+    const client = new McpClient({ name: "senpi-mcp-client", version: "0.0.0" }, { capabilities: mcpClientCapabilities(elicitationEnabled) });
+    await configureMcpElicitation(client, elicitationUiProvider, undefined, elicitationEnabled);
     return client;
 }
 // OMP pattern: hand stdio OAuth servers the current access token via env.

package/dist/core/extensions/builtin/mcp/transport.d.ts

@@ -32,6 +32,7 @@ export type CreateMcpTransportOptions = {
     readonly logger: McpLogger;
     readonly env?: Record<string, string | undefined>;
     readonly elicitationUiProvider?: McpElicitationUiProvider;
+    readonly elicitationEnabled?: boolean;
     readonly authProvider?: McpOAuthProvider;
     /** Re-reads a declaring server's references for this transport (senpi#3858). */
     readonly resolveConfig?: () => Promise<McpServerConfig>;

package/dist/core/extensions/builtin/mcp/transport.js

@@ -91,6 +91,7 @@ function createConnection(options, spec, connectTimeoutMs) {
         materialize: async () => {
             const materializeWith = (current) => import("./modern/dispatch.js").then(({ materializeNegotiatedTransport }) => materializeNegotiatedTransport({
                 elicitationUiProvider: options.elicitationUiProvider,
+                elicitationEnabled: options.elicitationEnabled,
                 logger: options.logger,
                 onStart: captureRootPid,
                 sink: asyncErrorSink,

package/dist/core/external-admission.d.ts

@@ -60,6 +60,8 @@ export declare class ExternalAdmission {
     }): InputHold;
     onInputsSettled(listener: () => void): () => void;
     onEmitted(listener: (deliveryId: string) => void): () => void;
+    /** Durable custody will replay this delivery: reserve its id before asynchronous recovery or gateway admission. */
+    restoreQueued(deliveryId: string, isOwned: () => boolean): void;
     /**
      * From here on every `admit` throws `reason` and changes nothing: the runtime is being handed to
      * another writer, so the delivery stays with its sender and is delivered there instead.
@@ -82,8 +84,9 @@ export declare class ExternalAdmission {
      * deliveries may be admitted again - unless the file's last write was refused too.
      */
     observeRunSettled(): void;
-    /** The runtime's queues were cleared: queued deliveries are no longer held. */
+    /** Cleared carriers are no longer held; custody not yet enqueued for recovery still owns its delivery. */
     dropQueued(): void;
+    private releaseRestored;
     private endHold;
     private isBusy;
 }

package/dist/core/external-admission.js

@@ -54,6 +54,13 @@ export class ExternalAdmission {
         this.emittedListeners.add(listener);
         return () => this.emittedListeners.delete(listener);
     }
+    /** Durable custody will replay this delivery: reserve its id before asynchronous recovery or gateway admission. */
+    restoreQueued(deliveryId, isOwned) {
+        if (this.pending.has(deliveryId) || this.emitted.has(deliveryId) || this.failed.has(deliveryId))
+            return;
+        // Recovery chooses the payload's queue lane; this reservation only tracks durable ownership.
+        this.pending.set(deliveryId, isOwned);
+    }
     /**
      * From here on every `admit` throws `reason` and changes nothing: the runtime is being handed to
      * another writer, so the delivery stays with its sender and is delivered there instead.
@@ -79,6 +86,7 @@ export class ExternalAdmission {
             throw new Error(this.closedReason);
         const turn_epoch = this.turnEpochValue;
         const id = input.delivery_id;
+        this.releaseRestored();
         if (this.pending.has(id) || this.emitted.has(id) || this.failed.has(id)) {
             return { kind: "already_admitted", turn_epoch };
         }
@@ -112,6 +120,7 @@ export class ExternalAdmission {
         return { kind: "queued", turn_epoch };
     }
     list() {
+        this.releaseRestored();
         const deliveries = { pending: [...this.pending.keys()], emitted: [...this.emitted] };
         if (this.failed.size === 0)
             return deliveries;
@@ -149,10 +158,17 @@ export class ExternalAdmission {
         if (this.fileTakesWrites)
             this.failed.clear();
     }
-    /** The runtime's queues were cleared: queued deliveries are no longer held. */
+    /** Cleared carriers are no longer held; custody not yet enqueued for recovery still owns its delivery. */
     dropQueued() {
+        this.releaseRestored();
+        for (const [id, lane] of this.pending) {
+            if (lane !== "start" && typeof lane !== "function")
+                this.pending.delete(id);
+        }
+    }
+    releaseRestored() {
         for (const [id, lane] of this.pending) {
-            if (lane !== "start")
+            if (typeof lane === "function" && !lane())
                 this.pending.delete(id);
         }
     }

package/dist/core/lifecycle-session-binding.js

@@ -2,6 +2,7 @@ import { collectGoalLifecycleFacts, onGoalLifecycleChange } from "./extensions/b
 import { goalStoreRef } from "./extensions/builtin/goal/store-ref.js";
 import { collectTurnEndLivenessInput } from "./extensions/builtin/goal/turn-end-liveness-report.js";
 import { StaleExtensionContextError } from "./extensions/stale-context-error.js";
+import { deliveryIdOf } from "./external-admission.js";
 import { consumeLifecycleDelivery, lifecycleDeliveryEntries, messageTicket } from "./lifecycle-delivery.js";
 import { readLifecycleGoal } from "./lifecycle-goal.js";
 import { lifecycleHistory } from "./lifecycle-history.js";
@@ -41,6 +42,25 @@ export class LifecycleSessionBinding {
             },
             readRuntime: () => readLifecycleRuntimeFacts(session),
         });
+        // A crashed receiver may have durable custody but no transcript entry yet. Recovery owns that
+        // delivery already; register it before session_start can let the gateway enqueue a second carrier.
+        const deliveryEntries = session.sessionManager.reduceHistory(lifecycleDeliveryEntries);
+        for (const record of this.controller.obligations.active) {
+            if (record.state !== "queued" || !record.payload || !record.ticketId)
+                continue;
+            const ticketId = record.ticketId;
+            const message = { role: "custom", ...record.payload.message, timestamp: 0 };
+            const deliveryId = deliveryIdOf(message);
+            if (deliveryId === undefined)
+                continue;
+            if (deliveryEntries.has(ticketId))
+                session.externalAdmission.observePersisted(message);
+            else
+                session.externalAdmission.restoreQueued(deliveryId, () => 
+                // Consumption writes the entry before message_end observes it in external admission.
+                session.sessionManager.reduceHistory(lifecycleDeliveryEntries).has(ticketId) ||
+                    this.controller.obligations.active.some((current) => current.ticketId === ticketId && current.state === "queued"));
+        }
         this.unsubscribeHuman = bindLifecycleHumanInput(session, (event) => this.controller.humanInput(event.at));
         this.unsubscribeAdmission = session.externalAdmission.onInputsSettled(() => this.controller.admissionSettled());
         this.unsubscribeGoal = onGoalLifecycleChange(session.sessionManager, (goal) => {

package/dist/core/sdk.js

@@ -315,6 +315,7 @@ export async function createAgentSession(options = {}) {
             const serviceTier = serviceTierForProvider(model.provider, options?.serviceTier ?? resolveRequestServiceTier(model));
             return modelRuntime.streamSimple(model, context, {
                 ...options,
+                cwd,
                 serviceTier,
                 timeoutMs,
                 websocketConnectTimeoutMs,

package/dist/core/session-spawned-by.d.ts

@@ -0,0 +1,4 @@
+import type { SpawnedBy } from "./session-lifecycle-types.ts";
+/** The shared CLI / open_session boundary contract; IDs are opaque, non-empty strings. */
+export declare function isSpawnedBy(value: unknown): value is SpawnedBy;
+//# sourceMappingURL=session-spawned-by.d.ts.map

package/dist/core/session-spawned-by.js

@@ -0,0 +1,16 @@
+/** The shared CLI / open_session boundary contract; IDs are opaque, non-empty strings. */
+export function isSpawnedBy(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        "parentSessionId" in value &&
+        typeof value.parentSessionId === "string" &&
+        value.parentSessionId.length > 0 &&
+        "rootSessionId" in value &&
+        typeof value.rootSessionId === "string" &&
+        value.rootSessionId.length > 0 &&
+        "taskId" in value &&
+        typeof value.taskId === "string" &&
+        value.taskId.length > 0);
+}
+//# sourceMappingURL=session-spawned-by.js.map

package/dist/main.js

@@ -401,8 +401,11 @@ async function sessionCwdOrUndefined(sessionFile) {
     }
 }
 export async function createSessionManager(parsed, cwd, sessionDir, settingsManager, appMode) {
+    if (parsed.spawnedBy && (parsed.session || parsed.resume || parsed.continue || parsed.fork || parsed.rebind)) {
+        console.error(chalk.yellow("Warning: --spawned-by is ignored when resuming or forking a session."));
+    }
     if (parsed.noSession || parsed.help || parsed.listModels !== undefined || parsed.listTips) {
-        return SessionManager.inMemory(cwd, parsed.sessionId !== undefined ? { id: parsed.sessionId } : undefined);
+        return SessionManager.inMemory(cwd, { id: parsed.sessionId, spawnedBy: parsed.spawnedBy });
     }
     if (parsed.fork) {
         if (parsed.sessionId) {
@@ -533,11 +536,13 @@ export async function createSessionManager(parsed, cwd, sessionDir, settingsMana
     if (parsed.sessionId) {
         const existingSession = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
         if (existingSession) {
+            if (parsed.spawnedBy)
+                console.error(chalk.yellow("Warning: --spawned-by is ignored when resuming an existing session."));
             return SessionManager.open(existingSession.path, sessionDir);
         }
         console.error(chalk.yellow(`Warning: No project session found with id '${parsed.sessionId}'; creating a new session with that id.`));
     }
-    return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
+    return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId, spawnedBy: parsed.spawnedBy });
 }
 function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRuntime, settingsManager) {
     const options = {};

package/dist/modes/rpc/session-router-open-profile.js

@@ -1,3 +1,4 @@
+import { isSpawnedBy } from "../../core/session-spawned-by.js";
 import { HOST_DAEMON_DIR_ENV } from "./host-daemon-paths.js";
 import { hostInstanceId } from "./protocol-identity.js";
 import { sessionAutoTitleError, sessionBrowserEngineError, sessionContextError, sessionKindError, sessionPromptSurfaceError, sessionRetryFallbackError, } from "./rpc-input-validation.js";
@@ -6,16 +7,7 @@ import { error } from "./session-router-errors.js";
 /** `open_session.spawnedBy` must name the parent, root and task when present; the open answers `invalid_spawned_by` otherwise. */
 export function invalidSpawnedBy(command) {
     const ancestry = command.spawnedBy;
-    return (ancestry !== undefined &&
-        (typeof ancestry !== "object" ||
-            ancestry === null ||
-            Array.isArray(ancestry) ||
-            typeof ancestry.parentSessionId !== "string" ||
-            ancestry.parentSessionId.length === 0 ||
-            typeof ancestry.rootSessionId !== "string" ||
-            ancestry.rootSessionId.length === 0 ||
-            typeof ancestry.taskId !== "string" ||
-            ancestry.taskId.length === 0));
+    return ancestry !== undefined && !isSpawnedBy(ancestry);
 }
 export function validatedOpenProfile(host, command, options) {
     // A parked session's reopen replays what its park recorded; a field it left empty stays empty

package/docs/usage.md

@@ -232,12 +232,26 @@ cat README.md | senpi -p "Summarize this text"
 | `-c`, `--continue` | Continue the most recent session |
 | `-r`, `--resume` | Browse and select a session |
 | `--session <path\|id>` | Use a specific session file or partial UUID |
+| `--spawned-by <json>` | Set parent, root, and task ancestry on a fresh standalone session |
 | `--fork <path\|id>` | Fork a session file or partial UUID into a new session |
 | `--rebind <path\|id>` | Move a session of this repository, recorded at another path (moved or re-cloned), into this directory and continue it |
 | `--session-dir <dir>` | Custom session storage directory |
 | `--no-session` | Ephemeral mode; do not save |
 | `--name <name>`, `-n <name>` | Set session display name at startup |
 
+To start a standalone child session, pass one JSON object:
+
+```bash
+senpi --mode rpc --spawned-by '{"parentSessionId":"parent","rootSessionId":"root","taskId":"task"}'
+```
+
+All three fields must be non-empty strings; malformed input exits before runtime creation.
+The ancestry is stored in the session header, so `get_state.lifecycle.role` is `child` before
+the first prompt. A fresh session created with `--session-id` also accepts it. Resuming an
+existing ID preserves its header and warns that the flag is ignored. The flag is likewise
+ignored with a warning with `--session`, `--resume`, `--continue`, `--rebind`, or `--fork`.
+Without the flag, new sessions and ordinary forks start as roots.
+
 ### Tool Options
 
 | Option | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.24-3",
+	"version": "2026.10.24-4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -71,9 +71,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.24-3",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.24-3",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.24-3",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.24-4",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.24-4",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.24-4",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "6.0.0",
 		"cross-spawn": "7.0.6",
@@ -92,8 +92,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.306",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.24-3",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.24-3",
+		"@code-yeongyu/senpi-codemode": "2026.10.24-4",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.24-4",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",