@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/gjc-runtime/gc-render.ts

@@ -8,7 +8,6 @@ import { GC_STORES } from "./gc-runtime";
 
 const STORE_HEADINGS: Record<GcStore, string> = {
 	harness_leases: "Harness owner leases",
-	team_workers: "Team workers",
 	file_locks: "Config file-locks",
 	tmux_sessions: "Tmux sessions",
 	registry_entries: "Harness-root registry entries",

package/src/gjc-runtime/gc-runtime.ts

@@ -35,17 +35,10 @@ import { FileSessionStorage, probeSessionRetirement, retireSessionTranscript } f
 import { buildGcReportText } from "./gc-render";
 import { collectSessionScopeUsage, type GcSessionScopeUsage, shouldReportSessionScope } from "./gc-session-scope";
 
-export type GcStore =
-	| "harness_leases"
-	| "team_workers"
-	| "file_locks"
-	| "tmux_sessions"
-	| "registry_entries"
-	| "local_roots";
+export type GcStore = "harness_leases" | "file_locks" | "tmux_sessions" | "registry_entries" | "local_roots";
 
 export const GC_STORES: readonly GcStore[] = [
 	"harness_leases",
-	"team_workers",
 	"file_locks",
 	"tmux_sessions",
 	"registry_entries",
@@ -547,19 +540,16 @@ export async function defaultGcAdapters(): Promise<GcStoreAdapter[]> {
 	const [
 		{ harnessLeasesGcAdapter, registryEntriesGcAdapter },
 		{ fileLocksGcAdapter },
-		{ teamWorkersGcAdapter },
 		{ tmuxSessionsGcAdapter },
 		{ localRootsGcAdapter },
 	] = await Promise.all([
 		import("../harness-control-plane/gc-adapter"),
 		import("../config/file-lock-gc"),
-		import("./team-gc"),
 		import("./tmux-gc"),
 		import("../internal-urls/local-root-gc"),
 	]);
 	return [
 		harnessLeasesGcAdapter,
-		teamWorkersGcAdapter,
 		fileLocksGcAdapter,
 		tmuxSessionsGcAdapter,
 		registryEntriesGcAdapter,

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

@@ -402,7 +402,7 @@ export function applyGjcTmuxProfile(context: GjcTmuxProfileContext): GjcTmuxProf
 	const branchSlug = context.branch ? buildGjcTmuxSessionSlug(context.branch) : (context.branchSlug ?? null);
 	// The psmux UX filter (mouse / set-clipboard / mode-style /
 	// set-window-option) now lives in buildGjcTmuxProfileCommands so every
-	// caller — gjc --tmux planning, gjc session create, gjc team bootstrap —
+	// caller — gjc --tmux planning, gjc session create —
 	// applies the same drop set when the active multiplexer is psmux. We pass
 	// the resolved tmuxCommand through the new opts seam so the filter
 	// engages for this exact command, not whatever the resolver returns at
@@ -1027,8 +1027,8 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 			extraEnv: {
 				[GJC_COORDINATOR_SESSION_ID_ENV]: sessionId,
 				[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
-				// Carry the GJC-managed session name into the child so `gjc team`
-				// can target the correct leader session by name. Under psmux on
+				// Carry the GJC-managed session name into the child so tmux-backed
+				// flows can target the correct leader session by name. Under psmux on
 				// Windows the inherited TMUX_PANE can resolve to the wrong/default
 				// session, which would split/send workers into the wrong session.
 				[GJC_TMUX_ACTIVE_SESSION_ENV]: sessionName,

package/src/gjc-runtime/psmux-detect.ts

@@ -307,7 +307,7 @@ export interface ResolvedTmuxBinary {
 
 /**
  * Resolve the tmux command GJC should invoke. Honors the existing
- * GJC_TMUX_COMMAND / GJC_TEAM_TMUX_COMMAND overrides; on Windows when no
+ * GJC_TMUX_COMMAND override; on Windows when no
  * override is set, psmux (installed as psmux, pmux, or tmux) is picked
  * automatically so the default gjc --tmux flow lands on a real multiplexer.
  */
@@ -315,7 +315,7 @@ export function resolveGjcTmuxBinary(options: ResolveGjcTmuxBinaryOptions = {}):
 	const env = options.env ?? process.env;
 	const platform = options.platform ?? process.platform;
 	const runner = options.runner ?? readSpawnRunner();
-	const explicit = env.GJC_TMUX_COMMAND?.trim() || env.GJC_TEAM_TMUX_COMMAND?.trim();
+	const explicit = env.GJC_TMUX_COMMAND?.trim();
 	if (explicit) {
 		const isPsmux =
 			platform === "win32"

package/src/gjc-runtime/python-transcript.ts

@@ -0,0 +1,58 @@
+import { pythonKernelTranscriptPath } from "./session-layout";
+import { writeLogJsonl } from "./state-writer";
+
+export interface PythonTranscriptRecord {
+	timestamp: string;
+	code: string;
+	output: string;
+	exitCode: number | null;
+	cancelled: boolean;
+	truncated: boolean;
+}
+
+export interface PythonKernelTranscript {
+	readonly dir: string;
+	readonly kernelInstanceId: string;
+	append(record: PythonTranscriptRecord): Promise<void>;
+}
+
+function transcriptDirectoryName(now: Date, kernelInstanceId: string): string {
+	const yyyy = now.getUTCFullYear().toString().padStart(4, "0");
+	const mm = (now.getUTCMonth() + 1).toString().padStart(2, "0");
+	const dd = now.getUTCDate().toString().padStart(2, "0");
+	const hh = now.getUTCHours().toString().padStart(2, "0");
+	const min = now.getUTCMinutes().toString().padStart(2, "0");
+	const ss = now.getUTCSeconds().toString().padStart(2, "0");
+	return `${yyyy}${mm}${dd}T${hh}${min}${ss}Z-${kernelInstanceId}`;
+}
+
+export function openPythonKernelTranscript(input: {
+	cwd: string;
+	sessionId: string;
+	kernelInstanceId: string;
+	now?: Date;
+}): PythonKernelTranscript {
+	const dir = transcriptDirectoryName(input.now ?? new Date(), input.kernelInstanceId);
+	const transcriptPath = pythonKernelTranscriptPath(input.cwd, input.sessionId, dir);
+	let queue: Promise<void> = Promise.resolve();
+
+	return {
+		dir,
+		kernelInstanceId: input.kernelInstanceId,
+		append(record: PythonTranscriptRecord): Promise<void> {
+			const write = queue.then(async () => {
+				await writeLogJsonl(transcriptPath, record, {
+					cwd: input.cwd,
+					audit: {
+						category: "log",
+						verb: "append",
+						owner: "gjc-runtime",
+						sessionId: input.sessionId,
+					},
+				});
+			});
+			queue = write.catch(() => undefined);
+			return write;
+		},
+	};
+}

package/src/gjc-runtime/ralplan-runtime.ts

@@ -42,7 +42,6 @@ import {
 	writeArtifact,
 	writeWorkflowEnvelopeAtomic,
 } from "./state-writer";
-import { probeGjcTeamAvailability } from "./team-runtime";
 import { assertSafePathComponent, CommandError, flagValue, hasFlag } from "./workflow-cli-common";
 import { getSkillManifest } from "./workflow-manifest";
 import {
@@ -66,7 +65,7 @@ import {
  * 2. **Artifact write**: `gjc ralplan --write --stage <type> --stage_n <N>
  *    (--artifact <path-or-string> | --artifact-env GJC_RALPLAN_ARTIFACT)
  *    [--run-id <id>] [--session-id <id>] [--lane-verdict <token>] [--json]` persists Planner / Architect
- *    / Critic / disposition / revision / post-interview / ADR / final artifacts under
+ *    / Critic / intent / disposition / revision / post-interview / ADR / final artifacts under
  *    `.gjc/plans/ralplan/<run-id>/`, maintains an `index.jsonl` audit log, copies `final`
  *    stages to `pending-approval.md`, and advances the HUD chip to reflect the latest
  *    persisted stage. Disposition stage artifacts are fail-closed JSON documents that
@@ -81,6 +80,7 @@ export interface RalplanCommandResult {
 
 const KNOWN_STAGES = [
 	"planner",
+	"intent",
 	"architect",
 	"critic",
 	"disposition",
@@ -100,7 +100,7 @@ export const PLANNING_STUCK_MARKER = "PLANNING-STUCK";
 export const RALPLAN_DEFAULT_MAX_REVIEW_PASSES_PER_LANE = 1;
 /** Inclusive upper bound for `gjc.ralplan.maxReviewPassesPerLane` settings overrides. */
 export const RALPLAN_MAX_REVIEW_PASSES_PER_LANE_LIMIT = 10;
-export type RalplanAutoHandoffTarget = "off" | "ultragoal" | "team";
+export type RalplanAutoHandoffTarget = "off" | "ultragoal" | "autoresearch";
 
 export interface RalplanAutoHandoffResolution {
 	configuredTarget: RalplanAutoHandoffTarget;
@@ -109,7 +109,7 @@ export interface RalplanAutoHandoffResolution {
 	source: string;
 }
 
-const RALPLAN_AUTO_HANDOFF_TARGETS = new Set<RalplanAutoHandoffTarget>(["off", "ultragoal", "team"]);
+const RALPLAN_AUTO_HANDOFF_TARGETS = new Set<RalplanAutoHandoffTarget>(["off", "ultragoal", "autoresearch"]);
 
 const RALPLAN_ITERATION_OPENER_STAGES = new Set<RalplanStage>(["planner", "revision"]);
 
@@ -466,7 +466,6 @@ function parseRalplanAutoHandoffTarget(value: unknown): RalplanAutoHandoffTarget
 
 type RalplanAutoHandoffOptions = {
 	planningStuck?: boolean;
-	teamAvailabilityProbe?: () => { available: true } | { available: false; reason: string };
 	/** The session's effective agent directory (see resolveWorkflowSetting). */
 	agentDir?: string;
 };
@@ -474,7 +473,7 @@ type RalplanAutoHandoffOptions = {
 function parsePresentRalplanAutoHandoff(value: unknown): WorkflowSettingParseResult<RalplanAutoHandoffTarget> {
 	const target = parseRalplanAutoHandoffTarget(value);
 	return target === undefined
-		? { kind: "invalid", reason: "expected gjc.ralplan.autoHandoff to be one of off, ultragoal, team" }
+		? { kind: "invalid", reason: "expected gjc.ralplan.autoHandoff to be one of off, ultragoal, autoresearch" }
 		: { kind: "valid", value: target };
 }
 
@@ -500,18 +499,7 @@ function resolveRalplanAutoHandoffTarget(
 	if (options.planningStuck) {
 		return { configuredTarget, effectiveTarget: "off", degradationReason: "planning_stuck", source };
 	}
-	if (configuredTarget !== "team")
-		return { configuredTarget, effectiveTarget: configuredTarget, degradationReason: null, source };
-
-	const availability = (options.teamAvailabilityProbe ?? probeGjcTeamAvailability)();
-	return availability.available
-		? { configuredTarget, effectiveTarget: "team", degradationReason: null, source }
-		: {
-				configuredTarget,
-				effectiveTarget: "off",
-				degradationReason: `team_unavailable:${availability.reason}`,
-				source,
-			};
+	return { configuredTarget, effectiveTarget: configuredTarget, degradationReason: null, source };
 }
 
 function parseMaxReviewPassesPerLaneValue(value: unknown): number | null {

package/src/gjc-runtime/session-layout.ts

@@ -125,8 +125,22 @@ export function sessionLogsDir(cwd: string, gjcSessionId: string): string {
 export function sessionRuntimeDir(cwd: string, gjcSessionId: string): string {
 	return path.join(sessionRoot(cwd, gjcSessionId), "runtime");
 }
-export function sessionRlmDir(cwd: string, gjcSessionId: string): string {
-	return path.join(sessionRoot(cwd, gjcSessionId), "rlm");
+export function sessionIpykernelsDir(cwd: string, gjcSessionId: string): string {
+	return path.join(sessionRoot(cwd, gjcSessionId), "ipykernels");
+}
+export function sessionIpykernelsArtifactsDir(cwd: string, gjcSessionId: string): string {
+	return path.join(sessionIpykernelsDir(cwd, gjcSessionId), "artifacts");
+}
+export function pythonKernelTranscriptPath(cwd: string, gjcSessionId: string, dirName: string): string {
+	const normalized = dirName.trim();
+	assertSafePathComponent(normalized, "python kernel transcript dirName");
+	return path.join(sessionIpykernelsDir(cwd, gjcSessionId), normalized, "transcript.jsonl");
+}
+export function sessionAutoresearchDir(cwd: string, gjcSessionId: string): string {
+	return path.join(sessionRoot(cwd, gjcSessionId), "autoresearch");
+}
+export function sessionAutoresearchRunsDir(cwd: string, gjcSessionId: string): string {
+	return path.join(sessionAutoresearchDir(cwd, gjcSessionId), "runs");
 }
 
 // ---- Nested resolvers under <sessionRoot>/state ----
@@ -153,9 +167,6 @@ export function auditPath(cwd: string, gjcSessionId: string): string {
 export function transactionJournalPath(cwd: string, gjcSessionId: string, mutationId: string): string {
 	return path.join(sessionStateDir(cwd, gjcSessionId), "transactions", `${encodeSessionSegment(mutationId)}.json`);
 }
-export function teamStateRoot(cwd: string, gjcSessionId: string): string {
-	return path.join(sessionStateDir(cwd, gjcSessionId), "team");
-}
 export function workflowGatePath(cwd: string, gjcSessionId: string, gateId: string): string {
 	return path.join(sessionStateDir(cwd, gjcSessionId), "workflow-gates", `${encodeSessionSegment(gateId)}.json`);
 }
@@ -173,8 +184,8 @@ export function tmuxRuntimeSessionPath(cwd: string, gjcSessionId: string, slug:
 	assertSafePathComponent(normalized, "slug");
 	return path.join(sessionRuntimeDir(cwd, gjcSessionId), "tmux-sessions", `${normalized}.json`);
 }
-export function rlmArtifactRoot(cwd: string, gjcSessionId: string, rlmSessionId: string): string {
+export function autoresearchRlmArtifactRoot(cwd: string, gjcSessionId: string, rlmSessionId: string): string {
 	const normalized = rlmSessionId.trim();
 	if (normalized === "") throw new Error("rlmSessionId is required");
-	return path.join(sessionRlmDir(cwd, gjcSessionId), encodeSessionSegment(normalized));
+	return path.join(sessionAutoresearchRunsDir(cwd, gjcSessionId), encodeSessionSegment(normalized));
 }

package/src/gjc-runtime/session-state-sidecar.ts

@@ -5,6 +5,12 @@ import * as path from "node:path";
 import type { AssistantMessage } from "@gajae-code/ai/core";
 import { normalizePathForComparison, postmortem } from "@gajae-code/utils";
 import { withFileLock } from "../config/file-lock";
+import {
+	ensureCoordinatorDirectory,
+	syncCoordinatorDirectory,
+	syncCoordinatorFile,
+	writeCoordinatorAtomic,
+} from "../coordinator-mcp/durability";
 import { reduceTerminalReceiptState } from "../sdk/receipt-state";
 import { TOOL_CATALOG } from "../tools/tool-catalog.generated";
 import { sessionRoot, sessionRuntimeDir } from "./session-layout";
@@ -648,6 +654,7 @@ export async function persistCoordinatorRuntimeInputReady(): Promise<RuntimeInpu
 		if (existing.session_id !== expected.sessionId || existing.launch_id !== expected.launchId) {
 			throw runtimeReadinessMarkerConflict();
 		}
+		await syncCoordinatorDirectory(path.dirname(readinessFile));
 		return existing;
 	}
 
@@ -665,21 +672,64 @@ export async function persistCoordinatorRuntimeInputReady(): Promise<RuntimeInpu
 		path.dirname(readinessFile),
 		`.${path.basename(readinessFile)}.${process.pid}.${randomUUID()}.tmp`,
 	);
+	let result: RuntimeInputReadyMarker | null = null;
+	let primaryError: unknown;
 	try {
-		await fs.mkdir(path.dirname(readinessFile), { recursive: true });
-		await fs.writeFile(tempFile, `${JSON.stringify(marker)}\n`, { flag: "wx" });
+		await ensureCoordinatorDirectory(path.dirname(readinessFile));
+		const handle = await fs.open(tempFile, "wx", 0o600);
+		let writeError: unknown;
+		try {
+			await handle.writeFile(`${JSON.stringify(marker)}\n`);
+			await syncCoordinatorFile(handle);
+		} catch (error) {
+			writeError = error;
+		}
+		try {
+			await handle.close();
+		} catch (closeError) {
+			if (writeError) throw new AggregateError([writeError, closeError], "readiness write and close failed");
+			throw closeError;
+		}
+		if (writeError) throw writeError;
 		try {
 			await fs.link(tempFile, readinessFile);
 		} catch (error) {
-			if ((error as { code?: unknown }).code !== "EEXIST") throw runtimeReadinessMarkerConflict();
+			if ((error as { code?: unknown }).code !== "EEXIST") throw error;
 			const raced = await readRuntimeInputReadyMarker(readinessFile);
-			if (raced && raced.session_id === expected.sessionId && raced.launch_id === expected.launchId) return raced;
-			throw runtimeReadinessMarkerConflict();
+			if (raced && raced.session_id === expected.sessionId && raced.launch_id === expected.launchId) {
+				await syncCoordinatorDirectory(path.dirname(readinessFile));
+				result = raced;
+			} else {
+				throw runtimeReadinessMarkerConflict();
+			}
 		}
-		return marker;
-	} finally {
+		if (result === null) {
+			await syncCoordinatorDirectory(path.dirname(readinessFile));
+			result = marker;
+		}
+	} catch (error) {
+		primaryError = error;
+	}
+	let cleanupError: unknown;
+	try {
 		await fs.rm(tempFile, { force: true });
+	} catch (error) {
+		cleanupError = error;
 	}
+	let cleanupBarrierError: unknown;
+	if (!cleanupError) {
+		try {
+			await syncCoordinatorDirectory(path.dirname(readinessFile));
+		} catch (error) {
+			cleanupBarrierError = error;
+		}
+	}
+	const failures = [primaryError, cleanupError, cleanupBarrierError].filter(
+		(error): error is unknown => error !== undefined,
+	);
+	if (failures.length > 1) throw new AggregateError(failures, "readiness publication and cleanup failed");
+	if (failures.length === 1) throw failures[0];
+	return result;
 }
 
 function sameResolvedPath(left: string, right: string, platform: NodeJS.Platform = process.platform): boolean {
@@ -1268,8 +1318,7 @@ async function withCoordinatorTransactionLock<T>(stateFile: string, operation: (
 }
 
 async function writeStateFile(stateFile: string, payload: Record<string, unknown>): Promise<void> {
-	await fs.mkdir(path.dirname(stateFile), { recursive: true });
-	await Bun.write(stateFile, `${JSON.stringify(payload)}\n`);
+	await writeCoordinatorAtomic(stateFile, `${JSON.stringify(payload)}\n`);
 }
 
 function contextWithManagedOwnerGeneration(context: RuntimeStateContext): RuntimeStateContext {

package/src/gjc-runtime/state-renderer.ts

@@ -288,44 +288,6 @@ export function renderUltragoalStatusMarkdown(summary: {
 	return `${lines.join("\n")}\n`;
 }
 
-export function renderTeamStatusMarkdown(snapshot: {
-	team_name: string;
-	phase: string;
-	tmux_target?: string;
-	tmux_session?: string;
-	state_dir: string;
-	task_total: number;
-	task_counts: Record<string, number>;
-	workers: Array<{ id: string; status: string }>;
-	notification_summary?: { total: number; replay_eligible: number; by_state: Record<string, number> };
-	integration_by_worker?: Record<string, { status?: string; conflict_files?: string[] }>;
-}): string {
-	const counts = Object.entries(snapshot.task_counts)
-		.map(([key, value]) => `${key}=${value}`)
-		.join(" ");
-	const lines = [
-		"# team status",
-		"",
-		`- team: ${snapshot.team_name}`,
-		`- phase: ${snapshot.phase}`,
-		`- tmux: ${snapshot.tmux_target || snapshot.tmux_session || "none"}`,
-		`- state: ${snapshot.state_dir}`,
-		`- tasks: ${snapshot.task_total} (${counts})`,
-		`- workers: ${snapshot.workers.length} (${snapshot.workers.map(worker => `${worker.id}:${worker.status}`).join(" ")})`,
-	];
-	if (snapshot.notification_summary) {
-		lines.push(
-			`- notifications: total=${snapshot.notification_summary.total} replay_eligible=${snapshot.notification_summary.replay_eligible}`,
-		);
-	}
-	const integrations = Object.entries(snapshot.integration_by_worker ?? {});
-	if (integrations.length)
-		lines.push(
-			`- integrations: ${integrations.map(([worker, state]) => `${worker}:${state.status ?? "unknown"}`).join(" ")}`,
-		);
-	return `${lines.join("\n")}\n`;
-}
-
 export function renderStateMarkdown(
 	skill: CanonicalGjcWorkflowSkill,
 	stateJson: Record<string, unknown>,

package/src/gjc-runtime/state-runtime.ts

@@ -15,11 +15,12 @@ import {
 } from "../skill-state/active-state";
 import { initialPhaseForSkill } from "../skill-state/initial-phase";
 import {
+	buildAutoresearchHudSummary,
 	buildRalplanHudSummary,
-	buildTeamHudSummary,
 	buildUltragoalHudSummary,
 	deriveDeepInterviewHud,
 } from "../skill-state/workflow-hud";
+
 import {
 	type AuditEntry,
 	buildWorkflowStateReceipt,
@@ -923,27 +924,47 @@ function buildHudForMode(
 				updatedAt,
 			});
 		}
-		case "team": {
-			const teamPhase = typeof payload.phase === "string" ? (payload.phase as string) : (phase ?? "running");
-			const taskCounts =
-				typeof payload.task_counts === "object" && payload.task_counts && !Array.isArray(payload.task_counts)
-					? (payload.task_counts as Record<string, number>)
-					: {};
-			const taskTotal = typeof payload.task_total === "number" ? (payload.task_total as number) : 0;
-			const workers = Array.isArray(payload.workers)
-				? (payload.workers as Array<{ id?: string; status?: string }>)
-						.filter(w => w && typeof w.id === "string")
-						.map(w => ({
-							id: w.id as string,
-							status: typeof w.status === "string" ? (w.status as string) : undefined,
-						}))
-				: [];
-			return buildTeamHudSummary({
-				phase: teamPhase,
-				task_total: taskTotal,
-				task_counts: taskCounts,
-				workers,
-				updated_at: updatedAt,
+		case "autoresearch": {
+			const missionPhase = typeof payload.current_phase === "string" ? payload.current_phase : (phase ?? "intake");
+			const mode = typeof payload.mode === "string" ? payload.mode : undefined;
+			const intake = typeof payload.intake === "string" ? payload.intake : undefined;
+			const slug = typeof payload.slug === "string" ? payload.slug : undefined;
+			const specPath =
+				typeof payload.spec_path === "string"
+					? payload.spec_path
+					: typeof payload.specPath === "string"
+						? payload.specPath
+						: undefined;
+
+			const verdict =
+				payload.verdict && typeof payload.verdict === "object" && !Array.isArray(payload.verdict)
+					? (payload.verdict as Record<string, unknown>)
+					: undefined;
+			const verdictValue = verdict
+				? typeof verdict.status === "string"
+					? verdict.status
+					: verdict.status && typeof verdict.status === "object"
+						? JSON.stringify(verdict.status).slice(0, 40)
+						: undefined
+				: undefined;
+			const rawExperiments = Array.isArray(payload.experiments) ? payload.experiments : [];
+			const experimentStatuses = rawExperiments
+				.map(item =>
+					item && typeof item === "object" && typeof (item as Record<string, unknown>).status === "string"
+						? ((item as Record<string, unknown>).status as string)
+						: undefined,
+				)
+				.filter((status): status is string => Boolean(status));
+			return buildAutoresearchHudSummary({
+				phase: missionPhase,
+				mode,
+				intake,
+				slug,
+				verdict: verdictValue,
+				specPath,
+				experimentCount: experimentStatuses.length,
+				experimentStatuses,
+				updatedAt,
 			});
 		}
 		default:

package/src/gjc-runtime/state-schema.ts

@@ -12,9 +12,9 @@
  */
 import * as fs from "node:fs/promises";
 import { z } from "zod";
+import { CANONICAL_GJC_WORKFLOW_SKILLS } from "../skill-state/canonical-skills";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-version";
 
-const CANONICAL_GJC_WORKFLOW_SKILLS = ["deep-interview", "ralplan", "ultragoal", "team"] as const;
 const skillEnum = z.enum([...CANONICAL_GJC_WORKFLOW_SKILLS]);
 const ownerEnum = z.enum(["gjc-state-cli", "gjc-runtime", "gjc-hook"]);
 const receiptStatusEnum = z.enum(["fresh", "stale"]);

package/src/gjc-runtime/tmux-common.ts

@@ -56,14 +56,14 @@ export function envDisabled(value: string | undefined): boolean {
  * Resolve the tmux (or tmux-compatible multiplexer) command GJC should invoke.
  *
  * This is the shared entry point used by every GJC code path that needs to talk
- * to a multiplexer: `gjc --tmux` planning, `gjc session ...`, `gjc team ...`,
+ * to a multiplexer: `gjc --tmux` planning and `gjc session ...`,
  * the lifecycle controller, and the harness resident owner. Routing all of
  * them through the same resolver means a single `GJC_TMUX_COMMAND` override or
  * a single Windows psmux / pmux detection wins for the whole process — the
  * failure mode where `gjc --tmux` creates a psmux-backed session and then
  * `gjc session status` fails because it queries literal `tmux` is closed off.
  *
- * Explicit `GJC_TMUX_COMMAND` / `GJC_TEAM_TMUX_COMMAND` overrides are honored on
+ * Explicit `GJC_TMUX_COMMAND` overrides are honored on
  * every platform. On native Windows without an override the resolver walks
  * `psmux`, then `pmux`, then `tmux` and uses the first binary present on PATH.
  * On POSIX the resolver returns `tmux` (the historical default) and only
@@ -124,10 +124,10 @@ export const GJC_TMUX_UNTAGGED_REASON = "gjc_tmux_session_untagged";
 export function buildGjcTmuxUntaggedSessionHint(tmuxCommand: string): string {
 	return (
 		`the active multiplexer "${tmuxCommand}" lists this session but did not return GJC's ${GJC_TMUX_PROFILE_OPTION} ownership tag; ` +
-		"GJC-managed sessions and `gjc team` require a tmux provider that round-trips tmux user options. " +
+		"GJC-managed sessions require a tmux provider that round-trips tmux user options. " +
 		"On Windows psmux, GJC persists a ProviderAuthority that binds the exact executable identity and an isolated `-L <namespace>` server namespace for the owner generation. " +
 		"Recover through GJC so it reuses that persisted authority; do not retry against ambient tmux/psmux or a raw `-L` namespace. " +
-		"GJC_TMUX_COMMAND and GJC_TEAM_TMUX_COMMAND are binary overrides, not shell command lines."
+		"GJC_TMUX_COMMAND is a binary override, not a shell command line."
 	);
 }
 
@@ -233,7 +233,7 @@ export function buildGjcTmuxRequiredProfileCommands(
  * 3.3.0. psmux does not support the tmux `set-window-option` command at all
  * (it reports "unknown command: set-window-option") and silently drops several
  * `set-option` keys. The list lives here so every code path that tags a tmux
- * session (gjc --tmux planning, gjc session create, gjc team bootstrap)
+ * session (gjc --tmux planning, gjc session create)
  * applies the same filter.
  */
 const PSMUX_UNSUPPORTED_PROFILE_KEYS = new Set(["mouse", "set-clipboard", "mode-style"]);
@@ -270,11 +270,11 @@ export function buildGjcTmuxProfileCommands(
 	// psmux does not implement set-window-option and historically drops
 	// mouse / set-clipboard / mode-style. Filter the UX profile commands
 	// centrally so every code path that tags a session (gjc --tmux planning,
-	// gjc session create, gjc team bootstrap) drops the same set. The
+	// gjc session create) drops the same set. The
 	// GJC_PSMUX_PROFILE_FORCE override lets the operator opt back in when
 	// running on a psmux build that has caught up. The ownership-tag
 	// round-trip (set-option @gjc-*) is never filtered, since gjc session /
-	// gjc team rely on it.
+	// tmux-backed sessions rely on it.
 	// The filter is opt-in: callers that explicitly pass `opts.tmuxCommand`
 	// name a psmux-class multiplexer (psmux / pmux) when they want the UX
 	// profile filtered. Auto-detect on Windows hosts where psmux happens