@nseng-ai/ccc 0.1.1

package/src/ns/autobranch/flow.ts

@@ -0,0 +1,18 @@
+import type {
+	FlowAutobranchCheckpointInput,
+	FlowAutobranchCheckpointResult,
+	FlowAutobranchFileStat,
+	FlowAutobranchRequest,
+} from "@nseng-ai/flow/api";
+import { createFlowAutobranchCheckpointFlow } from "@nseng-ai/flow/api";
+
+export type AutobranchFlowInput = FlowAutobranchCheckpointInput;
+export type AutobranchFlowResult = FlowAutobranchCheckpointResult;
+export type FileStat = FlowAutobranchFileStat;
+export type ParsedAutobranchArgs = FlowAutobranchRequest;
+
+export async function createAutobranchCheckpointFlow(
+	input: AutobranchFlowInput,
+): Promise<AutobranchFlowResult> {
+	return await createFlowAutobranchCheckpointFlow(input);
+}

package/src/ns/autoslot-presentation.ts

@@ -0,0 +1,33 @@
+// CCC-local facade for the `autoslot` workflow's durable outcomes.
+//
+// `autoslot` (autobranch + slot checkout) is orchestrated in CCC and reports typed settled facts here,
+// while the generic finite block layout now lives in `@nseng-ai/foundation/cli-theme` because the repeated shape was
+// proven across Flow and CCC. This module keeps autoslot's domain-local type name and owns the mapping
+// from CCC outcome facts to that shared layout.
+
+import type { Caps } from "@nseng-ai/clinkr";
+import { renderResultBlock } from "@nseng-ai/foundation/cli-theme";
+
+/**
+ * The visual intent of an autoslot outcome. Distinct from the `NsCommandIo` notify level (which owns
+ * stdout/stderr routing and exit-code flipping): a declined guardrail renders `refusal` (warn) even
+ * when it is notified at `error` level to flip the exit code (house-style §7.3).
+ */
+export type AutoslotResultKind = "success" | "refusal" | "failure";
+
+export interface AutoslotResultBlock {
+	kind: AutoslotResultKind;
+	/** Leading one-line summary (already-phrased prose); rendered bold + intent-painted with a glyph. */
+	headline: string;
+	/** The working directory the workflow operated in, shown as dimmed plumbing evidence. */
+	cwd: string;
+	/** Domain-authored detail (slot target / skip reason / failure cause) at normal weight. */
+	body?: string;
+	/** Optional normal-weight "what to do next" line (e.g. the copyable `ns slot co <branch>`). */
+	guidance?: string;
+}
+
+/** Render an autoslot result block to a string, styled and degraded for `caps`. */
+export function renderAutoslotResultBlock(caps: Caps, input: AutoslotResultBlock): string {
+	return renderResultBlock(caps, input);
+}

package/src/ns/autoslot.ts

@@ -0,0 +1,2 @@
+export type { AutoslotCliInput, AutoslotFlowInput } from "@nseng-ai/flow/api";
+export { createAutoslotFlow, runAutoslotCli } from "@nseng-ai/flow/api";

package/src/ns/cli-command-io.ts

@@ -0,0 +1,23 @@
+import {
+	createCliCommandIo,
+	type CliCommandIoInput,
+	type CliCommandIoOptions,
+} from "@nseng-ai/ns/kernel/command-io";
+import type { NsCommandIo } from "@nseng-ai/ns/kernel/sdk";
+
+/** Minimal CLI stream/callback surface that CCC standalone commands adapt to NsCommandIo. */
+export type CccCliCommandIoInput = CliCommandIoInput;
+
+export type CccCliCommandIoOptions = CliCommandIoOptions;
+
+/**
+ * CCC edge adapter mapping CLI stdout/stderr/onOutput callbacks onto an NsCommandIo.
+ * The implementation lives in the kernel because command I/O is an intrinsic
+ * SDK service, not CCC orchestration behavior.
+ */
+export function createCccCliCommandIo(
+	input: CccCliCommandIoInput,
+	options: CccCliCommandIoOptions = {},
+): NsCommandIo {
+	return createCliCommandIo(input, options);
+}

