@sayknow-cli/coding-agent 0.3.1 → 0.3.4

package/dist/types/extensibility/skc-plugins/compiler.d.ts

@@ -0,0 +1,19 @@
+import { type NormalizedSkcPluginBundle } from "./types";
+/**
+ * Stable surface extension-id builders. Kept here so install, runtime, and
+ * observability all derive identical ids.
+ */
+export declare const surfaceIds: {
+    readonly tool: (name: string) => string;
+    readonly hook: (event: string, phase: string | undefined, target: string | undefined, name: string) => string;
+    readonly mcp: (name: string) => string;
+    readonly systemAppendix: (plugin: string, name: string) => string;
+    readonly agentAppendix: (agent: string, plugin: string, name: string) => string;
+    readonly subskill: (parent: string, phase: string, activationArg: string) => string;
+};
+/**
+ * Pure compile step: reads only the manifest, subskill frontmatter, and
+ * declared files (as bytes for hashing/existence). It NEVER imports or executes
+ * plugin tool/hook code.
+ */
+export declare function compileSkcPluginBundle(root: string): Promise<NormalizedSkcPluginBundle>;

package/dist/types/extensibility/skc-plugins/constrained-hooks.d.ts

@@ -0,0 +1,29 @@
+import { type SessionQuarantine } from "./session-validation";
+/**
+ * Constrained plugin-hook loader.
+ *
+ * Third-party plugin hooks are NOT given the broad first-party HookAPI. They
+ * receive a restricted API that can only register a handler for their declared
+ * event; every session-mutation / command / shell capability throws
+ * security_policy. After the factory runs we verify it registered exactly the
+ * declared event (and nothing else), or the hook is quarantined.
+ */
+export interface ConstrainedPluginHook {
+    plugin: string;
+    event: string;
+    target?: string;
+    phase?: "before" | "after";
+    handler: (...args: any[]) => unknown;
+}
+export interface ConstrainedHookLoadResult {
+    hooks: ConstrainedPluginHook[];
+    quarantine: SessionQuarantine[];
+}
+/**
+ * Load all always-on constrained plugin hooks for the effective registry at
+ * `cwd`, applying hash-drift + collision quarantine first. Returns empty when
+ * no plugins are installed.
+ */
+export declare function loadConstrainedPluginHooks(input: {
+    cwd: string;
+}): Promise<ConstrainedHookLoadResult>;

package/dist/types/extensibility/skc-plugins/index.d.ts

@@ -1,8 +1,17 @@
 export * from "./activation";
+export * from "./compiler";
+export * from "./constrained-hooks";
 export * from "./injection";
+export * from "./installer";
 export * from "./loader";
+export * from "./mcp-policy";
+export * from "./observability";
 export * from "./paths";
+export * from "./prompt-appendix";
+export * from "./registry";
+export * from "./runtime-adapters";
 export * from "./schema";
+export * from "./session-validation";
 export * from "./state";
 export * from "./tools";
 export * from "./types";

package/dist/types/extensibility/skc-plugins/injection.d.ts

@@ -29,3 +29,12 @@ export declare function buildAgentSubskillInjection(input: {
     sessionId?: string;
     agentName: string;
 }): Promise<string>;
+import type { SkcPluginRegistryEntry } from "./types";
+/**
+ * Tier-1 advertisement for a workflow parent skill: bounded, metadata-only list
+ * of installed sub-skills bound to `parent`, rendered ONLY in that parent's
+ * prompt (never the global public-workflow-surface). No body content.
+ */
+export declare function buildSubskillAdvertisement(entries: readonly SkcPluginRegistryEntry[], parent: string, phase?: string): string;
+/** Tier-1 advertisement for a role-agent parent. */
+export declare function buildAgentSubskillAdvertisement(entries: readonly SkcPluginRegistryEntry[], agentName: string): string;

package/dist/types/extensibility/skc-plugins/installer.d.ts

@@ -0,0 +1,13 @@
+import { type SkcPluginRegistryEntry, type SkcPluginScope } from "./types";
+export interface InstallSkcPluginOptions {
+    scope: SkcPluginScope;
+    cwd: string;
+    force?: boolean;
+}
+export interface InstallSkcPluginResult {
+    status: "installed" | "updated" | "unchanged";
+    entry: SkcPluginRegistryEntry;
+}
+export declare function installSkcPluginBundle(source: string, options: InstallSkcPluginOptions): Promise<InstallSkcPluginResult>;
+/** True only when the source actually resolves to a SKC plugin bundle (root sayknow-plugin.json). */
+export declare function isSkcPluginBundleSource(source: string): Promise<boolean>;

