@sayknow-cli/coding-agent 0.5.1 → 0.5.6

package/src/session-import/types.ts

@@ -0,0 +1,163 @@
+/**
+ * Provider-neutral session-import contract (issue #3709).
+ *
+ * An import accepts ONE explicit user-selected Codex or Claude transcript/export
+ * file, normalizes it into the intermediate representation below, and rebuilds a
+ * bounded, redacted continuation context in one workspace-scoped native SKC
+ * session. A verified identical import is reused; otherwise a new session is
+ * published. The source file is only ever read; provider process state is never scraped.
+ */
+
+/** Providers with a first-party observable transcript/export format. */
+export type SessionImportProviderId = "codex" | "claude";
+
+/** Concrete on-disk format variants the adapters understand. */
+export type SessionImportFormatId = "codex-rollout-jsonl" | "claude-code-jsonl" | "claude-export-json";
+
+/** Maximum quarantined-record digests retained in memory during import. */
+export const SESSION_IMPORT_QUARANTINE_MAX_RECORDS = 512;
+
+/** One normalized conversational unit produced by a provider adapter. */
+export interface ImportedMessage {
+	/** Conversational role. Tool evidence is attached to assistant turns. */
+	role: "user" | "assistant";
+	/** Visible text (may be empty when only tool evidence exists). */
+	text: string;
+	/** ISO-8601 source timestamp when the record carried one. */
+	timestamp?: string;
+	/**
+	 * Bounded, already redacted tool/file evidence lines (e.g. `$ ls` → `ok`).
+	 * Rendered inline after the text so completed work stays visible.
+	 */
+	toolEvidence?: string[];
+}
+
+/** Provider-neutral normalized conversation. */
+export interface ImportedConversation {
+	provider: SessionImportProviderId;
+	format: SessionImportFormatId;
+	/** Source-side session/conversation identifier when the format carries one. */
+	sourceSessionId?: string;
+	/** Source title when the format carries one. */
+	title?: string;
+	/** Source workspace cwd when the format carries one. */
+	cwd?: string;
+	messages: ImportedMessage[];
+}
+
+/** Deterministic, actionable import failure codes. */
+export type SessionImportErrorCode =
+	| "invalid_request"
+	| "source_not_found"
+	| "source_unreadable"
+	| "source_changed"
+	| "unsupported_format"
+	| "format_mismatch"
+	| "malformed_input"
+	| "content_too_large"
+	| "destination_conflict"
+	| "io_failed";
+
+/** Import pipeline phase a failure belongs to. */
+export type SessionImportPhase =
+	| "request"
+	| "read"
+	| "detect"
+	| "parse"
+	| "normalize"
+	| "persist"
+	| "cleanup"
+	| "switch";
+
+export class SessionImportError extends Error {
+	readonly code: SessionImportErrorCode;
+	readonly phase: SessionImportPhase;
+	readonly retryable: boolean;
+	readonly limitBytes?: number;
+	readonly observedBytes?: number;
+
+	constructor(
+		code: SessionImportErrorCode,
+		phase: SessionImportPhase,
+		message: string,
+		options?: { retryable?: boolean; limitBytes?: number; observedBytes?: number },
+	) {
+		super(message);
+		this.name = "SessionImportError";
+		this.code = code;
+		this.phase = phase;
+		this.retryable = options?.retryable ?? false;
+		this.limitBytes = options?.limitBytes;
+		this.observedBytes = options?.observedBytes;
+	}
+}
+
+/** One record the adapter could not map. Never carries raw content. */
+export interface ImportQuarantineRecord {
+	/** 1-based record/line number in the source. */
+	record: number;
+	byteLength: number;
+	sha256: string;
+	reason: "invalid_json" | "unknown_record" | "missing_fields" | "oversized_record";
+}
+
+/** Bounded tallies reported to the user and persisted in provenance. */
+export interface SessionImportCounts {
+	/** Records successfully mapped into the normalized conversation. */
+	mapped: number;
+	/** Records quarantined (never silently dropped). */
+	quarantined: number;
+	/** Secret/credential redactions applied to imported text. */
+	redacted: number;
+	/** Messages omitted from the rendered context by head/tail bounding. */
+	omitted: number;
+}
+
+/** Provenance persisted as a `custom` session entry on the import target. */
+export interface SessionImportProvenance {
+	schemaVersion: 1;
+	customType: "session-import";
+	provider: SessionImportProviderId;
+	format: SessionImportFormatId;
+	/** Basename of the explicit user-selected source file (never a full path). */
+	sourceFileName: string;
+	sourceSessionId?: string;
+	sourceTitle?: string;
+	/** SHA-256 over the exact source bytes that were imported. */
+	sourceSha256: string;
+	sourceBytes: number;
+	/** RFC 4122 UUID of the SKC session that received the import. */
+	targetSessionId: string;
+	importedAt: string;
+	converterVersion: number;
+	sanitizerVersion: number;
+	counts: SessionImportCounts;
+	/** True when head/tail bounding elided part of the conversation. */
+	truncated: boolean;
+	quarantine: { present: boolean; truncated: boolean };
+}
+
+/** Fully prepared import: parsed, normalized, redacted, bounded. No session state mutated yet. */
+export interface PreparedSessionImport {
+	conversation: ImportedConversation;
+	/** Rendered continuation context for the `custom_message` entry. */
+	contextText: string;
+	provenance: Omit<SessionImportProvenance, "targetSessionId" | "importedAt">;
+	counts: SessionImportCounts;
+	/** Distinct redaction pattern ids that fired (for the user-facing summary). */
+	redactionKinds: string[];
+	/** Bounded digest-only records for durable quarantine metadata. */
+	quarantineRecords: ImportQuarantineRecord[];
+	sourceSha256: string;
+	sourceBytes: number;
+}
+
+/** Result of a completed or idempotently reused imported session. */
+export interface SessionImportCompleted {
+	targetSessionId: string;
+	targetPath: string;
+	title: string;
+	prepared: PreparedSessionImport;
+	/** True when the same source/version import already existed in this workspace. */
+	reused: boolean;
+}