package/src/ns/cli.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+import { z } from "zod";
+
+import { ClinkrGroup, failure, negative, ok, type ClinkrExit } from "@nseng-ai/clinkr";
+import { defineCli, type CliEntrypointDeps } from "@nseng-ai/foundation/cli-runtime";
+import { NodeCommandExecApi } from "@nseng-ai/foundation/exec";
+import type { CommandExecApi } from "@nseng-ai/foundation/command";
+
+import {
+	commitAutobranchCheckpointMessage,
+	prepareAutobranchCheckpointMessage,
+} from "./autobranch/checkpoint.ts";
+import {
+	createFlowAutobranchCheckpointFlow,
+	type FlowAutobranchCheckpointInput,
+	type FlowAutobranchRequest,
+} from "@nseng-ai/flow/api";
+import {
+	applyCmuxWorkspaceSummaryCommand,
+	cmuxWorkspaceSummaryRequestSchema,
+	cmuxWorkspaceSummaryResultSchema,
+	renderCmuxWorkspaceSummaryHuman,
+} from "../cmux/workspace-summary.ts";
+
+export const AUTOBRANCH_SUMMARY =
+	"Create a Graphite branch from dirty worktree changes or the latest unpushed commit.";
+
+type AutobranchSeamOverrides = Partial<
+	Pick<
+		FlowAutobranchCheckpointInput,
+		"prepareCheckpointMessage" | "commitPreparedCheckpointMessage" | "readFile" | "stat" | "now"
+	>
+>;
+
+export interface CccCliDeps extends Pick<CliEntrypointDeps, "cwd" | "env" | "stdout" | "stderr"> {
+	commands?: CommandExecApi;
+	autobranch?: AutobranchSeamOverrides;
+}
+
+export interface CccCliContext {
+	commands: CommandExecApi;
+	cwd: string;
+	env: Record<string, string | undefined>;
+	stdout: (text: string) => void;
+	stderr: (text: string) => void;
+	autobranch?: AutobranchSeamOverrides;
+}
+
+const autobranchRequestSchema = z.object({
+	slug: z
+		.string()
+		.optional()
+		.describe("Branch slug to use instead of deriving one from the worktree or latest commit."),
+});
+
+type AutobranchRequest = z.infer<typeof autobranchRequestSchema>;
+
+const autobranchSuccessSchema = z.object({
+	summary: z.string(),
+	warnings: z.array(z.string()),
+});
+
+const autobranchErrorDataSchema = z.object({
+	outcome: z.enum(["refusal", "failure"]),
+});
+
+const autobranchResultSchema = z.union([autobranchSuccessSchema, autobranchErrorDataSchema]);
+
+type AutobranchResult = z.infer<typeof autobranchResultSchema>;
+type AutobranchErrorData = z.infer<typeof autobranchErrorDataSchema>;
+
+const entry = defineCli<CccCliContext, CccCliDeps, undefined>({
+	metaUrl: import.meta.url,
+	runtime: "typescript",
+	description: "CCC repo orchestration tools.",
+	prepareRun: ({ deps, cwd, env, stdout, stderr }) => {
+		const resolvedStdout = deps.stdout ?? stdout;
+		const resolvedStderr = deps.stderr ?? stderr;
+		const context: CccCliContext = {
+			commands: deps.commands ?? new NodeCommandExecApi(),
+			cwd: deps.cwd ?? cwd,
+			env: deps.env ?? env,
+			stdout: resolvedStdout,
+			stderr: resolvedStderr,
+			...(deps.autobranch === undefined ? {} : { autobranch: deps.autobranch }),
+		};
+		return { type: "run", context, buildState: undefined };
+	},
+	configureCli: ({ root }) => {
+		const execGroup = new ClinkrGroup<CccCliContext>({
+			name: "exec",
+			description: "Run hidden deterministic CCC operations for agents.",
+			isHidden: true,
+		});
+		execGroup.command({
+			name: "cmux-workspace-summary",
+			summary: "Apply generated cmux workspace title and description fields.",
+			description: "Apply generated cmux workspace title and description fields.",
+			schema: cmuxWorkspaceSummaryRequestSchema,
+			resultSchema: cmuxWorkspaceSummaryResultSchema,
+			handler: handleCmuxWorkspaceSummary,
+			renderHuman: renderCmuxWorkspaceSummaryHuman,
+		});
+		execGroup.command({
+			name: "autobranch",
+			summary: AUTOBRANCH_SUMMARY,
+			description: `Create a Graphite branch using \`gt create\` from dirty worktree changes or from the latest eligible unpushed commit.
+
+Dirty worktree mode stashes pending changes, creates a Graphite branch, restores the stash, and creates a checkpoint commit. Clean worktree mode moves the latest eligible unpushed non-merge commit onto a new Graphite branch using recovery-branch verification.`,
+			schema: autobranchRequestSchema,
+			resultSchema: autobranchResultSchema,
+			handler: handleAutobranch,
+			renderHuman: renderAutobranch,
+		});
+		root.group(execGroup);
+	},
+});
+
+export function buildCli(): ClinkrGroup<CccCliContext> {
+	return entry.buildCli(undefined);
+}
+
+export async function runCli(args: readonly string[], deps: CccCliDeps = {}): Promise<number> {
+	return await entry.run(args, deps);
+}
+
+async function handleCmuxWorkspaceSummary(
+	ctx: CccCliContext,
+	request: z.output<typeof cmuxWorkspaceSummaryRequestSchema>,
+) {
+	return applyCmuxWorkspaceSummaryCommand({
+		request,
+		commands: ctx.commands,
+		cwd: ctx.cwd,
+		env: ctx.env,
+	});
+}
+
+async function handleAutobranch(
+	ctx: CccCliContext,
+	request: AutobranchRequest,
+): Promise<ClinkrExit<AutobranchResult>> {
+	const args: FlowAutobranchRequest = request.slug === undefined ? {} : { slug: request.slug };
+	const autobranch = ctx.autobranch ?? {};
+	const result = await createFlowAutobranchCheckpointFlow({
+		cwd: ctx.cwd,
+		args,
+		exec: (command, commandArgs, timeout) =>
+			ctx.commands.exec(command, commandArgs, { cwd: ctx.cwd, timeout, env: ctx.env }),
+		prepareCheckpointMessage:
+			autobranch.prepareCheckpointMessage ??
+			((snapshot) => prepareAutobranchCheckpointMessage(snapshot, ctx.env)),
+		commitPreparedCheckpointMessage:
+			autobranch.commitPreparedCheckpointMessage ??
+			((message) =>
+				commitAutobranchCheckpointMessage(
+					(command, commandArgs, commandCwd, timeout) =>
+						ctx.commands.exec(command, commandArgs, { cwd: commandCwd, timeout, env: ctx.env }),
+					ctx.cwd,
+					message,
+				)),
+		...(autobranch.readFile === undefined ? {} : { readFile: autobranch.readFile }),
+		...(autobranch.stat === undefined ? {} : { stat: autobranch.stat }),
+		...(autobranch.now === undefined ? {} : { now: autobranch.now }),
+	});
+
+	if (!result.ok) {
+		const data: AutobranchErrorData = { outcome: result.outcome };
+		if (result.outcome === "refusal") {
+			return negative(result.error, { data, human: result.error });
+		}
+		return failure("autobranch-failed", result.error, data);
+	}
+	for (const warning of result.warnings) {
+		ctx.stderr(`${warning.trimEnd()}\n`);
+	}
+	return ok({ summary: result.summary, warnings: result.warnings });
+}
+
+function renderAutobranch(result: AutobranchResult): string {
+	if (!("summary" in result)) return result.outcome;
+	return result.summary;
+}
+
+await entry.runIfMain({ isImportMetaMain: import.meta.main });