package/dist/types/extensibility/skc-plugins/mcp-policy.d.ts

@@ -0,0 +1,26 @@
+import { type SkcPluginMcpManifestEntry } from "./types";
+export declare function isDeniedIpv4(host: string): boolean;
+export declare function isDeniedIpv6(host: string): boolean;
+/**
+ * Synchronous URL policy (scheme, credentials, host literal ranges). Used for
+ * the primary endpoint and any redirect/token/discovery URL.
+ */
+export declare function assertUrlAllowed(rawUrl: string, label?: string): URL;
+/** Reject headers with control characters / CRLF injection. */
+export declare function assertHeadersAllowed(headers: Record<string, string> | undefined): void;
+/**
+ * Runtime DNS check: resolve the host and ensure no resolved address falls in a
+ * denied range (covers DNS rebinding when re-run before each connect).
+ */
+export declare function assertDnsResolvesPublic(hostname: string, label?: string): Promise<void>;
+export interface StdioPolicyContext {
+    pluginRoot: string;
+}
+/** stdio launcher/path confinement policy. */
+export declare function assertStdioAllowed(entry: SkcPluginMcpManifestEntry, ctx: StdioPolicyContext): void;
+/**
+ * Install-time MCP policy (no network required). Validates scheme/host literals
+ * and stdio confinement. Runtime connect additionally calls
+ * assertDnsResolvesPublic and re-validates redirect/token URLs.
+ */
+export declare function assertMcpInstallPolicy(entry: SkcPluginMcpManifestEntry, ctx: StdioPolicyContext): void;

package/dist/types/extensibility/skc-plugins/observability.d.ts

@@ -0,0 +1,27 @@
+import type { SkcPluginRegistryEntry, SkcPluginScope } from "./types";
+/**
+ * Observability for SKC plugin bundle surfaces, consumable by the extension
+ * dashboard / state manager. Each surface row carries its stable extension id,
+ * owning plugin, scope, source kind, enabled/disabled/quarantined status, and a
+ * content hash. MCP auth/header values are NEVER included.
+ */
+export type PluginSurfaceStatus = "enabled" | "disabled" | "quarantined";
+export interface PluginSurfaceRow {
+    extensionId: string;
+    kind: "tool" | "hook" | "mcp" | "system-appendix" | "agent-appendix" | "subskill";
+    plugin: string;
+    scope: SkcPluginScope;
+    sourceKind: SkcPluginRegistryEntry["source"]["kind"];
+    status: PluginSurfaceStatus;
+    hash: string;
+    quarantineCode?: string;
+}
+export interface PluginObservabilitySummary {
+    plugins: number;
+    surfaces: PluginSurfaceRow[];
+}
+/**
+ * Build the observability summary for the effective registry at `cwd`, including
+ * hash-drift and session-collision quarantine status.
+ */
+export declare function summarizeSkcPluginObservability(cwd: string): Promise<PluginObservabilitySummary>;

package/dist/types/extensibility/skc-plugins/prompt-appendix.d.ts

@@ -0,0 +1,16 @@
+import type { SkcPluginRegistryEntry, SkcSubskillParentAgent } from "./types";
+export interface RenderedPluginAppendices {
+    /** Combined system-appendix block text (empty if none). */
+    system: string;
+    /** Per-agent appendix block text. */
+    byAgent: Map<SkcSubskillParentAgent, string>;
+    /** Stable digest of all rendered appendix content + identities (for cache/refresh). */
+    digest: string;
+}
+/**
+ * Build appendix blocks from the active, enabled registry entries in their
+ * deterministic order. Per-appendix and total size caps are enforced
+ * fail-closed (oversize content is dropped with a marker, never silently
+ * truncated into the prompt as authoritative text).
+ */
+export declare function renderPluginAppendices(entries: readonly SkcPluginRegistryEntry[]): Promise<RenderedPluginAppendices>;

package/dist/types/extensibility/skc-plugins/registry.d.ts