package/src/skc-runtime/boot-generation.ts

@@ -0,0 +1,172 @@
+/**
+ * Boot-generation evidence for reboot-only session restore.
+ *
+ * Restore exists to survive a reboot, and only a reboot. The eligibility rule is
+ * therefore narrow on purpose: a session may be restored only when the recorded
+ * and current boot values come from the SAME source and differ. Anything else —
+ * equal values, a missing or malformed record, an unreadable probe, or two
+ * different sources — is inconclusive and must never spawn.
+ *
+ * The same-source requirement is not pedantry. Linux can report `boot-id` at
+ * record time and fall back to `proc-btime` later; those two values are always
+ * unequal even on one boot, so comparing across sources would read every launch
+ * as a reboot and duplicate live sessions.
+ */
+
+import * as fsSync from "node:fs";
+
+/** Where a boot value came from. Values are only ever compared within one source. */
+export type BootGenerationSource = "darwin-kern-boottime" | "linux-boot-id" | "linux-proc-btime" | "unavailable";
+
+export interface BootGeneration {
+	source: BootGenerationSource;
+	/** Opaque; only equality within the same source is meaningful. */
+	value: string | null;
+}
+
+export type BootComparison = "changed" | "same_boot" | "boot_unknown";
+
+const BOOT_GENERATION_SCHEMA_VERSION = 1;
+
+export interface RecordedBootGeneration {
+	schema_version: number;
+	source: string;
+	value: string;
+}
+
+export interface BootGenerationProbeDeps {
+	platform?: NodeJS.Platform;
+	readFile?: (file: string) => string;
+	runCommand?: (command: string, args: string[]) => { exitCode: number | null; stdout: string };
+}
+
+function defaultReadFile(file: string): string {
+	return fsSync.readFileSync(file, "utf8");
+}
+
+function defaultRunCommand(command: string, args: string[]): { exitCode: number | null; stdout: string } {
+	const result = Bun.spawnSync({ cmd: [command, ...args], stdout: "pipe", stderr: "ignore" });
+	return { exitCode: result.exitCode, stdout: result.stdout.toString() };
+}
+
+/** `{ sec = 1785305532, usec = 377197 } Wed Jul 29 ...` -> `1785305532.377197`. */
+export function parseDarwinBootTime(raw: string): string | null {
+	const match = /sec\s*=\s*(\d+)\s*,\s*usec\s*=\s*(\d+)/u.exec(raw);
+	if (!match) return null;
+	const sec = match[1];
+	const usec = match[2];
+	if (!sec || !usec) return null;
+	// A microsecond field at or above 1e6 is not a time this kernel produced;
+	// accepting it would let a malformed reading masquerade as a distinct boot.
+	if (Number.parseInt(usec, 10) >= 1_000_000) return null;
+	return `${sec}.${usec.padStart(6, "0")}`;
+}
+
+/** A boot id is a UUID that changes on every boot; anything else is not usable. */
+export function parseLinuxBootId(raw: string): string | null {
+	const value = raw.trim();
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u.test(value) ? value : null;
+}
+
+/** `/proc/stat` carries `btime <seconds>` once, as the kernel boot wall-clock. */
+export function parseLinuxProcBtime(raw: string): string | null {
+	const values: string[] = [];
+	for (const line of raw.split("\n")) {
+		const match = /^btime\s+(\d+)\s*$/u.exec(line);
+		if (match?.[1]) values.push(match[1]);
+	}
+	// The kernel reports btime exactly once. More than one means the input is not
+	// a `/proc/stat` we can reason about, so refuse rather than pick one.
+	return values.length === 1 ? (values[0] ?? null) : null;
+}
+
+/**
+ * Reads the strongest boot evidence this platform offers.
+ *
+ * Windows returns `unavailable`: restore is unsupported there (no immutable
+ * native tmux session identity), so there is nothing to gate.
+ */
+export function readBootGeneration(deps: BootGenerationProbeDeps = {}): BootGeneration {
+	const platform = deps.platform ?? process.platform;
+	const readFile = deps.readFile ?? defaultReadFile;
+	const runCommand = deps.runCommand ?? defaultRunCommand;
+
+	if (platform === "darwin") {
+		try {
+			const probed = runCommand("sysctl", ["-n", "kern.boottime"]);
+			if (probed.exitCode !== 0) return { source: "unavailable", value: null };
+			const value = parseDarwinBootTime(probed.stdout);
+			return value ? { source: "darwin-kern-boottime", value } : { source: "unavailable", value: null };
+		} catch {
+			return { source: "unavailable", value: null };
+		}
+	}
+
+	if (platform === "linux") {
+		try {
+			const value = parseLinuxBootId(readFile("/proc/sys/kernel/random/boot_id"));
+			if (value) return { source: "linux-boot-id", value };
+		} catch {
+			// Fall through: some hardened kernels hide boot_id.
+		}
+		try {
+			const value = parseLinuxProcBtime(readFile("/proc/stat"));
+			if (value) return { source: "linux-proc-btime", value };
+		} catch {
+			// Fall through to unavailable.
+		}
+		return { source: "unavailable", value: null };
+	}
+
+	return { source: "unavailable", value: null };
+}
+
+/**
+ * Each source produces one exact shape. Validating it is what stops a value that
+ * merely differs textually — trailing space, a zero-width character — from being
+ * read as a different boot.
+ */
+const BOOT_VALUE_SHAPE: Record<string, RegExp> = {
+	"darwin-kern-boottime": /^\d+\.\d{6}$/u,
+	"linux-boot-id": /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u,
+	"linux-proc-btime": /^\d+$/u,
+};
+
+export function isBootValueWellFormed(source: string, value: string): boolean {
+	return BOOT_VALUE_SHAPE[source]?.test(value) ?? false;
+}
+
+export function isRecordedBootGeneration(value: unknown): value is RecordedBootGeneration {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value as Record<string, unknown>;
+	return (
+		record.schema_version === BOOT_GENERATION_SCHEMA_VERSION &&
+		typeof record.source === "string" &&
+		record.source.length > 0 &&
+		record.source !== "unavailable" &&
+		typeof record.value === "string" &&
+		record.value.length > 0 &&
+		isBootValueWellFormed(record.source, record.value)
+	);
+}
+
+export function recordBootGeneration(current: BootGeneration): RecordedBootGeneration | null {
+	if (current.source === "unavailable" || !current.value) return null;
+	if (!isBootValueWellFormed(current.source, current.value)) return null;
+	return { schema_version: BOOT_GENERATION_SCHEMA_VERSION, source: current.source, value: current.value };
+}
+
+/**
+ * Decides whether the machine rebooted since the session was recorded.
+ *
+ * `changed` is the ONLY executable answer. It requires a well-formed record, a
+ * readable current probe, an identical source, and different values. Source
+ * mismatch is deliberately `boot_unknown` rather than `changed`.
+ */
+export function compareBootGeneration(recorded: unknown, current: BootGeneration): BootComparison {
+	if (!isRecordedBootGeneration(recorded)) return "boot_unknown";
+	if (current.source === "unavailable" || !current.value) return "boot_unknown";
+	if (!isBootValueWellFormed(current.source, current.value)) return "boot_unknown";
+	if (recorded.source !== current.source) return "boot_unknown";
+	return recorded.value === current.value ? "same_boot" : "changed";
+}