package/src/ns/land.ts

@@ -0,0 +1,12 @@
+export type {
+	ExecResult,
+	ExtensionMode,
+	LandCliConfirmPrompt,
+	LandCommandContext,
+	LandCliInput,
+	LandExtensionAPI,
+	NotifyLevel,
+	PrintOutput,
+	ValidPullRequestView,
+} from "@nseng-ai/flow/api";
+export { parsePullRequestView, registerLandCommand, runLandCli } from "@nseng-ai/flow/api";

package/src/ns/trunk-pull.ts

@@ -0,0 +1,2 @@
+export type { TrunkPullOutcome, TrunkPullResult } from "@nseng-ai/flow/api";
+export { runTrunkPullDetailed } from "@nseng-ai/flow/api";

package/src/pi/claude-plan-tab.ts

@@ -0,0 +1,32 @@
+import { registerCommandWithImmediateAck } from "@nseng-ai/pi/commands/ack";
+import {
+	CCC_CLAUDE_PLAN_TAB_COMMAND_NAME,
+	handleCccClaudePlanTab,
+	type PromptFileOptions,
+	resolvePromptFileOptions,
+} from "../api/handlers.ts";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+
+const COMMAND_NAME = CCC_CLAUDE_PLAN_TAB_COMMAND_NAME;
+const PROMPT_DIR = join(homedir(), ".pi", "agent", "ccc-claude-plan-tab-prompts");
+
+export function registerCccClaudePlanTabCommand(
+	pi: ExtensionAPI,
+	options: PromptFileOptions = {},
+): void {
+	const promptOptions = resolvePromptFileOptions(options, PROMPT_DIR);
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: COMMAND_NAME,
+		commandDefinition: {
+			description:
+				"Open a new cmux tab running Claude Code in plan mode, seeded with the provided prompt or last assistant message.",
+			argumentHint: "[seed prompt]",
+			handler: async (args, ctx) => {
+				await handleCccClaudePlanTab({ pi, ctx, args, promptOptions });
+			},
+		},
+	});
+}