@@ -0,0 +1,32 @@
+import { type SkcPluginRegistry, type SkcPluginRegistryEntry, type SkcPluginScope } from "./types";
+export declare function registryRootForScope(scope: SkcPluginScope, cwd: string): string;
+export declare function registryPathForScope(scope: SkcPluginScope, cwd: string): string;
+/**
+ * Deterministic ordering: scope (user before project) -> normalized name ->
+ * resolved plugin root. Collisions are errors elsewhere; order only controls
+ * stable hook/appendix sequencing.
+ */
+export declare function sortRegistryEntries(entries: SkcPluginRegistryEntry[]): SkcPluginRegistryEntry[];
+export declare function readRegistry(scope: SkcPluginScope, cwd: string): Promise<SkcPluginRegistry>;
+export declare function withRegistryLock<T>(scope: SkcPluginScope, cwd: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Lock-free atomic write (temp+fsync+rename). Only call while already holding
+ * the per-scope registry lock via withRegistryLock.
+ */
+export declare function writeRegistryUnlocked(registry: SkcPluginRegistry, cwd: string): Promise<void>;
+/**
+ * Atomic registry write: write to a temp sibling, fsync, then rename. Guarded
+ * by an interprocess lockfile so concurrent installs cannot clobber each other.
+ */
+export declare function writeRegistry(registry: SkcPluginRegistry, cwd: string): Promise<void>;
+/**
+ * Mutate a scope's registry as a single locked read-modify-write transaction so
+ * concurrent installs cannot lose each other's updates. The mutator receives a
+ * sorted copy and returns the next entry list.
+ */
+export declare function updateRegistry(scope: SkcPluginScope, cwd: string, mutator: (entries: SkcPluginRegistryEntry[]) => SkcPluginRegistryEntry[]): Promise<SkcPluginRegistry>;
+/**
+ * Effective registry for a cwd: user + project entries in deterministic order.
+ */
+export declare function loadEffectiveSkcPluginRegistry(cwd: string): Promise<SkcPluginRegistryEntry[]>;
+export declare function registryEntryFingerprint(entry: SkcPluginRegistryEntry): string;

package/dist/types/extensibility/skc-plugins/runtime-adapters.d.ts

@@ -0,0 +1,64 @@
+import type { CustomTool } from "../custom-tools/types";
+import { type SessionQuarantine } from "./session-validation";
+export interface AlwaysOnPluginTools {
+    tools: CustomTool[];
+    quarantine: SessionQuarantine[];
+}
+/**
+ * Load the always-on plugin tool surfaces for the effective registry at `cwd`.
+ *
+ * Safety properties:
+ * - Hash drift quarantines the plugin (runtime_mismatch) before any import.
+ * - Session-start collisions vs reserved/built-in names quarantine fail-closed.
+ * - Manifest-declared tool names are authoritative: a factory that returns a
+ *   different/extra/missing name is rejected with runtime_mismatch and skipped.
+ * - Reserved tool names are never overwritten.
+ *
+ * Returns an empty result when no plugins are installed, so callers that always
+ * call this in `createAgentSession` incur no behavior change without plugins.
+ */
+export declare function loadAlwaysOnPluginTools(input: {
+    cwd: string;
+    reservedToolNames: string[];
+}): Promise<AlwaysOnPluginTools>;
+/**
+ * Render the always-on system-appendix blocks for the effective registry at
+ * `cwd`, applying hash-drift + collision quarantine first. Returns "" when no
+ * plugins are installed/enabled. Safe to call unconditionally at session start.
+ */
+export declare function renderAlwaysOnSystemAppendices(input: {
+    cwd: string;
+}): Promise<string>;
+/**
+ * Render the agent-appendix block and Tier-1 sub-skill advertisement for a role
+ * agent at session/spawn time. Hash-drift + collision quarantine applied first.
+ * Returns empty strings when nothing applies.
+ */
+export declare function renderAgentPromptAdditions(input: {
+    cwd: string;
+    agentName: string;
+}): Promise<{
+    appendix: string;
+    advertisement: string;
+}>;
+/**
+ * Render the Tier-1 sub-skill advertisement for a workflow parent skill.
+ * Returns "" when nothing applies. Quarantine applied first.
+ */
+export declare function renderSkillAdvertisement(input: {
+    cwd: string;
+    skillName: string;
+    phase?: string;
+}): Promise<string>;
+/**
+ * Convert active plugin-bundle MCP surfaces into runtime MCPServerConfig entries,
+ * applying install + runtime MCP policy (URL scheme/private-range deny, DNS
+ * re-resolution for http/sse, stdio root-confinement) before connection. Servers
+ * failing policy are quarantined and excluded. Returns {} when none.
+ */
+export declare function buildPluginMcpConfigs(input: {
+    cwd: string;
+}): Promise<{
+    configs: Record<string, any>;
+    quarantine: SessionQuarantine[];
+}>;

package/dist/types/extensibility/skc-plugins/session-validation.d.ts

@@ -0,0 +1,42 @@
+import type { SkcPluginLoadErrorCode, SkcPluginRegistryEntry } from "./types";
+/**
+ * Session-start validation: the registry is the collision authority. Capability
+ * provider output is supplied as EVIDENCE only; plugin surfaces are never
+ * resolved by capability first-wins. Offending surfaces are quarantined
+ * fail-closed with a stable error code rather than silently shadowed.
+ */
+export interface SessionCapabilityEvidence {
+    /** Built-in + provider tool names already present before plugin insertion. */
+    toolNames?: Iterable<string>;
+    /** Non-plugin MCP server names from providers/built-ins. */
+    mcpNames?: Iterable<string>;
+    /** Non-plugin hook keys (event:phase:target:name) from providers/built-ins. */
+    hookKeys?: Iterable<string>;
+    /** Existing appendix extension ids already present. */
+    appendixIds?: Iterable<string>;
+}
+export interface SessionQuarantine {
+    plugin: string;
+    surfaceId: string;
+    code: SkcPluginLoadErrorCode;
+    message: string;
+}
+export interface SessionValidationResult {
+    /** Registry entries (enabled, non-quarantined) whose surfaces may activate. */
+    active: SkcPluginRegistryEntry[];
+    /** Per-surface quarantine records (fail-closed). */
+    quarantine: SessionQuarantine[];
+}
+/**
+ * Re-verify that the installed files still match the registry's recorded hashes.
+ * Drift (manual edits, partial writes) quarantines the whole plugin with
+ * runtime_mismatch.
+ */
+export declare function verifyEntryHashes(entry: SkcPluginRegistryEntry): Promise<SessionQuarantine | null>;
+/**
+ * Validate the effective installed registry against the current capability
+ * universe (evidence) and across plugins. Returns the entries that may activate
+ * plus per-surface quarantine records. Disabled entries/surfaces are skipped
+ * (not an error).
+ */
+export declare function validateSessionBundles(entries: readonly SkcPluginRegistryEntry[], evidence?: SessionCapabilityEvidence, preQuarantined?: readonly SessionQuarantine[]): SessionValidationResult;

package/dist/types/extensibility/skc-plugins/types.d.ts

@@ -7,12 +7,56 @@ export declare const SKC_SUBSKILL_PARENT_AGENTS: readonly ["executor", "architec
 export type SkcSubskillParentAgent = (typeof SKC_SUBSKILL_PARENT_AGENTS)[number];
 export type SkcSubskillParent = SkcSubskillParentSkill | SkcSubskillParentAgent;
 export declare const SKC_AGENT_SUBSKILL_PHASES: Record<SkcSubskillParentAgent, string[]>;
+export interface SkcPluginToolManifestEntry {
+    name: string;
+    path: string;
+    description?: string;
+    sha256?: string;
+    /**
+     * "always-on" object entries are activated for the whole session; legacy
+     * string shorthand stays "subskill"-scoped and is only attached to subskill
+     * bindings (never registered as an always-on tool surface).
+     */
+    surface: "subskill" | "always-on";
+}
+export interface SkcPluginHookManifestEntry {
+    name: string;
+    event: string;
+    target?: string;
+    phase?: "before" | "after";
+    path: string;
+    sha256?: string;
+}
+export type SkcPluginMcpTransport = "stdio" | "http" | "sse";
+export interface SkcPluginMcpManifestEntry {
+    name: string;
+    transport: SkcPluginMcpTransport;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    sha256?: string;
+}
+export interface SkcPluginAppendixManifestEntry {
+    name: string;
+    path?: string;
+    content?: string;
+    sha256?: string;
+}
+export interface SkcPluginAgentAppendixManifestEntry extends SkcPluginAppendixManifestEntry {
+    agent: SkcSubskillParentAgent;
+}
 export interface SkcPluginManifest {
     name: string;
     version: string;
     kind: "sayknow-cli-plugin";
     subskills: string[];
-    tools: string[];
+    tools: SkcPluginToolManifestEntry[];
+    hooks: SkcPluginHookManifestEntry[];
+    mcps: SkcPluginMcpManifestEntry[];
+    systemAppendix: SkcPluginAppendixManifestEntry[];
+    agentAppendix: SkcPluginAgentAppendixManifestEntry[];
 }
 export interface SubskillFrontmatter {
     name: string;
@@ -57,8 +101,120 @@ export interface LoadedSkcPlugin {
     bindings: LoadedSubskillBinding[];
     toolBindings: PhaseScopedToolBinding[];
 }
-export type SkcPluginLoadErrorCode = "forbidden_surface" | "invalid_manifest" | "invalid_frontmatter" | "invalid_parent" | "invalid_phase" | "duplicate_arg" | "duplicate_parent_phase" | "missing_file" | "invalid_kind";
+export type SkcPluginLoadErrorCode = "forbidden_surface" | "invalid_manifest" | "invalid_kind" | "unsupported_surface" | "invalid_frontmatter" | "invalid_parent" | "invalid_phase" | "missing_file" | "hash_mismatch" | "invalid_appendix" | "invalid_hook" | "invalid_mcp" | "duplicate_arg" | "duplicate_parent_phase" | "duplicate_tool" | "duplicate_hook" | "duplicate_mcp" | "duplicate_appendix" | "security_policy" | "install_conflict" | "session_collision" | "runtime_mismatch" | "quarantined_surface";
 export declare class SkcPluginLoadError extends Error {
     readonly code: SkcPluginLoadErrorCode;
     constructor(code: SkcPluginLoadErrorCode, message: string, options?: ErrorOptions);
 }
+export type SkcPluginScope = "user" | "project";
+export type SkcPluginSourceKind = "path" | "git" | "tarball";
+export interface SkcPluginCopiedFile {
+    relativePath: string;
+    sha256: string;
+    bytes: number;
+}
+export interface NormalizedSubskillSurface {
+    extensionId: string;
+    name: string;
+    description: string;
+    parent: string;
+    phase: string;
+    activationArg: string;
+    relativePath: string;
+    sha256: string;
+}
+export interface NormalizedToolSurface {
+    extensionId: string;
+    name: string;
+    relativePath: string;
+    sha256: string;
+    description?: string;
+}
+export interface NormalizedHookSurface {
+    extensionId: string;
+    name: string;
+    event: string;
+    target?: string;
+    phase?: "before" | "after";
+    relativePath: string;
+    sha256: string;
+}
+export interface NormalizedMcpSurface {
+    extensionId: string;
+    name: string;
+    transport: SkcPluginMcpTransport;
+    configHash: string;
+    config: SkcPluginMcpManifestEntry;
+}
+export interface NormalizedAppendixSurface {
+    extensionId: string;
+    name: string;
+    relativePath?: string;
+    /** Inline appendix body (when the manifest used `content` instead of `path`). */
+    content?: string;
+    contentHash: string;
+    bytes: number;
+}
+export interface NormalizedAgentAppendixSurface extends NormalizedAppendixSurface {
+    agent: SkcSubskillParentAgent;
+}
+export interface NormalizedSkcPluginSurfaces {
+    subskills: NormalizedSubskillSurface[];
+    tools: NormalizedToolSurface[];
+    hooks: NormalizedHookSurface[];
+    mcps: NormalizedMcpSurface[];
+    systemAppendices: NormalizedAppendixSurface[];
+    agentAppendices: NormalizedAgentAppendixSurface[];
+}
+/**
+ * Result of the pure compile step. Computed from manifest, frontmatter, and
+ * declared files read as bytes only — never by importing plugin code.
+ */
+export interface NormalizedSkcPluginBundle {
+    name: string;
+    version: string;
+    root: string;
+    manifestPath: string;
+    manifestHash: string;
+    surfaces: NormalizedSkcPluginSurfaces;
+    files: SkcPluginCopiedFile[];
+}
+export interface SkcPluginQuarantineEntry {
+    surfaceId: string;
+    code: SkcPluginLoadErrorCode;
+    message: string;
+    detectedAt: string;
+}
+export interface SkcPluginRegistrySource {
+    kind: SkcPluginSourceKind;
+    uri: string;
+    ref?: string;
+    sha?: string;
+    resolvedAt: string;
+}
+export interface SkcPluginRegistryEntry {
+    name: string;
+    version: string;
+    scope: SkcPluginScope;
+    enabled: boolean;
+    pluginRoot: string;
+    manifestPath: string;
+    manifestHash: string;
+    source: SkcPluginRegistrySource;
+    installedAt: string;
+    updatedAt: string;
+    copiedFiles: SkcPluginCopiedFile[];
+    surfaces: NormalizedSkcPluginSurfaces;
+    disabledSurfaceIds: string[];
+    quarantine?: SkcPluginQuarantineEntry[];
+}
+export interface SkcPluginRegistry {
+    version: 1;
+    scope: SkcPluginScope;
+    plugins: SkcPluginRegistryEntry[];
+}
+/**
+ * Stable identifiers for plugin-contributed surfaces used by observability,
+ * disabledSurfaceIds, and quarantine bookkeeping.
+ */
+export type SkcPluginSurfaceExtensionId = string;

package/dist/types/extensibility/skc-plugins/validation.d.ts

@@ -1,4 +1,11 @@
-import { type LoadedSubskillBinding, type SubskillFrontmatter } from "./types";
+import { type LoadedSubskillBinding, type NormalizedSkcPluginBundle, type SkcPluginRegistryEntry, type SubskillFrontmatter } from "./types";
 export declare function validateBinding(fm: SubskillFrontmatter): void;
 export declare function buildParentArgMap(bindings: readonly LoadedSubskillBinding[]): Map<string, Map<string, LoadedSubskillBinding>>;
 export declare function buildParentPhaseSet(bindings: readonly LoadedSubskillBinding[]): Set<string>;
+/**
+ * Hard install-time collision + security validation for a compiled bundle
+ * against the effective installed registry (other plugins in the target scope
+ * universe). Collisions are hard errors; the registry is the collision
+ * authority, never capability first-wins.
+ */
+export declare function validateInstallPlan(bundle: NormalizedSkcPluginBundle, effectiveEntries: readonly SkcPluginRegistryEntry[]): void;

package/dist/types/i18n/messages/en.d.ts

@@ -30,7 +30,6 @@ export declare const en: {
     readonly "settings.tab.appearance": "Appearance";
     readonly "settings.tab.model": "Model";
     readonly "settings.tab.interaction": "Interaction";
-    readonly "settings.tab.notifications": "Notifications";
     readonly "settings.tab.context": "Context";
     readonly "settings.tab.memory": "Memory";
     readonly "settings.tab.editing": "Editing";

package/dist/types/main.d.ts

@@ -12,6 +12,7 @@ import type { SubmittedUserInput } from "./modes/types";
 import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
+import { SessionManager } from "./session/session-manager";
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
@@ -48,6 +49,7 @@ export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof
  * tool registry and shadow the client-supplied servers (issue #1234).
  */
 export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings): Promise<SessionManager | undefined>;
 /**
  * Research-mode (RLM) preset hook. Lets `skc rlm` augment the session options
  * (system prompt, restricted toolset, custom python tool) and assert the tool

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,6 @@
 import { Editor, type KeyId } from "@sayknow-cli/tui";
 import { type AppKeybinding } from "../../config/keybindings";
-type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.followUp" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
 type PastePendingClearReason = "timeout" | "queue-limit";
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.

package/dist/types/modes/components/model-selector.d.ts

@@ -38,7 +38,15 @@ export declare class ModelSelectorComponent extends Container {
         sessionId?: string;
         isFastForProvider?: (provider?: string) => boolean;
         isFastForSubagentProvider?: (provider?: string) => boolean;
+        isCurrentModelFastModeActive?: () => boolean;
+        currentThinkingLevel?: ThinkingLevel;
+        activeModelProfile?: string;
     });
+    refreshRoleAssignments(options?: {
+        currentModel?: Model;
+        currentThinkingLevel?: ThinkingLevel;
+        activeModelProfile?: string;
+    }): void;
     handleInput(keyData: string): void;
     getSearchInput(): Input;
     __testSelectProfile(profileName: string, setDefault: boolean): Promise<void>;

package/dist/types/modes/components/settings-defs.d.ts

@@ -37,7 +37,6 @@ export interface SubmenuSettingDef extends BaseSettingDef {
 }
 export interface TextInputSettingDef extends BaseSettingDef {
     type: "text";
-    secret?: boolean;
 }
 export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef | TextInputSettingDef;
 /** Get all setting definitions with UI */

package/dist/types/modes/components/status-line/git-utils.d.ts

@@ -1,3 +1,4 @@
+import type { GitHeadState } from "../../../utils/git";
 /**
  * Extract "owner/repo" from a GitHub remote URL.
  * Handles HTTPS, SSH (scp-style), and git:// protocols.
@@ -20,3 +21,8 @@ export declare function canReuseCachedPr(cachedPr: {
     number: number;
     url: string;
 } | null | undefined, cachedContext: PrCacheContext | undefined, currentContext: PrCacheContext | null): boolean;
+export interface CurrentBranchState {
+    readonly branch: string | null;
+    readonly repoId: string | null;
+}
+export declare function resolveCurrentBranch(cwd: string, resolveHead?: (cwd: string) => GitHeadState | null): CurrentBranchState;