@code-yeongyu/senpi 2026.10.24-3 → 2026.10.25-1

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/core/skill-access.js

@@ -22,15 +22,27 @@ export function insideSkillRoot(path, root) {
 export function buildSkillAllowedSet(sources) {
     const roots = new Set();
     const files = new Set();
-    for (const source of sources) {
+    // Package resolution retains the selected root on every discovered skill.
+    // Walk each spelling once, without collapsing differently ignored aliases.
+    const realpaths = new Map();
+    const realpath = (path) => {
+        let canonical = realpaths.get(path);
+        if (canonical === undefined) {
+            canonical = realpathSync.native(path);
+            realpaths.set(path, canonical);
+        }
+        return canonical;
+    };
+    for (const source of new Set(sources)) {
         try {
-            const canonical = realpathSync.native(source);
+            const canonical = realpath(source);
             if (statSync(canonical).isFile()) {
                 files.add(canonical);
                 continue;
             }
             collectSkillEntries(source, "pi", undefined, undefined, {
-                onDirectory: (path) => roots.add(realpathSync.native(path)),
+                realpath,
+                onDirectory: (path) => roots.add(realpath(path)),
             });
         }
         catch {

package/dist/core/skill-discovery.d.ts

@@ -9,6 +9,8 @@ export interface SkillWalkOptions {
     readonly allowedSet?: SkillAllowedSet;
     readonly ancestry?: ReadonlySet<string>;
     readonly onDirectory?: (path: string) => void;
+    /** Optional cache owned by a single discovery pass, never retained on a Skill. */
+    readonly realpath?: (path: string) => string;
 }
 export declare function shouldSkipSkillWalkDirectoryName(name: string): boolean;
 /**

package/dist/core/skill-discovery.js

@@ -117,7 +117,7 @@ export function collectSkillEntries(dir, mode, ignoreMatcher, rootDir, options =
     let canonical;
     try {
         authorizeSkillPath(dir, options.provenance, options.allowedSet, true);
-        canonical = realpathSync.native(dir);
+        canonical = (options.realpath ?? realpathSync.native)(dir);
     }
     catch (error) {
         // Leave a blocked root as a candidate so the resource loader retains its

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.25-1",
 	"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.25-1",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.25-1",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.25-1",
 		"@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.25-1",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.25-1",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",