@sayknow-cli/coding-agent 0.2.4 → 0.2.6

package/src/skc-runtime/deep-interview-recorder.ts

@@ -11,7 +11,8 @@ import {
 	normalizeDeepInterviewEnvelope,
 	questionHash,
 } from "./deep-interview-state";
-import { readExistingStateForMutation, writeWorkflowEnvelopeAtomic } from "./state-writer";
+import { writeSessionActivityMarker } from "./session-resolution";
+import { readExistingStateForMutation, writeGuardedWorkflowEnvelopeAtomic } from "./state-writer";
 
 export * from "./deep-interview-state";
 
@@ -298,6 +299,12 @@ async function readEnvelope(statePath: string): Promise<DeepInterviewStateEnvelo
 	return ensureDeepInterviewStateShape(undefined);
 }
 
+function existingStateRevision(value: unknown): number | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const revision = (value as Record<string, unknown>).state_revision;
+	return typeof revision === "number" && Number.isFinite(revision) ? revision : 0;
+}
+
 function interviewIdOf(envelope: DeepInterviewStateEnvelope): string | undefined {
 	const inner = (envelope.state ?? {}) as Record<string, unknown>;
 	return typeof inner.interview_id === "string" ? inner.interview_id : undefined;
@@ -310,6 +317,7 @@ async function persistEnvelope(
 	sessionId: string | undefined,
 	command: string,
 ): Promise<void> {
+	if (!sessionId) throw new Error("deep-interview recorder requires a session id");
 	const now = new Date().toISOString();
 	const payload: Record<string, unknown> = { ...normalizeDeepInterviewEnvelope(envelope), updated_at: now };
 	// Guarantee RequiredOnWriteEnvelopeSchema fields for the fresh/absent fallback;
@@ -318,11 +326,22 @@ async function persistEnvelope(
 	payload.version ??= WORKFLOW_STATE_VERSION;
 	payload.active ??= true;
 	payload.current_phase ??= "interviewing";
-	await writeWorkflowEnvelopeAtomic(statePath, payload, {
+	const expectedRevision = existingStateRevision(envelope);
+	const writeResult = await writeGuardedWorkflowEnvelopeAtomic(statePath, payload, {
 		cwd,
+		policy: "source",
+		expectedRevision,
 		receipt: { cwd, skill: "deep-interview", owner: "skc-runtime", command, sessionId, nowIso: now },
-		audit: { category: "state", verb: "write", owner: "skc-runtime", skill: "deep-interview" },
+		audit: { category: "state", verb: "write", owner: "skc-runtime", skill: "deep-interview", sessionId },
 	});
+	// Reflect the freshly written revision back onto the in-memory envelope so a
+	// follow-up HUD sync derives its `sourceRevision` from the persisted revision
+	// (not the stale pre-write value), otherwise the active-state writer treats the
+	// newer HUD as stale and skips it (e.g. dropping the ambiguity chip after scoring).
+	if (writeResult.written && typeof expectedRevision === "number") {
+		(envelope as Record<string, unknown>).state_revision = expectedRevision + 1;
+	}
+	await writeSessionActivityMarker(cwd, sessionId, { writer: "deep-interview-recorder", path: statePath });
 }
 
 /**
@@ -335,20 +354,17 @@ async function syncRecorderHud(
 	envelope: DeepInterviewStateEnvelope,
 	sessionId: string | undefined,
 ): Promise<void> {
-	try {
-		const phase = typeof envelope.current_phase === "string" ? envelope.current_phase : "interviewing";
-		await syncSkillActiveState({
-			cwd,
-			skill: "deep-interview",
-			active: phase !== "complete",
-			phase,
-			sessionId,
-			source: "skc-runtime-deep-interview-recorder",
-			hud: deriveDeepInterviewHud(envelope as Record<string, unknown>, { phase }),
-		});
-	} catch {
-		// HUD sync is best-effort cache maintenance and must not change record semantics.
-	}
+	const phase = typeof envelope.current_phase === "string" ? envelope.current_phase : "interviewing";
+	await syncSkillActiveState({
+		cwd,
+		skill: "deep-interview",
+		active: phase !== "complete",
+		phase,
+		sessionId,
+		source: "skc-runtime-deep-interview-recorder",
+		hud: deriveDeepInterviewHud(envelope as Record<string, unknown>, { phase }),
+		sourceRevision: existingStateRevision(envelope),
+	});
 }
 
 /**
@@ -360,6 +376,19 @@ async function repairRecorderHudFromPersisted(
 	cwd: string,
 	statePath: string,
 	sessionId: string | undefined,
+): Promise<void> {
+	try {
+		await syncDeepInterviewRecorderHud(cwd, statePath, sessionId);
+	} catch {
+		// HUD sync is best-effort cache maintenance and must not change record semantics.
+	}
+}
+
+/** Refresh the best-effort HUD cache from persisted deep-interview state. */
+export async function syncDeepInterviewRecorderHud(
+	cwd: string,
+	statePath: string,
+	sessionId: string | undefined,
 ): Promise<void> {
 	const read = await readExistingStateForMutation(statePath);
 	if (read.kind !== "valid") return;
@@ -384,7 +413,11 @@ export async function appendOrMergeDeepInterviewRound(
 	}
 	(envelope.state as Record<string, unknown>).rounds = result.rounds;
 	await persistEnvelope(cwd, statePath, envelope, options.sessionId, "skc deep-interview record-answer");
-	await syncRecorderHud(cwd, envelope, options.sessionId);
+	try {
+		await syncRecorderHud(cwd, envelope, options.sessionId);
+	} catch {
+		// HUD sync is best-effort cache maintenance and must not change record semantics.
+	}
 	return { action: result.action, record: result.record };
 }
 

package/src/skc-runtime/deep-interview-runtime.ts

@@ -7,6 +7,8 @@ import { deriveDeepInterviewHud } from "../skill-state/workflow-hud";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-contract";
 import { normalizeDeepInterviewEnvelope } from "./deep-interview-state";
 import { runNativeRalplanCommand } from "./ralplan-runtime";
+import { modeStatePath, sessionSpecsDir } from "./session-layout";
+import { resolveSkcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { runNativeStateCommand } from "./state-runtime";
 import { appendJsonl, readExistingStateForMutation, writeArtifact, writeWorkflowEnvelopeAtomic } from "./state-writer";
 
@@ -76,10 +78,6 @@ function assertSafePathComponent(value: string, label: string): void {
 	}
 }
 
-function encodeSessionSegment(value: string): string {
-	return encodeURIComponent(value).replaceAll(".", "%2E");
-}
-
 function defaultSpecSlug(now: Date = new Date()): string {
 	const yyyy = now.getUTCFullYear().toString().padStart(4, "0");
 	const mm = (now.getUTCMonth() + 1).toString().padStart(2, "0");
@@ -89,14 +87,10 @@ function defaultSpecSlug(now: Date = new Date()): string {
 	return `${yyyy}-${mm}-${dd}-${hh}${min}-${randomBytes(2).toString("hex")}`;
 }
 
-function stateDirFor(cwd: string, sessionId: string | undefined): string {
-	return sessionId
-		? path.join(cwd, ".skc", "state", "sessions", encodeSessionSegment(sessionId))
-		: path.join(cwd, ".skc", "state");
-}
-
-export function deepInterviewStatePath(cwd: string, sessionId: string | undefined): string {
-	return path.join(stateDirFor(cwd, sessionId), "deep-interview-state.json");
+export function deepInterviewStatePath(cwd: string, sessionId?: string): string {
+	const resolvedSessionId = sessionId?.trim() || process.env.SKC_SESSION_ID?.trim();
+	if (!resolvedSessionId) throw new Error("deep-interview state path requires a session id");
+	return modeStatePath(cwd, resolvedSessionId, "deep-interview");
 }
 
 async function resolveSpecContent(rawSpec: string, cwd: string): Promise<string> {
@@ -117,7 +111,7 @@ interface ResolvedDeepInterviewArgs {
 	resolution: DeepInterviewResolution;
 	threshold: number;
 	thresholdSource: string;
-	sessionId?: string;
+	sessionId: string;
 	idea: string;
 	language?: DeepInterviewLanguagePreference;
 	json: boolean;
@@ -134,7 +128,7 @@ export interface ResolvedDeepInterviewSpecWriteArgs {
 	stage: "final";
 	slug: string;
 	spec: string;
-	sessionId?: string;
+	sessionId: string;
 	json: boolean;
 	deliberate: boolean;
 	handoff?: "ralplan";
@@ -277,8 +271,12 @@ async function resolveSpecWriteArgs(args: readonly string[], cwd: string): Promi
 		throw new DeepInterviewCommandError(2, "--spec is required for deep-interview --write");
 	}
 
-	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
-	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+	const session = resolveSkcSessionForWrite(cwd, {
+		flagValue: flagValue(args, "--session-id"),
+		envSessionId: process.env.SKC_SESSION_ID,
+	});
+	const sessionId = session.skcSessionId;
+	assertSafePathComponent(sessionId, "session-id");
 
 	const rawHandoff = flagValue(args, "--handoff")?.trim() || undefined;
 	if (rawHandoff && rawHandoff !== "ralplan") {
@@ -324,8 +322,12 @@ async function resolveSpecWriteArgs(args: readonly string[], cwd: string): Promi
 }
 
 async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): Promise<ResolvedDeepInterviewArgs> {
-	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
-	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+	const session = resolveSkcSessionForWrite(cwd, {
+		flagValue: flagValue(args, "--session-id"),
+		envSessionId: process.env.SKC_SESSION_ID,
+	});
+	const sessionId = session.skcSessionId;
+	assertSafePathComponent(sessionId, "session-id");
 
 	const explicitResolutions = (["quick", "standard", "deep"] as const).filter(name => hasFlag(args, `--${name}`));
 	if (explicitResolutions.length > 1) {
@@ -402,19 +404,34 @@ export async function persistDeepInterviewSpec(
 	}
 	const existing = existingRead.kind === "valid" ? existingRead.value : {};
 
-	const specPath = path.join(cwd, ".skc", "specs", `deep-interview-${resolved.slug}.md`);
+	const specPath = path.join(sessionSpecsDir(cwd, resolved.sessionId), `deep-interview-${resolved.slug}.md`);
 	const content = resolved.spec.endsWith("\n") ? resolved.spec : `${resolved.spec}\n`;
 	await writeArtifact(specPath, content, {
 		cwd,
-		audit: { category: "artifact", verb: "write", owner: "skc-runtime", skill: "deep-interview" },
+		audit: {
+			category: "artifact",
+			verb: "write",
+			owner: "skc-runtime",
+			skill: "deep-interview",
+			sessionId: resolved.sessionId,
+		},
 	});
 
 	const sha256 = createHash("sha256").update(content).digest("hex");
 	const createdAt = new Date().toISOString();
 	await appendJsonl(
-		path.join(cwd, ".skc", "specs", "deep-interview-index.jsonl"),
+		path.join(sessionSpecsDir(cwd, resolved.sessionId), "deep-interview-index.jsonl"),
 		{ slug: resolved.slug, stage: resolved.stage, path: specPath, created_at: createdAt, sha256 },
-		{ cwd, audit: { category: "ledger", verb: "append", owner: "skc-runtime", skill: "deep-interview" } },
+		{
+			cwd,
+			audit: {
+				category: "ledger",
+				verb: "append",
+				owner: "skc-runtime",
+				skill: "deep-interview",
+				sessionId: resolved.sessionId,
+			},
+		},
 	);
 
 	const payload = normalizeDeepInterviewEnvelope({
@@ -446,9 +463,11 @@ export async function persistDeepInterviewSpec(
 			verb: "write",
 			owner: "skc-runtime",
 			skill: "deep-interview",
+			sessionId: resolved.sessionId,
 			forced: resolved.force,
 		},
 	});
+	await writeSessionActivityMarker(cwd, resolved.sessionId, { writer: "deep-interview-runtime", path: statePath });
 	await syncDeepInterviewHud({
 		cwd,
 		sessionId: resolved.sessionId,
@@ -503,8 +522,15 @@ async function seedDeepInterviewState(cwd: string, resolved: ResolvedDeepIntervi
 			sessionId: resolved.sessionId,
 			nowIso: now,
 		},
-		audit: { category: "state", verb: "write", owner: "skc-runtime", skill: "deep-interview" },
+		audit: {
+			category: "state",
+			verb: "write",
+			owner: "skc-runtime",
+			skill: "deep-interview",
+			sessionId: resolved.sessionId,
+		},
 	});
+	await writeSessionActivityMarker(cwd, resolved.sessionId, { writer: "deep-interview-runtime", path: statePath });
 	await syncDeepInterviewHud({ cwd, sessionId: resolved.sessionId, payload, phase: "interviewing" });
 	return statePath;
 }

package/src/skc-runtime/goal-mode-request.ts

@@ -8,6 +8,8 @@ import {
 	type ModeChangeEntry,
 	type SessionEntry,
 } from "../session/session-manager";
+import { sessionStateDir, sessionUltragoalDir } from "./session-layout";
+import { resolveSkcSessionForRead, resolveSkcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { removeFileAudited, writeJsonAtomic } from "./state-writer";
 
 export const SKC_SESSION_FILE_ENV = "SKC_SESSION_FILE";
@@ -48,12 +50,12 @@ function isEnoent(error: unknown): boolean {
 	);
 }
 
-function requestPath(cwd: string): string {
-	return path.join(cwd, ".skc", "state", "goal-mode-request.json");
+function requestPath(cwd: string, sessionId: string): string {
+	return path.join(sessionStateDir(cwd, sessionId), "goal-mode-request.json");
 }
 
-function ultragoalGoalsPath(cwd: string): string {
-	return path.join(cwd, ".skc", "ultragoal", "goals.json");
+function ultragoalGoalsPath(cwd: string, sessionId: string): string {
+	return path.join(sessionUltragoalDir(cwd, sessionId), "goals.json");
 }
 
 function isCreateGoalsArg(value: string): boolean {
@@ -65,8 +67,14 @@ export function isUltragoalCreateGoalsInvocation(args: readonly string[]): boole
 	return command !== undefined && isCreateGoalsArg(command);
 }
 
-export async function readUltragoalSkcObjective(cwd: string): Promise<{ objective: string; goalsPath: string }> {
-	const goalsPath = ultragoalGoalsPath(cwd);
+export async function readUltragoalSkcObjective(
+	cwd: string,
+	sessionId?: string | null,
+): Promise<{ objective: string; goalsPath: string }> {
+	const session = sessionId?.trim()
+		? { skcSessionId: sessionId.trim() }
+		: await resolveSkcSessionForRead(cwd, { envSessionId: process.env.SKC_SESSION_ID });
+	const goalsPath = ultragoalGoalsPath(cwd, session.skcSessionId);
 	try {
 		const plan = (await Bun.file(goalsPath).json()) as UltragoalPlanShape;
 		const objective = typeof plan.skcObjective === "string" ? plan.skcObjective.trim() : "";
@@ -87,7 +95,10 @@ export async function writePendingGoalModeRequest(input: {
 }): Promise<PendingGoalModeRequest> {
 	const objective = input.objective.trim();
 	if (!objective) throw new Error("goal objective is required");
-	const sessionId = input.sessionId?.trim();
+	const resolvedSessionId =
+		input.sessionId?.trim() ||
+		resolveSkcSessionForWrite(input.cwd, { envSessionId: process.env.SKC_SESSION_ID }).skcSessionId;
+	const sessionId = resolvedSessionId;
 	const request: PendingGoalModeRequest = {
 		version: REQUEST_VERSION,
 		kind: "goal_mode_request",
@@ -97,11 +108,12 @@ export async function writePendingGoalModeRequest(input: {
 		goalsPath: input.goalsPath,
 		...(sessionId ? { sessionId } : {}),
 	};
-	const filePath = requestPath(input.cwd);
+	const filePath = requestPath(input.cwd, sessionId);
 	await writeJsonAtomic(filePath, request, {
 		cwd: input.cwd,
-		audit: { category: "state", verb: "write", owner: "skc-runtime" },
+		audit: { category: "state", verb: "write", owner: "skc-runtime", sessionId },
 	});
+	await writeSessionActivityMarker(input.cwd, sessionId, { writer: "goal-mode-request", path: filePath });
 	return request;
 }
 
@@ -175,7 +187,10 @@ export async function consumePendingGoalModeRequest(
 	cwd: string,
 	currentSessionId?: string | null,
 ): Promise<PendingGoalModeRequest | null> {
-	const filePath = requestPath(cwd);
+	const session = currentSessionId?.trim()
+		? { skcSessionId: currentSessionId.trim() }
+		: await resolveSkcSessionForRead(cwd, { envSessionId: process.env.SKC_SESSION_ID });
+	const filePath = requestPath(cwd, session.skcSessionId);
 	let raw: unknown;
 	try {
 		raw = await Bun.file(filePath).json();
@@ -203,7 +218,7 @@ export async function consumePendingGoalModeRequest(
 	}
 	await removeFileAudited(filePath, {
 		cwd,
-		audit: { category: "prune", verb: "remove", owner: "skc-runtime" },
+		audit: { category: "prune", verb: "remove", owner: "skc-runtime", sessionId: session.skcSessionId },
 	}).catch(error => {
 		if (!isEnoent(error)) throw error;
 	});

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

@@ -1,6 +1,8 @@
+import { Buffer } from "node:buffer";
 import * as path from "node:path";
 import { safeStderrWrite } from "@sayknow-cli/utils";
 import type { Args } from "../cli/args";
+import { tmuxRuntimeSessionPath } from "./session-layout";
 import { SKC_COORDINATOR_SESSION_ID_ENV, SKC_COORDINATOR_SESSION_STATE_FILE_ENV } from "./session-state-sidecar";
 import {
 	buildSkcTmuxProfileCommands,
@@ -14,7 +16,7 @@ import {
 	SKC_TMUX_SESSION_PREFIX,
 	type SkcTmuxProfileCommand,
 } from "./tmux-common";
-import { findSkcTmuxSessionByBranch } from "./tmux-sessions";
+import { findSkcTmuxSessionByName, findSkcTmuxSessionByScope } from "./tmux-sessions";
 
 export {
 	buildSkcTmuxProfileCommands,
@@ -83,6 +85,20 @@ export interface TmuxLaunchPlan {
 	sessionStateFile?: string | null;
 }
 
+function explicitTmuxSessionName(env: NodeJS.ProcessEnv): string | undefined {
+	return env.SKC_TMUX_SESSION?.trim() || undefined;
+}
+
+function findExistingSessionForLaunch(context: {
+	env: NodeJS.ProcessEnv;
+	project: string;
+	branch?: string | null;
+}): string | undefined {
+	const explicit = explicitTmuxSessionName(context.env);
+	if (explicit) return findSkcTmuxSessionByName(explicit, context.env)?.name;
+	return findSkcTmuxSessionByScope(context.project, context.branch, context.env)?.name;
+}
+
 export interface SkcTmuxProfileResult {
 	skipped: boolean;
 	commands: SkcTmuxProfileCommand[];
@@ -107,6 +123,7 @@ interface CommandResolutionContext {
 	argv: string[];
 	execPath: string;
 	extraEnv?: Record<string, string>;
+	platform?: NodeJS.Platform;
 }
 
 function parseLaunchPolicy(env: NodeJS.ProcessEnv): LaunchPolicy {
@@ -148,6 +165,26 @@ function buildEnvAssignments(values: Record<string, string> | undefined): string
 	const entries = Object.entries(values ?? {});
 	return entries.length === 0 ? "" : ` ${entries.map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ")}`;
 }
+function powershellQuote(value: string): string {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+function stripRootTmuxFlag(rawArgs: string[]): string[] {
+	return rawArgs.filter(arg => arg !== "--tmux");
+}
+
+function buildWindowsPowerShellInnerCommand(context: CommandResolutionContext, rawArgs: string[]): string {
+	const command = resolveCurrentSkcCommand(context);
+	const envLines = Object.entries({ [SKC_TMUX_LAUNCHED_ENV]: "1", ...(context.extraEnv ?? {}) }).map(
+		([key, value]) => `$env:${key} = ${powershellQuote(value)}`,
+	);
+	const invocation = ["&", ...command.map(powershellQuote), ...stripRootTmuxFlag(rawArgs).map(powershellQuote)].join(
+		" ",
+	);
+	const exitLine = "if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 }";
+	const script = [...envLines, invocation, exitLine].join("\n");
+	const encodedCommand = Buffer.from(script, "utf16le").toString("base64");
+	return `pwsh -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encodedCommand}`;
+}
 
 export function applySkcTmuxProfile(context: SkcTmuxProfileContext): SkcTmuxProfileResult {
 	const env = context.env ?? process.env;
@@ -177,16 +214,26 @@ function resolveCurrentSkcCommand(context: CommandResolutionContext): string[] {
 	if (isBunVirtualPath(entrypoint)) {
 		return isBunVirtualPath(context.execPath) ? ["skc"] : [context.execPath];
 	}
-	const resolvedEntrypoint = path.isAbsolute(entrypoint) ? entrypoint : path.resolve(context.cwd, entrypoint);
+	const pathModule = pathModuleForPlatform(context.platform);
+	const resolvedEntrypoint = pathModule.isAbsolute(entrypoint)
+		? entrypoint
+		: pathModule.resolve(context.cwd, entrypoint);
 	if (entrypoint.endsWith(".ts") || entrypoint.endsWith(".js") || entrypoint.endsWith(".mjs")) {
 		return [context.execPath, resolvedEntrypoint];
 	}
 	return [resolvedEntrypoint];
 }
+function isWindowsPlatform(platform: NodeJS.Platform | undefined): boolean {
+	return platform === "win32";
+}
+function pathModuleForPlatform(platform: NodeJS.Platform | undefined): typeof path.win32 | typeof path {
+	return isWindowsPlatform(platform) ? path.win32 : path;
+}
 
 function buildInnerCommand(context: CommandResolutionContext, rawArgs: string[]): string {
+	if (isWindowsPlatform(context.platform)) return buildWindowsPowerShellInnerCommand(context, rawArgs);
 	const command = resolveCurrentSkcCommand(context);
-	const quoted = [...command, ...rawArgs].map(shellQuote).join(" ");
+	const quoted = [...command, ...stripRootTmuxFlag(rawArgs)].map(shellQuote).join(" ");
 	return `exec env ${SKC_TMUX_LAUNCHED_ENV}=1${buildEnvAssignments(context.extraEnv)} ${quoted}`;
 }
 
@@ -305,7 +352,6 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 	if (!context.parsed.tmux || policy === "direct") return undefined;
 	if (env.TMUX || env[SKC_TMUX_LAUNCHED_ENV] === "1") return undefined;
 	const platform = context.platform ?? process.platform;
-	if (platform === "win32") return undefined;
 	const tty = context.tty ?? { stdin: Boolean(process.stdin.isTTY), stdout: Boolean(process.stdout.isTTY) };
 	if (policy === "tmux" && !isInteractiveRootLaunch(context.parsed, tty)) return undefined;
 
@@ -315,17 +361,23 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 	const sessionName = buildSkcTmuxSessionName(env, { branch });
 	const tmuxCommand = resolveSkcTmuxCommand(env);
 	const sessionId = env[SKC_COORDINATOR_SESSION_ID_ENV]?.trim() || sessionName;
+	// The session ROOT is keyed by the active SKC session (SKC_SESSION_ID), NOT the
+	// coordinator/tmux identity. Fall back to the coordinator id only for standalone
+	// tmux launches with no SKC session context.
+	const skcSessionId = env.SKC_SESSION_ID?.trim() || sessionId;
 	const sessionStateFile =
 		env[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim() ||
-		path.join(cwd, ".skc", "runtime", "tmux-sessions", `${buildSkcTmuxSessionSlug(sessionName)}.json`);
+		tmuxRuntimeSessionPath(cwd, skcSessionId, buildSkcTmuxSessionSlug(sessionName));
 	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
 	if (!tmuxAvailable) return undefined;
-	const existingBranchSessionName =
+	const existingSessionName =
 		"existingBranchSessionName" in context
 			? (context.existingBranchSessionName ?? undefined)
-			: context.worktreeBranch
-				? findSkcTmuxSessionByBranch(context.worktreeBranch, env, project)?.name
-				: undefined;
+			: findExistingSessionForLaunch({
+					env,
+					project,
+					branch,
+				});
 	const innerCommand = buildInnerCommand(
 		{
 			cwd,
@@ -335,6 +387,7 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 				[SKC_COORDINATOR_SESSION_ID_ENV]: sessionId,
 				[SKC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
 			},
+			platform,
 		},
 		context.rawArgs,
 	);
@@ -348,7 +401,7 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 		project,
 		sessionId,
 		sessionStateFile,
-		attachSessionName: existingBranchSessionName,
+		attachSessionName: existingSessionName,
 	};
 }
 
@@ -405,19 +458,19 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 			sessionId: plan.sessionId ?? null,
 			sessionStateFile: plan.sessionStateFile ?? null,
 		});
-		if (profile.failures.length > 0) {
+		const ownershipFailure = profile.failures.find(item => item.command.args.includes("@skc-profile"));
+		if (ownershipFailure) {
 			cleanupCreatedTmuxSession(plan, spawnSync, options);
-			const failure =
-				profile.failures.find(item => item.command.args.includes("@skc-profile")) ?? profile.failures[0];
 			(context.diagnosticWriter ?? safeStderrWrite)(
-				formatTmuxLaunchDiagnostic("profile tagging failed", failure?.stderr),
+				formatTmuxLaunchDiagnostic("profile tagging failed", ownershipFailure.stderr),
 			);
 			return true;
 		}
 	}
 	if (created.exitCode !== 0) return false;
-	const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", plan.sessionName], options);
+	const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", `=${plan.sessionName}`], options);
 	if (attached.exitCode === 0) return true;
+	cleanupCreatedTmuxSession(plan, spawnSync, options);
 	(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach failed", attached.stderr));
 	return true;
 }