package/src/pi/command-backed-skills.ts

@@ -0,0 +1,7 @@
+import { specializedCommandBackedSkillsFromSpecs } from "@nseng-ai/foundation/command";
+
+import { CCC_SIDEBAR_BRANCH_STATE_SUMMARY_COMMAND_NAME } from "../api/handlers.ts";
+
+export const cccCommandBackedSkillRegistrations = specializedCommandBackedSkillsFromSpecs([
+	{ skillName: "ccc-sidebar", surface: CCC_SIDEBAR_BRANCH_STATE_SUMMARY_COMMAND_NAME },
+]);

package/src/pi/dispatch-from-trunk.ts

@@ -0,0 +1,41 @@
+import { optionalEntry } from "@nseng-ai/foundation/primitives";
+import {
+	makeCommandProgressNotifier,
+	registerCommandWithImmediateAck,
+} from "@nseng-ai/pi/commands/ack";
+import {
+	CCC_WORKSPACE_DISPATCH_FROM_TRUNK_COMMAND_NAME,
+	handleCccSlotDispatchFromTrunk,
+	resolveDispatchPromptPayloadOptions,
+	type DispatchPromptPayloadOptions,
+} from "../api/handlers.ts";
+import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+
+const COMMAND_NAME = CCC_WORKSPACE_DISPATCH_FROM_TRUNK_COMMAND_NAME;
+
+export function registerCccSlotDispatchFromTrunkCommand(
+	pi: ExtensionAPI,
+	options: DispatchPromptPayloadOptions = {},
+): void {
+	const payloadOptions = resolveDispatchPromptPayloadOptions(options);
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: COMMAND_NAME,
+		commandDefinition: {
+			description:
+				"Create a Graphite-tracked branch from trunk/main and launch it in a new cmux workspace.",
+			argumentHint: "<task>",
+			handler: async (args, ctx) => {
+				const notifyProgress = makeCommandProgressNotifier({ host: pi, ctx });
+				await handleCccSlotDispatchFromTrunk({
+					pi,
+					payloadOptions,
+					args,
+					ctx,
+					...optionalEntry("slotClient", options.slotClient),
+					notifyProgress,
+				});
+			},
+		},
+	});
+}

package/src/pi/dispatch-prompt.ts

@@ -0,0 +1,41 @@
+import { optionalEntry } from "@nseng-ai/foundation/primitives";
+import {
+	makeCommandProgressNotifier,
+	registerCommandWithImmediateAck,
+} from "@nseng-ai/pi/commands/ack";
+import {
+	CCC_WORKSPACE_DISPATCH_PROMPT_COMMAND_NAME,
+	handleCccSlotDispatchPrompt,
+	type DispatchPromptPayloadOptions,
+	resolveDispatchPromptPayloadOptions,
+} from "../api/handlers.ts";
+import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+
+const COMMAND_NAME = CCC_WORKSPACE_DISPATCH_PROMPT_COMMAND_NAME;
+
+export function registerCccSlotDispatchPromptCommand(
+	pi: ExtensionAPI,
+	options: DispatchPromptPayloadOptions = {},
+): void {
+	const payloadOptions = resolveDispatchPromptPayloadOptions(options);
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: COMMAND_NAME,
+		commandDefinition: {
+			description:
+				"Create a Graphite-tracked branch and dispatch a prompt in a new cmux workspace.",
+			argumentHint: "<prompt>",
+			handler: async (args, ctx) => {
+				const notifyProgress = makeCommandProgressNotifier({ host: pi, ctx });
+				await handleCccSlotDispatchPrompt({
+					pi,
+					payloadOptions,
+					...optionalEntry("slotClient", options.slotClient),
+					args,
+					ctx,
+					notifyProgress,
+				});
+			},
+		},
+	});
+}

package/src/pi/extension.ts

