@sayknow-cli/coding-agent 0.3.6 → 0.3.8

package/src/main.ts

@@ -30,6 +30,7 @@ import { activateModelProfile } from "./config/model-profile-activation";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
 import { resolveCliModel, resolveModelRoleValue, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
+import { maybeAutostartTelegramRemote } from "./config/telegram-autostart";
 import { BUNDLED_GROK_BUILD_EXTENSION_ID, getBundledGrokBuildExtensionFactory } from "./defaults/skc-grok-cli";
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
@@ -37,6 +38,7 @@ import type { ExtensionUIContext } from "./extensibility/extensions/types";
 import type { InteractiveMode } from "./modes/interactive-mode";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
+import { applyCliRuntimeApiKeyOverride } from "./runtime-api-key";
 import type { MCPManager } from "./runtime-mcp";
 import {
 	type CreateAgentSessionOptions,
@@ -51,6 +53,7 @@ import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-
 import { formatModelOnboardingGuidance } from "./setup/model-onboarding-guidance";
 import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { resolvePromptInput } from "./system-prompt";
+import { persistTaskTokenLog, resolveTaskTokenLogDir, taskTokenLogFromUsage } from "./task/token-log";
 import type { LspStartupServerInfo } from "./tools";
 import { getDisplayChangelogEntries, getInstalledVersionChangelogEntry, getNewEntries } from "./utils/changelog";
 import type { EventBus } from "./utils/event-bus";
@@ -189,6 +192,11 @@ function applyExtensionFlagValues(session: AgentSession, rawArgs: string[]): Map
 	return extensionRunner.getFlagValues();
 }
 
+type CreateSessionForMain = (
+	options: CreateAgentSessionOptions,
+	context?: { skipPostCreateModelRefresh?: boolean },
+) => Promise<CreateAgentSessionResult>;
+
 type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 
 export interface AcpSessionFactoryOptions {
@@ -199,7 +207,7 @@ export interface AcpSessionFactoryOptions {
 	modelRegistry: ModelRegistry;
 	parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
 	rawArgs: string[];
-	createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
+	createSession: CreateSessionForMain;
 }
 
 export async function applyStartupModelProfiles(args: {
@@ -221,8 +229,11 @@ export async function applyStartupModelProfiles(args: {
 	// override it. startupModel covers the eager path; session.model covers the
 	// deferred `--model <pattern>` path resolved inside createAgentSession.
 	const explicitModel = args.parsedArgs.model ? (args.startupModel ?? args.session.model) : undefined;
-
 	const defaultProfile = args.settings.get("modelProfile.default");
+	if (defaultProfile || args.parsedArgs.mpreset) {
+		await args.modelRegistry.refresh("online-if-uncached");
+	}
+
 	if (defaultProfile) {
 		await applyProfile(defaultProfile, false);
 	}
@@ -263,19 +274,23 @@ export async function applyStartupModelProfilesOrExit(
 export function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory {
 	return async cwd => {
 		const nextSettings = await args.settings.cloneForCwd(cwd);
+		const hasStartupProfile = Boolean(nextSettings.get("modelProfile.default") || args.parsedArgs.mpreset);
 		const nextSessionManager = SessionManager.create(cwd, args.sessionDir);
 		const agentId = `acp:${nextSessionManager.getSessionId()}`;
-		const { session: nextSession } = await args.createSession({
-			...args.baseOptions,
-			cwd,
-			sessionManager: nextSessionManager,
-			settings: nextSettings,
-			authStorage: args.authStorage,
-			modelRegistry: args.modelRegistry,
-			agentId,
-			hasUI: false,
-			enableMCP: false,
-		});
+		const { session: nextSession } = await args.createSession(
+			{
+				...args.baseOptions,
+				cwd,
+				sessionManager: nextSessionManager,
+				settings: nextSettings,
+				authStorage: args.authStorage,
+				modelRegistry: args.modelRegistry,
+				agentId,
+				hasUI: false,
+				enableMCP: false,
+			},
+			{ skipPostCreateModelRefresh: hasStartupProfile },
+		);
 		await applyStartupModelProfilesOrExit({
 			session: nextSession,
 			settings: nextSettings,
@@ -284,9 +299,7 @@ export function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSess
 			startupModel: args.baseOptions.model,
 			startupThinkingLevel: args.baseOptions.thinkingLevel,
 		});
-		if (args.parsedArgs.apiKey && !args.baseOptions.model && nextSession.model) {
-			args.authStorage.setRuntimeApiKey(nextSession.model.provider, args.parsedArgs.apiKey);
-		}
+		applyCliRuntimeApiKeyOverride(args.authStorage, args.parsedArgs.apiKey, nextSession.model);
 		applyExtensionFlagValues(nextSession, args.rawArgs);
 		return nextSession;
 	};
@@ -395,30 +408,28 @@ async function getChangelogForDisplay(parsed: Args): Promise<string | undefined>
 		return undefined;
 	}
 
-	const lastVersion = settings.get("lastChangelogVersion");
-	if (lastVersion === VERSION) {
-		// Steady state: user already saw the current version's changelog. Skip the file read + parse.
+	const entries = getDisplayChangelogEntries();
+	if (entries.length === 0) {
 		return undefined;
 	}
 
-	const entries = getDisplayChangelogEntries();
-
+	const lastVersion = settings.get("lastChangelogVersion");
 	if (!lastVersion) {
-		if (entries.length > 0) {
-			settings.set("lastChangelogVersion", VERSION);
-			await flushChangelogVersion();
-			return getInstalledVersionChangelogEntry(entries, VERSION)?.content;
-		}
-	} else {
+		settings.set("lastChangelogVersion", VERSION);
+		await flushChangelogVersion();
+		return getInstalledVersionChangelogEntry(entries, VERSION)?.content;
+	}
+
+	if (lastVersion !== VERSION) {
 		const newEntries = getNewEntries(entries, lastVersion);
+		settings.set("lastChangelogVersion", VERSION);
+		await flushChangelogVersion();
 		if (newEntries.length > 0) {
-			settings.set("lastChangelogVersion", VERSION);
-			await flushChangelogVersion();
 			return newEntries.map(e => e.content).join("\n\n");
 		}
 	}
 
-	return undefined;
+	return getInstalledVersionChangelogEntry(entries, VERSION)?.content;
 }
 
 async function flushChangelogVersion(): Promise<void> {
@@ -504,8 +515,8 @@ export async function createSessionManager(
 		}
 		return manager;
 	}
-	// Default case (new session) returns undefined, SDK will create one
-	return undefined;
+	const sessionDir = parsed.sessionDir ?? SessionManager.getDefaultSessionDir(cwd, activeSettings.getAgentDir());
+	return SessionManager.create(cwd, sessionDir);
 }
 
 async function maybeAutoChdir(parsed: Args): Promise<void> {
@@ -671,7 +682,7 @@ async function buildSessionOptions(
 		options.thinkingLevel = scopedModels[0].thinkingLevel;
 	}
 
-	// Scoped models for Ctrl+P cycling - fill in default thinking levels when not explicit
+	// Scoped models for Alt+N cycling - fill in default thinking levels when not explicit
 	if (scopedModels.length > 0) {
 		const defaultThinkingLevel = activeSettings.get("defaultThinkingLevel");
 		options.scopedModels = scopedModels.map(scopedModel => ({
@@ -845,6 +856,8 @@ export async function runRootCommand(
 
 	// Initialize discovery system with settings for provider persistence
 	logger.time("initializeWithSettings", initializeWithSettings, settingsInstance);
+	// Auto-start Telegram Remote gateway if enabled in settings
+	if (!parsedArgs.print && !autoPrint) await maybeAutostartTelegramRemote();
 
 	// Apply model role overrides from CLI args or env vars (ephemeral, not persisted)
 	const smolModel = parsedArgs.smol ?? $env.PI_SMOL_MODEL;
@@ -942,10 +955,51 @@ export async function runRootCommand(
 		modelRegistry,
 		settingsInstance,
 	);
+	// Resolve the token-log dir lazily on the first chat-usage event: a fresh
+	// launch's session dir does not exist yet at this point (the SDK creates it),
+	// so eager resolution would miss it. Re-resolve when the SessionManager id
+	// changes mid-run (fork/new) so root turns keep landing in the SAME
+	// `<session>/token-logs` dir the task executor uses for subagent turns.
+	let rootTokenLogDir: string | undefined;
+	let rootTokenLogSessionId: string | undefined;
+	let rootTokenLogResolved = false;
+	let rootTokenTurn = 0;
+	const baseTelemetry = sessionOptions.telemetry;
+	sessionOptions.telemetry = {
+		...(baseTelemetry ?? {}),
+		onChatUsage: async event => {
+			await baseTelemetry?.onChatUsage?.(event);
+			const currentSessionId = sessionManager?.getSessionId();
+			if (!rootTokenLogResolved || (currentSessionId && currentSessionId !== rootTokenLogSessionId)) {
+				rootTokenLogDir = await resolveTaskTokenLogDir(process.cwd(), sessionManager);
+				// Reset the per-session turn counter when the log dir moves to a new
+				// session so each session's log starts at turn 1.
+				if (rootTokenLogSessionId !== undefined && currentSessionId !== rootTokenLogSessionId) rootTokenTurn = 0;
+				rootTokenLogSessionId = currentSessionId;
+				rootTokenLogResolved = true;
+			}
+			if (!rootTokenLogDir) return;
+			rootTokenTurn += 1;
+			await persistTaskTokenLog(
+				taskTokenLogFromUsage(event.usage, {
+					subagentId: "root",
+					agent: event.agent?.name ?? "main",
+					// Monotonic 1-based sequence of persisted usage events for this
+					// session (event.stepNumber is 0-based and -1 for oneshot spans).
+					turn: rootTokenTurn,
+					at: new Date().toISOString(),
+					model: event.model,
+					cost: event.cost,
+				}),
+				{ dir: rootTokenLogDir },
+			);
+		},
+	};
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
 	sessionOptions.hasUI = isInteractive || mode === "rpc-ui";
 	sessionOptions.settings = settingsInstance;
+	const hasRootStartupProfile = Boolean(settingsInstance.get("modelProfile.default") || parsedArgs.mpreset);
 
 	// Research-mode (RLM) preset: augment session options before session creation.
 	deps.rlmPreset?.applyOptions(sessionOptions, settingsInstance);
@@ -958,18 +1012,19 @@ export async function runRootCommand(
 			);
 			process.exit(1);
 		}
-		if (sessionOptions.model) {
-			authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsedArgs.apiKey);
-		}
+		applyCliRuntimeApiKeyOverride(authStorage, parsedArgs.apiKey, sessionOptions.model);
 	}
 
 	const createAgentSessionImpl = deps.createAgentSession ?? createAgentSession;
-	const createSession = async (options: CreateAgentSessionOptions): Promise<CreateAgentSessionResult> => {
+	const createSession: CreateSessionForMain = async (options, context): Promise<CreateAgentSessionResult> => {
 		const result = await logger.time("createAgentSession", createAgentSessionImpl, options);
 		// Kick off background model discovery only after createAgentSession finishes its parallel
 		// discovery arms; running these concurrently contends for the event loop and stretches
-		// every parallel arm by ~30ms.
-		modelRegistry.refreshInBackground();
+		// every parallel arm by ~30ms. Startup model profiles do their own foreground refresh
+		// before activation so project-scoped defaults can resolve freshly discovered models.
+		if (!context?.skipPostCreateModelRefresh) {
+			modelRegistry.refreshInBackground();
+		}
 		return result;
 	};
 
@@ -986,11 +1041,11 @@ export async function runRootCommand(
 		});
 		await (deps.runAcpMode ?? (await import("./modes/acp")).runAcpMode)(createAcpSession);
 	} else {
-		const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager, eventBus } =
-			await createSession(sessionOptions);
-		if (parsedArgs.apiKey && !sessionOptions.model && session.model) {
-			authStorage.setRuntimeApiKey(session.model.provider, parsedArgs.apiKey);
-		}
+		const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager, eventBus } = await createSession(
+			sessionOptions,
+			{ skipPostCreateModelRefresh: hasRootStartupProfile },
+		);
+		applyCliRuntimeApiKeyOverride(authStorage, parsedArgs.apiKey, session.model);
 
 		// Research-mode (RLM) preset: hard tool-boundary assertion after the registry is assembled.
 		if (deps.rlmPreset?.onSessionCreated) {
@@ -1067,7 +1122,7 @@ export async function runRootCommand(
 						return `${scopedModel.model.id}${thinkingStr}`;
 					})
 					.join(", ");
-				process.stdout.write(`${chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`)}\n`);
+				process.stdout.write(`${chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Alt+N to cycle)")}`)}\n`);
 			}
 
 			if ($env.PI_TIMING) {

package/src/memories/index.ts

@@ -1083,7 +1083,18 @@ async function resolveMemoryModel(options: {
 		});
 		if (resolved.model) return resolved.model;
 	}
-	return session.model ?? modelRegistry.getAll()[0];
+	if (session.model) return session.model;
+	// No configured role and no active session model (e.g. background startup
+	// before lazy model resolution): prefer the most recently used model over
+	// raw registry order. `getAll()[0]` can be a retired model the provider
+	// now rejects with 404, which permanently fails consolidation jobs.
+	const allModels = modelRegistry.getAll();
+	const usageOrder = session.settings.getStorage()?.getModelUsageOrder() ?? [];
+	for (const usedKey of usageOrder) {
+		const match = allModels.find(model => `${model.provider}/${model.id}` === usedKey);
+		if (match) return match;
+	}
+	return allModels[0];
 }
 
 function loadMemoryConfig(settings: Settings): MemoryRuntimeConfig {

package/src/migrate/executor.ts

@@ -12,11 +12,28 @@ import * as path from "node:path";
 import { upsertMCPServer } from "../runtime-mcp/config-writer";
 import type { MigrateAction } from "./types";
 
-async function ensureRealDirectoryPathNoFollow(directory: string): Promise<void> {
-	const resolved = path.resolve(directory);
-	const parsed = path.parse(resolved);
-	let current = parsed.root;
-	for (const part of resolved.slice(parsed.root.length).split(path.sep).filter(Boolean)) {
+function trustedSkillDestinationBase(destination: string): string {
+	const skillDir = path.dirname(path.resolve(destination));
+	const skillsRoot = path.dirname(skillDir);
+	const scopeRoot = path.dirname(skillsRoot);
+	return path.basename(scopeRoot) === ".skc" ? path.dirname(scopeRoot) : scopeRoot;
+}
+
+async function ensureRealDirectoryPathNoFollow(directory: string, trustedBase: string): Promise<void> {
+	const resolvedBase = path.resolve(trustedBase);
+	const resolvedDirectory = path.resolve(directory);
+	const relative = path.relative(resolvedBase, resolvedDirectory);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+		throw new Error(`skill destination escapes trusted base: ${resolvedDirectory}`);
+	}
+
+	const baseStat = await fs.stat(resolvedBase);
+	if (!baseStat.isDirectory()) {
+		throw new Error(`skill destination base is not a directory: ${resolvedBase}`);
+	}
+
+	let current = resolvedBase;
+	for (const part of relative.split(path.sep).filter(part => part && part !== ".")) {
 		current = path.join(current, part);
 		try {
 			const stat = await fs.lstat(current);
@@ -36,7 +53,7 @@ async function ensureRealDirectoryPathNoFollow(directory: string): Promise<void>
 
 async function writeSkillFileNoFollow(destination: string, content: string): Promise<void> {
 	const skillDir = path.dirname(destination);
-	await ensureRealDirectoryPathNoFollow(skillDir);
+	await ensureRealDirectoryPathNoFollow(skillDir, trustedSkillDestinationBase(destination));
 	const handle = await fs.open(
 		destination,
 		fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_TRUNC | fsSync.constants.O_NOFOLLOW,

package/src/modes/acp/acp-agent.ts

@@ -710,9 +710,6 @@ export class AcpAgent implements Agent {
 		text: string,
 		options: { directAliasMayCollide?: boolean } = {},
 	): Promise<boolean> {
-		if (!text.startsWith("/")) {
-			return false;
-		}
 		if (!record.session.skillsSettings?.enableSkillCommands) {
 			return false;
 		}
@@ -758,9 +755,13 @@ export class AcpAgent implements Agent {
 			}
 			return true;
 		}
-		const spaceIndex = text.indexOf(" ");
-		const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
-		const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
+		const slashText = text.trimStart();
+		if (!slashText.startsWith("/")) {
+			return false;
+		}
+		const spaceIndex = slashText.indexOf(" ");
+		const commandName = spaceIndex === -1 ? slashText.slice(1) : slashText.slice(1, spaceIndex);
+		const args = spaceIndex === -1 ? "" : slashText.slice(spaceIndex + 1).trim();
 		if (
 			!isNamespacedSkillSlashCommandName(commandName) &&
 			options.directAliasMayCollide !== true &&

package/src/modes/components/agent-dashboard.ts

@@ -23,13 +23,11 @@ import {
 	extractPrintableText,
 	Input,
 	matchesKey,
-	padding,
 	replaceTabs,
 	resolveTerminalColumns,
 	Spacer,
 	Text,
 	truncateToWidth,
-	visibleWidth,
 	wrapTextWithAnsi,
 } from "@sayknow-cli/tui";
 import { isEnoent, prompt } from "@sayknow-cli/utils";
@@ -52,6 +50,7 @@ import { shortenPath } from "../../tools/render-utils";
 import { theme } from "../theme/theme";
 import { matchesAppInterrupt } from "../utils/keybinding-matchers";
 import { DynamicBorder } from "./dynamic-border";
+import { TwoColumnBody } from "./two-column-body";
 
 type SourceTabId = "all" | AgentSource;
 type AgentScope = "project" | "user";
@@ -296,38 +295,6 @@ class AgentInspectorPane implements Component {
 	invalidate(): void {}
 }
 
-class TwoColumnBody implements Component {
-	constructor(
-		private readonly leftPane: AgentListPane,
-		private readonly rightPane: AgentInspectorPane,
-		private readonly maxHeight: number,
-	) {}
-
-	render(width: number): string[] {
-		const leftWidth = Math.floor(width * 0.5);
-		const rightWidth = width - leftWidth - 3;
-		const leftLines = this.leftPane.render(leftWidth);
-		const rightLines = this.rightPane.render(rightWidth);
-		const lineCount = Math.min(this.maxHeight, Math.max(leftLines.length, rightLines.length));
-		const out: string[] = [];
-		const separator = theme.fg("dim", ` ${theme.boxSharp.vertical} `);
-
-		for (let i = 0; i < lineCount; i++) {
-			const left = truncateToWidth(leftLines[i] ?? "", leftWidth);
-			const leftPadded = left + padding(Math.max(0, leftWidth - visibleWidth(left)));
-			const right = truncateToWidth(rightLines[i] ?? "", rightWidth);
-			out.push(leftPadded + separator + right);
-		}
-
-		return out;
-	}
-
-	invalidate(): void {
-		this.leftPane.invalidate?.();
-		this.rightPane.invalidate?.();
-	}
-}
-
 export class AgentDashboard extends Container {
 	#settingsManager: Settings | null = null;
 	#allAgents: DashboardAgent[] = [];