@nseng-ai/ccc 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nseng-ai/ccc",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"type": "module",
 	"files": [
 		"src"
@@ -26,15 +26,15 @@
 		"./pi/extension": "./src/pi/extension.ts"
 	},
 	"dependencies": {
-		"@nseng-ai/branch-context": "0.1.1",
-		"@nseng-ai/capability-kit": "0.1.1",
-		"@nseng-ai/clinkr": "0.1.1",
-		"@nseng-ai/foundation": "0.1.1",
-		"@nseng-ai/flow": "0.1.1",
-		"@nseng-ai/ns": "0.1.1",
-		"@nseng-ai/objectives": "0.1.1",
-		"@nseng-ai/plans": "0.1.1",
-		"@nseng-ai/slots": "0.1.1",
+		"@nseng-ai/branch-context": "0.1.2",
+		"@nseng-ai/capability-kit": "0.1.2",
+		"@nseng-ai/clinkr": "0.1.2",
+		"@nseng-ai/foundation": "0.1.2",
+		"@nseng-ai/flow": "0.1.2",
+		"@nseng-ai/kernel": "0.1.2",
+		"@nseng-ai/objectives": "0.1.2",
+		"@nseng-ai/plans": "0.1.2",
+		"@nseng-ai/slots": "0.1.2",
 		"zod": "^4.4.3"
 	},
 	"peerDependencies": {

package/src/cmux/branch-slug.ts

@@ -4,15 +4,15 @@ import {
 	sanitizeBranchName,
 	trimBranchSlugToLength,
 } from "@nseng-ai/foundation/branch-slug";
+import {
+	formatRawTextModelFailure,
+	generateRawTextWithModel,
+} from "@nseng-ai/capability-kit/model-slug";
 import type { TextResult } from "@nseng-ai/foundation/primitives";
 import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
 
 export { finalizeBranchSlug, MAX_BRANCH_SLUG_LENGTH, sanitizeBranchName, trimBranchSlugToLength };
 
-const GPT_NANO_PROVIDER = "openai";
-const GPT_NANO_MODEL = "gpt-5.4-nano";
-const SLUG_PROMPT_TIMEOUT_MS = 60_000;
-const SUMMARY_PROMPT_TIMEOUT_MS = 60_000;
 const MAX_SLUG_INPUT_CHARS = 12_000;
 const MAX_SUMMARY_INPUT_CHARS = 16_000;
 
@@ -31,7 +31,7 @@ export async function generateBranchSlug(
 	},
 ): Promise<TextResult> {
 	const prompt = buildSlugPrompt(input);
-	const result = await runGptNanoText(pi, cwd, prompt, SLUG_PROMPT_TIMEOUT_MS);
+	const result = await generateRawText(pi, cwd, prompt);
 	if (!result.ok) {
 		return {
 			ok: false,
@@ -56,12 +56,7 @@ export async function summarizePlanWithGptNano(
 		sourceLabel?: string;
 	},
 ): Promise<TextResult> {
-	const result = await runGptNanoText(
-		pi,
-		cwd,
-		buildPlanSummaryPrompt(input),
-		SUMMARY_PROMPT_TIMEOUT_MS,
-	);
+	const result = await generateRawText(pi, cwd, buildPlanSummaryPrompt(input));
 	if (!result.ok) {
 		return { ok: false, message: `Could not summarize plan with GPT Nano: ${result.message}` };
 	}
@@ -73,39 +68,20 @@ export async function summarizePlanWithGptNano(
 	return { ok: true, text: summary };
 }
 
-async function runGptNanoText(
+async function generateRawText(
 	pi: BranchSlugRuntime,
 	cwd: string,
 	prompt: string,
-	timeout: number,
 ): Promise<TextResult> {
-	const result = await pi.exec("pi", buildGptNanoTextArgs(prompt), { cwd, timeout });
-	if (result.code !== 0) {
-		const details = result.stderr.trim() || result.stdout.trim();
-		return { ok: false, message: details };
-	}
-	return { ok: true, text: result.stdout.trim() };
-}
-
-export function buildGptNanoTextArgs(prompt: string): string[] {
-	return [
-		"--provider",
-		GPT_NANO_PROVIDER,
-		"--model",
-		GPT_NANO_MODEL,
-		"--thinking",
-		"low",
-		"--no-session",
-		"--no-extensions",
-		"--no-skills",
-		"--no-prompt-templates",
-		"--no-context-files",
-		"--no-tools",
-		"--mode",
-		"text",
-		"--print",
+	const result = await generateRawTextWithModel({
+		cwd,
 		prompt,
-	];
+		exec: (command, args, options) => pi.exec(command, args, options),
+	});
+	if (!result.ok) {
+		return { ok: false, message: formatRawTextModelFailure(result.failure) };
+	}
+	return { ok: true, text: result.evidence.rawOutput.trim() };
 }
 
 export function buildSlugPrompt(input: {

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

@@ -6,11 +6,23 @@ import {
 	piExecApiToCommandExecApi,
 } from "@nseng-ai/foundation/command";
 import { firstNonEmptyLine } from "@nseng-ai/foundation/text-normalization";
+import { isAbsolute, resolve } from "node:path";
+
 import {
 	planLocalBranchRefreshFromWorktrees,
 	type LocalBranchRefreshPlan,
 } from "@nseng-ai/capability-kit/git";
 import { runGraphiteCommand } from "@nseng-ai/capability-kit/graphite/branch";
+import {
+	createGraphiteMetadataDbAccess,
+	GRAPHITE_BRANCH_METADATA_QUERY,
+	GRAPHITE_BRANCH_METADATA_SCHEMA_QUERY,
+	graphiteMetadataDbPath,
+	hasExpectedGraphiteBranchMetadataSchema,
+	parseGraphiteBranchMetadataRows,
+	resolveGraphiteTrunkBranchFromTopology,
+	type GraphiteMetadataDbAccess,
+} from "@nseng-ai/capability-kit/graphite/metadata";
 import { optionalEntry } from "@nseng-ai/foundation/primitives";
 
 import { CCC_WORKSPACE_DISPATCH_FROM_TRUNK_COMMAND_NAME } from "./command-surfaces.ts";
@@ -30,12 +42,19 @@ const GIT_TRUNK_REFRESH_TIMEOUT_MS = 2 * 60 * 1000;
 const TRUNK_DISPATCH_CONTEXT_NOTE =
 	"This branch was created from refreshed Graphite trunk and is intentionally unrelated to the caller's current stack.";
 
+interface GraphiteTrunkResolutionContext {
+	pi: Pick<ExtensionAPI, "exec">;
+	cwd: string;
+	metadataDbAccess: GraphiteMetadataDbAccess;
+}
+
 export async function handleCccSlotDispatchFromTrunk(options: {
 	pi: Pick<ExtensionAPI, "exec" | "getThinkingLevel">;
 	payloadOptions: ReturnType<typeof resolveDispatchPromptPayloadOptions>;
 	args: string;
 	ctx: CommandContext;
 	slotClient?: SlotClient;
+	metadataDbAccess?: GraphiteMetadataDbAccess;
 	notifyProgress: (message: string) => void;
 }): Promise<void> {
 	const { pi, payloadOptions, args, ctx } = options;
@@ -45,13 +64,13 @@ export async function handleCccSlotDispatchFromTrunk(options: {
 		return;
 	}
 
-	options.notifyProgress("Resolving Graphite trunk…");
 	await ctx.waitForIdle();
 	const branch = await createTrackedBranchFromTrunkForPrompt({
 		pi,
 		cwd: ctx.cwd,
 		prompt,
 		notify: options.notifyProgress,
+		...optionalEntry("metadataDbAccess", options.metadataDbAccess),
 	});
 	if ("error" in branch) {
 		ctx.ui.notify(branch.error, "error");
@@ -75,26 +94,17 @@ export async function createTrackedBranchFromTrunkForPrompt(options: {
 	cwd: string;
 	prompt: string;
 	notify?: (message: string) => void;
+	metadataDbAccess?: GraphiteMetadataDbAccess;
 }): Promise<BranchCreateResult | { error: string }> {
 	const { pi, cwd, prompt, notify } = options;
 	notify?.("Resolving Graphite trunk…");
-	const trunk = await runGraphiteCommand(execApiToCommandRunner(piExecApiToCommandExecApi(pi)), {
+	const trunk = await resolveGraphiteTrunkBranch({
+		pi,
 		cwd,
-		args: ["trunk", "--no-interactive"],
+		metadataDbAccess: options.metadataDbAccess ?? createGraphiteMetadataDbAccess(),
 	});
-	if (!commandSucceeded(trunk)) {
-		return {
-			error: formatCommandFailure(
-				"Could not resolve Graphite trunk.",
-				"gt trunk --no-interactive",
-				trunk,
-			),
-		};
-	}
-	const trunkBranch = firstNonEmptyLine(trunk.stdout);
-	if (trunkBranch === undefined) {
-		return { error: "gt trunk --no-interactive returned no branch." };
-	}
+	if ("error" in trunk) return trunk;
+	const trunkBranch = trunk.branch;
 
 	notify?.("Refreshing Graphite trunk…");
 	const refresh = await refreshLocalTrunkBranch({ pi, cwd, trunkBranch });
@@ -124,6 +134,86 @@ export async function createTrackedBranchFromTrunkForPrompt(options: {
 	});
 }
 
+async function resolveGraphiteTrunkBranch(
+	context: GraphiteTrunkResolutionContext,
+): Promise<{ branch: string } | { error: string }> {
+	const { pi, cwd } = context;
+	const trunk = await runGraphiteCommand(execApiToCommandRunner(piExecApiToCommandExecApi(pi)), {
+		cwd,
+		args: ["trunk", "--no-interactive"],
+	});
+	if (commandSucceeded(trunk)) {
+		const trunkBranch = firstNonEmptyLine(trunk.stdout);
+		if (trunkBranch === undefined) {
+			return { error: "gt trunk --no-interactive returned no branch." };
+		}
+		return { branch: trunkBranch };
+	}
+	const trunkFailureMessage = formatCommandFailure(
+		"Could not resolve Graphite trunk.",
+		"gt trunk --no-interactive",
+		trunk,
+	);
+	if (!isDetachedHeadGraphiteTrunkFailure(trunk)) {
+		return { error: trunkFailureMessage };
+	}
+
+	const metadataTrunk = await resolveGraphiteTrunkBranchFromMetadata(context);
+	if ("branch" in metadataTrunk) return metadataTrunk;
+	return { error: [trunkFailureMessage, metadataTrunk.error].join("\n\n") };
+}
+
+function isDetachedHeadGraphiteTrunkFailure(result: { stdout: string; stderr: string }): boolean {
+	return `${result.stdout}\n${result.stderr}`.toLowerCase().includes("no current branch");
+}
+
+async function resolveGraphiteTrunkBranchFromMetadata(
+	context: GraphiteTrunkResolutionContext,
+): Promise<{ branch: string } | { error: string }> {
+	const commonDir = await runText(context.pi, context.cwd, "git", [
+		"rev-parse",
+		"--git-common-dir",
+	]);
+	if (!commonDir.ok) {
+		return { error: `Could not inspect Graphite metadata fallback: ${commonDir.message}` };
+	}
+	const commonGitDir = commonDir.text.trim();
+	const dbPath = graphiteMetadataDbPath(
+		isAbsolute(commonGitDir) ? commonGitDir : resolve(context.cwd, commonGitDir),
+	);
+	if (!context.metadataDbAccess.exists(dbPath)) {
+		return {
+			error: `Graphite metadata fallback unavailable: metadata store not found at ${dbPath}`,
+		};
+	}
+	const schemaRows = context.metadataDbAccess.queryJson(
+		dbPath,
+		GRAPHITE_BRANCH_METADATA_SCHEMA_QUERY,
+	);
+	if (!schemaRows.ok) {
+		return { error: `Graphite metadata fallback failed: ${schemaRows.error.message}` };
+	}
+	if (!hasExpectedGraphiteBranchMetadataSchema(schemaRows.value)) {
+		return { error: "Graphite metadata fallback failed: branch_metadata schema mismatch." };
+	}
+	const metadataRows = context.metadataDbAccess.queryJson(dbPath, GRAPHITE_BRANCH_METADATA_QUERY);
+	if (!metadataRows.ok) {
+		return { error: `Graphite metadata fallback failed: ${metadataRows.error.message}` };
+	}
+	const parsed = parseGraphiteBranchMetadataRows(metadataRows.value);
+	if (parsed.type === "not_array") {
+		return { error: "Graphite metadata fallback failed: branch_metadata rows were not an array." };
+	}
+	const resolution = resolveGraphiteTrunkBranchFromTopology(parsed.topology);
+	if (resolution.type === "trunk") return { branch: resolution.branch };
+	if (resolution.type === "none") {
+		return { error: "Graphite metadata fallback found no trunk marker." };
+	}
+	return {
+		error: `Graphite metadata fallback found multiple trunk markers: ${resolution.branches.join(", ")}`,
+	};
+}
+
 async function refreshLocalTrunkBranch(options: {
 	pi: Pick<ExtensionAPI, "exec">;
 	cwd: string;

package/src/cmux/sidebar.ts

@@ -2,6 +2,7 @@ import { DEFAULT_FAST_MODEL_REF, resolveModelRef } from "@nseng-ai/foundation/mo
 import {
 	chooseActiveObjectiveSlug,
 	objectiveSelectionContextFromCommandContext,
+	objectiveSelectionHostFromExec,
 	type ObjectiveSelectionSpec,
 } from "@nseng-ai/objectives/api";
 
@@ -33,7 +34,7 @@ const SIDEBAR_MODEL_ENV = "NS_CCC_SIDEBAR_MODEL";
 const OBJECTIVE_SIDEBAR_SELECTION_SPEC = {
 	statusKey: PI_SIDEBAR_STATUS_KEY,
 	selectionTitle: "Select an active Objective for cmux sidebar",
-	shouldCompactDiffSuggestion: true,
+	selectionMode: "compact-diff-suggestion",
 } satisfies ObjectiveSelectionSpec;
 
 interface RestoreState {
@@ -227,7 +228,7 @@ async function resolveObjectiveSidebarSlug(
 	}
 
 	return chooseActiveObjectiveSlug(
-		pi,
+		objectiveSelectionHostFromExec(pi),
 		objectiveSelectionContextFromCommandContext(ctx),
 		OBJECTIVE_SIDEBAR_SELECTION_SPEC,
 	);

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

@@ -465,7 +465,7 @@ function formatLaunchPreview(options: {
 		options.launchCommand,
 	);
 	return [
-		"cmux new-surface --type terminal --workspace <caller-workspace> --pane <caller-pane> --focus true",
+		"cmux new-surface --type terminal --workspace <caller-workspace> --pane <caller-pane> --focus false",
 		`cmux rename-tab --title ${formatShellArg(options.branch)}`,
 		`cmux send -- ${formatShellArg(`${surfaceLaunchCommand}\n`)}`,
 	].join("\n");
@@ -517,6 +517,7 @@ async function openBranchInCmuxSurface(options: {
 		tabTitle,
 		command: surfaceLaunchCommand,
 		signal: undefined,
+		shouldFocus: false,
 		onStage: (stage) => setStatus(ctx, config, formatSurfaceStageStatus(stage)),
 	});
 	if (launched.type === "failed") {

package/src/ns/autobranch/checkpoint.ts

@@ -4,7 +4,7 @@ import {
 	type CommandResult,
 	type PreparedCheckpointMessage,
 } from "@nseng-ai/capability-kit/checkpoint-flow";
-import { createTextGenerator } from "@nseng-ai/ns/kernel/context";
+import { createTextGenerator } from "@nseng-ai/kernel/context";
 import type { PendingWorktreeSnapshot } from "@nseng-ai/capability-kit/pending-worktree";
 import { selectCheckpointModelRef } from "@nseng-ai/capability-kit/text-generation";
 

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

@@ -2,8 +2,8 @@ import {
 	createCliCommandIo,
 	type CliCommandIoInput,
 	type CliCommandIoOptions,
-} from "@nseng-ai/ns/kernel/command-io";
-import type { NsCommandIo } from "@nseng-ai/ns/kernel/sdk";
+} from "@nseng-ai/kernel/command-io";
+import type { NsCommandIo } from "@nseng-ai/kernel/sdk";
 
 /** Minimal CLI stream/callback surface that CCC standalone commands adapt to NsCommandIo. */
 export type CccCliCommandIoInput = CliCommandIoInput;

package/src/ns/cli.ts

@@ -6,7 +6,6 @@ import { ClinkrGroup, failure, negative, ok, type ClinkrExit } from "@nseng-ai/c
 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,
@@ -143,11 +142,12 @@ async function handleAutobranch(
 ): Promise<ClinkrExit<AutobranchResult>> {
 	const args: FlowAutobranchRequest = request.slug === undefined ? {} : { slug: request.slug };
 	const autobranch = ctx.autobranch ?? {};
+	const exec = (command: string, commandArgs: string[], timeout: number) =>
+		ctx.commands.exec(command, commandArgs, { cwd: ctx.cwd, timeout, env: ctx.env });
 	const result = await createFlowAutobranchCheckpointFlow({
 		cwd: ctx.cwd,
 		args,
-		exec: (command, commandArgs, timeout) =>
-			ctx.commands.exec(command, commandArgs, { cwd: ctx.cwd, timeout, env: ctx.env }),
+		exec,
 		prepareCheckpointMessage:
 			autobranch.prepareCheckpointMessage ??
 			((snapshot) => prepareAutobranchCheckpointMessage(snapshot, ctx.env)),
@@ -183,4 +183,6 @@ function renderAutobranch(result: AutobranchResult): string {
 	return result.summary;
 }
 
+export const VERSION = entry.version;
+
 await entry.runIfMain({ isImportMetaMain: import.meta.main });

package/src/ns/land.ts

@@ -9,4 +9,9 @@ export type {
 	PrintOutput,
 	ValidPullRequestView,
 } from "@nseng-ai/flow/api";
-export { parsePullRequestView, registerLandCommand, runLandCli } from "@nseng-ai/flow/api";
+export {
+	FLOW_LAND_PR_FIELDS,
+	parsePullRequestView,
+	registerLandCommand,
+	runLandCli,
+} from "@nseng-ai/flow/api";

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

@@ -10,12 +10,17 @@ import {
 	type DispatchPromptPayloadOptions,
 } from "../api/handlers.ts";
 import type { ExtensionAPI } from "@nseng-ai/capability-kit/cmux/types";
+import type { GraphiteMetadataDbAccess } from "@nseng-ai/capability-kit/graphite/metadata";
 
 const COMMAND_NAME = CCC_WORKSPACE_DISPATCH_FROM_TRUNK_COMMAND_NAME;
 
+export interface CccSlotDispatchFromTrunkOptions extends DispatchPromptPayloadOptions {
+	metadataDbAccess?: GraphiteMetadataDbAccess;
+}
+
 export function registerCccSlotDispatchFromTrunkCommand(
 	pi: ExtensionAPI,
-	options: DispatchPromptPayloadOptions = {},
+	options: CccSlotDispatchFromTrunkOptions = {},
 ): void {
 	const payloadOptions = resolveDispatchPromptPayloadOptions(options);
 	registerCommandWithImmediateAck({
@@ -33,6 +38,7 @@ export function registerCccSlotDispatchFromTrunkCommand(
 					args,
 					ctx,
 					...optionalEntry("slotClient", options.slotClient),
+					...optionalEntry("metadataDbAccess", options.metadataDbAccess),
 					notifyProgress,
 				});
 			},

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

@@ -50,8 +50,7 @@ function registerDispatchPlanCommand(
 		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.",
+			description: `Attach the latest session-saved plan to a new Graphite-tracked branch via branch-context and launch it in a new cmux ${config.destination}.`,
 			argumentHint: "[--dry-run] [--help]",
 			handler: async (rawArgs, ctx) => {
 				const notifyProgress = makeCommandProgressNotifier({ host: pi, ctx });