@@ -0,0 +1,23 @@
+import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+import { registerCccClaudePlanTabCommand } from "./claude-plan-tab.ts";
+import { registerCccSlotDispatchFromTrunkCommand } from "./dispatch-from-trunk.ts";
+import { registerCccSlotDispatchPromptCommand } from "./dispatch-prompt.ts";
+import { createCccSidebarControllerWithPiWiring, registerCccSidebarCommands } from "./sidebar.ts";
+import {
+	registerCccSlotDispatchPlanCommand,
+	registerCccSurfaceDispatchPlanCommand,
+} from "./slot-dispatch-plan.ts";
+import { registerCccSlotOpenBranchCommand } from "./slot-open-branch.ts";
+
+export default function registerCccPiExtension(pi: ExtensionAPI): void {
+	const sidebarController = createCccSidebarControllerWithPiWiring(pi);
+	registerCccSidebarCommands(pi, sidebarController);
+	registerCccSlotDispatchPlanCommand(pi);
+	registerCccSurfaceDispatchPlanCommand(pi);
+	registerCccSlotOpenBranchCommand(pi);
+	registerCccSlotDispatchPromptCommand(pi);
+	registerCccSlotDispatchFromTrunkCommand(pi);
+	registerCccClaudePlanTabCommand(pi);
+}
+
+export { registerCccPiExtension };

package/src/pi/index.ts

@@ -0,0 +1,11 @@
+export { default, registerCccPiExtension } from "./extension.ts";
+export { cccCommandBackedSkillRegistrations } from "./command-backed-skills.ts";
+export { registerCccClaudePlanTabCommand } from "./claude-plan-tab.ts";
+export { registerCccSlotDispatchFromTrunkCommand } from "./dispatch-from-trunk.ts";
+export { registerCccSlotDispatchPromptCommand } from "./dispatch-prompt.ts";
+export {
+	registerCccSlotDispatchPlanCommand,
+	registerCccSurfaceDispatchPlanCommand,
+} from "./slot-dispatch-plan.ts";
+export { registerCccSlotOpenBranchCommand } from "./slot-open-branch.ts";
+export { registerCccSidebarCommands, createCccSidebarControllerWithPiWiring } from "./sidebar.ts";

package/src/pi/sidebar.ts

@@ -0,0 +1,58 @@
+import { registerCommandWithImmediateAck } from "@nseng-ai/pi/commands/ack";
+import { expandRepoSkillBlock } from "@nseng-ai/pi/skills/expansion";
+import {
+	CCC_SIDEBAR_BRANCH_STATE_SUMMARY_COMMAND_NAME,
+	CCC_SIDEBAR_OBJECTIVE_SUMMARY_COMMAND_NAME,
+	CCC_SIDEBAR_SESSION_SUMMARY_COMMAND_NAME,
+	createCccSidebarController,
+	type CccSidebarController,
+	type ObjectiveSidebarHandlerOptions,
+} from "../api/handlers.ts";
+import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+
+const SESSION_SIDEBAR_COMMAND_NAME = CCC_SIDEBAR_SESSION_SUMMARY_COMMAND_NAME;
+const BRANCH_STATE_SIDEBAR_COMMAND_NAME = CCC_SIDEBAR_BRANCH_STATE_SUMMARY_COMMAND_NAME;
+const OBJECTIVE_SIDEBAR_COMMAND_NAME = CCC_SIDEBAR_OBJECTIVE_SUMMARY_COMMAND_NAME;
+
+export function registerCccSidebarCommands(
+	pi: ExtensionAPI,
+	controller: CccSidebarController,
+): void {
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: SESSION_SIDEBAR_COMMAND_NAME,
+		commandDefinition: {
+			description: "Summarize this Pi session into the caller cmux sidebar.",
+			handler: async (_args, ctx) => controller.handleSessionCommand(ctx),
+		},
+	});
+
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: BRANCH_STATE_SIDEBAR_COMMAND_NAME,
+		commandDefinition: {
+			description:
+				"Summarize the current branch state versus its parent into the caller cmux sidebar.",
+			handler: async (_args, ctx) => controller.handleBranchStateCommand(ctx),
+		},
+	});
+
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: OBJECTIVE_SIDEBAR_COMMAND_NAME,
+		commandDefinition: {
+			description: "Format Objective overview into the caller cmux sidebar.",
+			argumentHint: "<slug or path>",
+			handler: async (args, ctx) => controller.handleObjectiveCommand(args, ctx),
+		},
+	});
+}
+
+export function createCccSidebarControllerWithPiWiring(pi: ExtensionAPI): CccSidebarController {
+	const objectiveSidebarOptions: ObjectiveSidebarHandlerOptions = {
+		expandSkillBlock: async (cwd, skillName) => expandRepoSkillBlock({ cwd, skillName }),
+	};
+	const controller = createCccSidebarController(pi, objectiveSidebarOptions);
+	pi.on("agent_end", controller.onAgentEnd);
+	return controller;
+}