package/src/skc-runtime/launch-tmux.ts

@@ -19,6 +19,13 @@ import {
 	SKC_TMUX_SESSION_PREFIX,
 	type SkcTmuxProfileCommand,
 } from "./tmux-common";
+import {
+	abandonIdentityCreate,
+	advanceIdentityCreatePhase,
+	type IdentityCreateReservation,
+	releaseIdentityCreate,
+	reserveIdentityCreate,
+} from "./tmux-owner-isolation";
 import { findSkcTmuxSessionByName, findSkcTmuxSessionByScope, type SkcTmuxSessionStatus } from "./tmux-sessions";
 
 export {
@@ -65,6 +72,8 @@ export interface TmuxSpawnResult {
 	exitCode: number | null;
 	signalCode?: string | null;
 	stderr?: string;
+	/** Populated only when the caller asked for `stdout: "pipe"`. */
+	stdout?: string;
 }
 
 export type TmuxSpawnSync = (command: string, args: string[], options: TmuxSpawnOptions) => TmuxSpawnResult;
@@ -73,8 +82,8 @@ export interface TmuxSpawnOptions {
 	cwd: string;
 	env: NodeJS.ProcessEnv;
 	stdin: "inherit";
-	stdout: "inherit";
-	stderr: "inherit";
+	stdout: "inherit" | "pipe";
+	stderr: "inherit" | "pipe";
 }
 
 export interface TmuxLaunchPlan {
@@ -88,6 +97,12 @@ export interface TmuxLaunchPlan {
 	project?: string | null;
 	sessionId?: string | null;
 	sessionStateFile?: string | null;
+	/**
+	 * Capability of the RESOLVED provider, not a platform guess. psmux has no
+	 * immutable native session identity, so it stays outside the native-proof
+	 * create fence and keeps its existing spawn/profile/attach behavior.
+	 */
+	isPsmux: boolean;
 }
 
 function explicitTmuxSessionName(env: NodeJS.ProcessEnv): string | undefined {
@@ -408,12 +423,106 @@ function readCurrentBranch(cwd: string): string | null {
 	}
 }
 
-function cleanupCreatedTmuxSession(plan: TmuxLaunchPlan, spawnSync: TmuxSpawnSync, options: TmuxSpawnOptions): void {
+/**
+ * Immutable identity of a session this process created, used so cleanup can
+ * never target a different session that merely reuses the name.
+ */
+interface CreatedSessionIdentity {
+	nativeSessionId: string;
+	serverPid: string;
+	/** Session birth time: distinguishes a reused `$id` on a restarted server. */
+	sessionCreated: string;
+}
+
+/**
+ * Reads `#{session_id}` and the server `#{pid}` for the session just created.
+ * Returns null when the provider cannot supply them, in which case cleanup falls
+ * back to the pre-existing name-based path.
+ */
+function captureCreatedSessionIdentity(
+	plan: TmuxLaunchPlan,
+	spawnSync: TmuxSpawnSync,
+	options: TmuxSpawnOptions,
+): CreatedSessionIdentity | null {
+	const probed = spawnSync(
+		plan.tmuxCommand,
+		[
+			"display-message",
+			"-p",
+			"-t",
+			buildSkcTmuxExactSessionTarget(plan.sessionName, { env: options.env }),
+			"#{session_id}\t#{pid}\t#{session_created}",
+		],
+		{ ...options, stdout: "pipe" },
+	);
+	if (probed.exitCode !== 0 || typeof probed.stdout !== "string") return null;
+	const [nativeSessionId, serverPid, sessionCreated] = probed.stdout.trim().split("\t");
+	if (!nativeSessionId?.startsWith("$") || !serverPid || !sessionCreated) return null;
+	return { nativeSessionId, serverPid, sessionCreated };
+}
+
+/**
+ * Returns false when the created session was NOT provably removed, so the caller
+ * can keep the reservation as evidence for authority-first recovery.
+ */
+function cleanupCreatedTmuxSession(
+	plan: TmuxLaunchPlan,
+	spawnSync: TmuxSpawnSync,
+	options: TmuxSpawnOptions,
+	identity?: CreatedSessionIdentity | null,
+): boolean {
+	if (plan.isPsmux) {
+		// Capability carveout: psmux exposes no immutable session identity, so the
+		// pre-existing name-based cleanup is all that is available there.
+		const killed = spawnSync(
+			plan.tmuxCommand,
+			["kill-session", "-t", buildSkcTmuxExactSessionTarget(plan.sessionName, { env: options.env })],
+			options,
+		);
+		return killed.exitCode === 0;
+	}
+	// Fail closed: without the immutable identity we cannot prove what we would be
+	// killing, and a session NAME may belong to somebody else by now. Leaking a
+	// session is recoverable; killing an unrelated one is not.
+	if (!identity) return false;
+	// One tmux invocation proves AND kills, so no other process can swap the
+	// target between the check and the kill. The predicate pins the server
+	// incarnation, the exact session id, and that session's birth time.
+	const predicate = [
+		`#{&&:#{==:#{pid},${identity.serverPid}}`,
+		`#{&&:#{==:#{session_id},${identity.nativeSessionId}}`,
+		`#{==:#{session_created},${identity.sessionCreated}}}}`,
+	].join(",");
 	spawnSync(
 		plan.tmuxCommand,
-		["kill-session", "-t", buildSkcTmuxExactSessionTarget(plan.sessionName, { env: options.env })],
+		["if-shell", "-t", identity.nativeSessionId, "-F", predicate, `kill-session -t ${identity.nativeSessionId}`],
 		options,
 	);
+	// `if-shell` exits 0 even when the predicate is false and nothing ran, so its
+	// exit code is not proof. Ask whether that exact session is still there.
+	const survivor = spawnSync(plan.tmuxCommand, ["has-session", "-t", identity.nativeSessionId], {
+		...options,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	// A signalled or otherwise unfinished probe answers nothing. Treating that as
+	// removal would delete the only evidence that a child may survive, so an
+	// indeterminate result fails closed.
+	if (typeof survivor.exitCode !== "number") return false;
+	// Zero means the session is still there.
+	if (survivor.exitCode === 0) return false;
+	// Non-zero is ambiguous on its own: tmux exits non-zero both for a session it
+	// cannot find and for an operational failure such as a refused socket. Only an
+	// explicit absence — including the whole server being gone — proves our child
+	// is no longer on a server we own. Anything else fails closed.
+	const diagnostic = (survivor.stderr ?? "").toLowerCase();
+	return (
+		diagnostic.includes("can't find session") ||
+		diagnostic.includes("cannot find session") ||
+		diagnostic.includes("session not found") ||
+		diagnostic.includes("no server running") ||
+		diagnostic.includes("no such file or directory")
+	);
 }
 function isTmuxAttachDisconnectError(result: TmuxSpawnResult): boolean {
 	if (result.signalCode === "SIGHUP") return true;
@@ -486,6 +595,7 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 		sessionId,
 		sessionStateFile,
 		attachSessionName: existingSessionName,
+		isPsmux: resolvedBinary.isPsmux,
 	};
 }
 
@@ -498,7 +608,12 @@ function defaultSpawnSync(command: string, args: string[], options: TmuxSpawnOpt
 		stdout: options.stdout,
 		stderr: options.stderr,
 	});
-	return { exitCode: result.exitCode, signalCode: result.signalCode };
+	return {
+		exitCode: result.exitCode,
+		signalCode: result.signalCode,
+		...(options.stdout === "pipe" ? { stdout: result.stdout?.toString() } : {}),
+		...(options.stderr === "pipe" ? { stderr: result.stderr?.toString() } : {}),
+	};
 }
 
 export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
@@ -525,49 +640,112 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 		if (attached.exitCode === 0) return true;
 	}
 
-	const created = spawnSync(plan.tmuxCommand, plan.newSessionArgs, options);
-	if (created.exitCode === 0) {
-		renameTmuxWindow(
+	// Shared identity create fence for the CREATED branch only. The attach
+	// fallback above is not a creator and stays unfenced.
+	//
+	// Capability, not platform: psmux exposes no immutable native session
+	// identity, so it cannot participate in the native-proof fence and keeps its
+	// existing behavior. That carveout is safe because restore already ends in
+	// `unsupported_owner_proof` before it can create on psmux, so no restore
+	// child can race this producer.
+	const fenceIdentity =
+		plan.isPsmux || !plan.sessionId || !plan.sessionStateFile
+			? null
+			: {
+					stateDir: path.dirname(plan.sessionStateFile),
+					sessionId: plan.sessionId,
+					stateFile: plan.sessionStateFile,
+				};
+	let reservation: IdentityCreateReservation | null = null;
+	let cleanupUncertain = false;
+	if (fenceIdentity) {
+		const reserved = reserveIdentityCreate(fenceIdentity);
+		if (!reserved.ok) {
+			// A PROVEN competing owner blocks the launch: perform no tmux mutation
+			// (no spawn, no attach, no delete). Falling through to a direct
+			// in-process launch is refused too, because it would put a second
+			// writer on the same coordinator transcript.
+			// Fail closed for every non-ok result. The fence database lives under
+			// SKC's own config root, so an unreachable fence is not a routine
+			// environment difference: it means the one-create guarantee cannot be
+			// honored, and launching anyway risks a second writer on this identity.
+			(context.diagnosticWriter ?? safeStderrWrite)(
+				formatTmuxLaunchDiagnostic("identity create fence", `${reserved.code}: ${reserved.diagnostic}`),
+			);
+			return true;
+		}
+		reservation = reserved.reservation;
+	}
+	try {
+		// Record the attempt name BEFORE the first spawn-capable call, exactly like
+		// the other producers. Without it a crash between `new-session` and the
+		// release leaves the row at `reserved`, which a successor reclaims WITHOUT a
+		// census — and that is how a second owner reaches one transcript.
+		if (reservation) {
+			reservation =
+				advanceIdentityCreatePhase(reservation, "helper_invoked", { attemptSessionName: plan.sessionName }) ??
+				(() => {
+					throw new Error("skc_tmux_identity_create_fence_lost");
+				})();
+		}
+		const created = spawnSync(plan.tmuxCommand, plan.newSessionArgs, options);
+		// Capture the immutable native identity while we still know the session we
+		// just made is the one behind this name. psmux cannot supply it, which is
+		// exactly why it stays outside the native-proof guarantee.
+		const createdIdentity =
+			created.exitCode === 0 && !plan.isPsmux ? captureCreatedSessionIdentity(plan, spawnSync, options) : null;
+		if (created.exitCode === 0) {
+			renameTmuxWindow(
+				plan.tmuxCommand,
+				buildSkcTmuxWindowTitle(plan.project ?? plan.cwd, plan.branch),
+				spawnSync,
+				options,
+				buildSkcTmuxExactSessionTarget(plan.sessionName, { env }),
+			);
+
+			const profile = applySkcTmuxProfile({
+				tmuxCommand: plan.tmuxCommand,
+				target: plan.sessionName,
+				cwd: plan.cwd,
+				env,
+				spawnSync,
+				branch: plan.branch,
+				project: plan.project,
+				sessionId: plan.sessionId ?? null,
+				sessionStateFile: plan.sessionStateFile ?? null,
+				version: VERSION,
+			});
+			const ownershipFailure = profile.failures.find(item => item.command.args.includes("@skc-profile"));
+			if (ownershipFailure) {
+				if (!cleanupCreatedTmuxSession(plan, spawnSync, options, createdIdentity)) cleanupUncertain = true;
+				(context.diagnosticWriter ?? safeStderrWrite)(
+					formatTmuxLaunchDiagnostic("profile tagging failed", ownershipFailure.stderr),
+				);
+				return true;
+			}
+		}
+		if (created.exitCode !== 0) return false;
+		const attached = spawnSync(
 			plan.tmuxCommand,
-			buildSkcTmuxWindowTitle(plan.project ?? plan.cwd, plan.branch),
-			spawnSync,
+			["attach-session", "-t", buildSkcTmuxExactSessionTarget(plan.sessionName, { env })],
 			options,
-			buildSkcTmuxExactSessionTarget(plan.sessionName, { env }),
 		);
-
-		const profile = applySkcTmuxProfile({
-			tmuxCommand: plan.tmuxCommand,
-			target: plan.sessionName,
-			cwd: plan.cwd,
-			env,
-			spawnSync,
-			branch: plan.branch,
-			project: plan.project,
-			sessionId: plan.sessionId ?? null,
-			sessionStateFile: plan.sessionStateFile ?? null,
-			version: VERSION,
-		});
-		const ownershipFailure = profile.failures.find(item => item.command.args.includes("@skc-profile"));
-		if (ownershipFailure) {
-			cleanupCreatedTmuxSession(plan, spawnSync, options);
+		if (attached.exitCode === 0) return true;
+		if (isTmuxAttachDisconnectError(attached)) {
 			(context.diagnosticWriter ?? safeStderrWrite)(
-				formatTmuxLaunchDiagnostic("profile tagging failed", ownershipFailure.stderr),
+				formatTmuxLaunchDiagnostic("attach disconnected", attached.stderr),
 			);
 			return true;
 		}
-	}
-	if (created.exitCode !== 0) return false;
-	const attached = spawnSync(
-		plan.tmuxCommand,
-		["attach-session", "-t", buildSkcTmuxExactSessionTarget(plan.sessionName, { env })],
-		options,
-	);
-	if (attached.exitCode === 0) return true;
-	if (isTmuxAttachDisconnectError(attached)) {
-		(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach disconnected", attached.stderr));
+		if (!cleanupCreatedTmuxSession(plan, spawnSync, options, createdIdentity)) cleanupUncertain = true;
+		(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach failed", attached.stderr));
 		return true;
+	} finally {
+		if (reservation) {
+			// An unproven cleanup may have left a child; its row is the only evidence
+			// a successor gets, so end the attempt without deleting it.
+			if (cleanupUncertain) abandonIdentityCreate(reservation);
+			else releaseIdentityCreate(reservation);
+		}
 	}
-	cleanupCreatedTmuxSession(plan, spawnSync, options);
-	(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach failed", attached.stderr));
-	return true;
 }