package/src/pi/slot-dispatch-plan.ts

@@ -0,0 +1,70 @@
+import {
+	makeCommandProgressNotifier,
+	registerCommandWithImmediateAck,
+} from "@nseng-ai/pi/commands/ack";
+import { formatImplBranchContextCommand } from "@nseng-ai/branch-context/pi";
+import {
+	CCC_SURFACE_DISPATCH_PLAN_COMMAND_NAME,
+	CCC_WORKSPACE_DISPATCH_PLAN_COMMAND_NAME,
+	handleCccSlotDispatchPlan,
+	type CccSlotDispatchPlanOptions,
+	type DispatchPlanConfig,
+} from "../api/handlers.ts";
+import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+
+const WORKSPACE_COMMAND_NAME = CCC_WORKSPACE_DISPATCH_PLAN_COMMAND_NAME;
+const SURFACE_COMMAND_NAME = CCC_SURFACE_DISPATCH_PLAN_COMMAND_NAME;
+
+const WORKSPACE_CONFIG: DispatchPlanConfig = {
+	commandName: WORKSPACE_COMMAND_NAME,
+	statusKey: WORKSPACE_COMMAND_NAME,
+	destination: "workspace",
+};
+
+const SURFACE_CONFIG: DispatchPlanConfig = {
+	commandName: SURFACE_COMMAND_NAME,
+	statusKey: SURFACE_COMMAND_NAME,
+	destination: "surface",
+};
+
+export function registerCccSlotDispatchPlanCommand(
+	pi: ExtensionAPI,
+	options: CccSlotDispatchPlanOptions = {},
+): void {
+	registerDispatchPlanCommand(pi, WORKSPACE_CONFIG, options);
+}
+
+export function registerCccSurfaceDispatchPlanCommand(
+	pi: ExtensionAPI,
+	options: CccSlotDispatchPlanOptions = {},
+): void {
+	registerDispatchPlanCommand(pi, SURFACE_CONFIG, options);
+}
+
+function registerDispatchPlanCommand(
+	pi: ExtensionAPI,
+	config: DispatchPlanConfig,
+	options: CccSlotDispatchPlanOptions,
+): void {
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: config.commandName,
+		commandDefinition: {
+			description:
+				"Attach the latest session-saved plan to a new Graphite-tracked branch via branch-context and launch it in a new cmux workspace.",
+			argumentHint: "[--dry-run] [--help]",
+			handler: async (rawArgs, ctx) => {
+				const notifyProgress = makeCommandProgressNotifier({ host: pi, ctx });
+				await handleCccSlotDispatchPlan({
+					pi,
+					rawArgs,
+					ctx,
+					options,
+					config,
+					notifyProgress,
+					formatBranchContextCommand: formatImplBranchContextCommand,
+				});
+			},
+		},
+	});
+}

package/src/pi/slot-open-branch.ts

@@ -0,0 +1,39 @@
+import {
+	makeCommandProgressNotifier,
+	registerCommandWithImmediateAck,
+} from "@nseng-ai/pi/commands/ack";
+import {
+	CCC_WORKSPACE_OPEN_BRANCH_COMMAND_NAME,
+	handleCccSlotOpenBranch,
+	type CccSlotOpenBranchOptions,
+} from "../api/handlers.ts";
+import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+
+const COMMAND_NAME = CCC_WORKSPACE_OPEN_BRANCH_COMMAND_NAME;
+
+export function registerCccSlotOpenBranchCommand(
+	pi: ExtensionAPI,
+	options: CccSlotOpenBranchOptions = {},
+): void {
+	registerCommandWithImmediateAck({
+		host: pi,
+		commandName: COMMAND_NAME,
+		commandDefinition: {
+			description: "Open an existing Git branch in a new cmux workspace.",
+			argumentHint: "<branch>",
+			handler: async (args, ctx) => {
+				const notifyProgress = makeCommandProgressNotifier({ host: pi, ctx });
+				await handleCccSlotOpenBranch({
+					pi,
+					args,
+					ctx,
+					options,
+					notifyProgress,
+				});
+			},
+		},
+	});
+
+	// Note: Autocomplete provider setup moved here from CCC handler
+	// to preserve Pi-specific wiring in the adapter
+}