@sayknow-cli/coding-agent 0.4.2 → 0.4.3

package/dist/types/hindsight/state.d.ts

@@ -0,0 +1,106 @@
+import type { AgentSession } from "../session/agent-session";
+import { type BankScope } from "./bank";
+import type { HindsightApi } from "./client";
+import type { HindsightConfig } from "./config";
+import { type HindsightMessage } from "./content";
+interface RecallOutcome {
+    context: string | null;
+    ok: boolean;
+}
+export interface HindsightSessionStateOptions {
+    /** Session id used for retain-queue metadata. */
+    sessionId: string;
+    client: HindsightApi;
+    bankId: string;
+    /** Tags applied to every retain — non-empty in per-project-tagged mode. */
+    retainTags?: string[];
+    /** Tag filter applied to every recall/reflect — non-empty in per-project-tagged mode. */
+    recallTags?: string[];
+    recallTagsMatch?: "any" | "all" | "any_strict" | "all_strict";
+    config: HindsightConfig;
+    session: AgentSession;
+    missionsSet: Set<string>;
+    lastRetainedTurn?: number;
+    hasRecalledForFirstTurn?: boolean;
+    /**
+     * When set, this entry is a subagent alias that reuses the parent's bank,
+     * scope, config, client, and missionsSet. Aliases skip auto-recall and
+     * auto-retain — those run on the parent only — but the recall/retain/reflect
+     * tools resolve via the alias so they persist to the same bank as the parent.
+     */
+    aliasOf?: HindsightSessionState;
+}
+/**
+ * Debounced batch queue for tool-initiated `retain` calls owned by one
+ * Hindsight session state instance.
+ *
+ * Auto-retain (`HindsightSessionState.retainSession`) is intentionally not
+ * routed through this queue — it submits a full transcript as one large item
+ * and already runs `async: true` server-side.
+ */
+export declare class HindsightRetainQueue {
+    #private;
+    constructor(state: HindsightSessionState);
+    get depth(): number;
+    enqueue(content: string, context?: string): void;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}
+/** Per-session Hindsight runtime state owned by its AgentSession. */
+export declare class HindsightSessionState {
+    #private;
+    /** Session id used for retain-queue metadata. */
+    sessionId: string;
+    client: HindsightApi;
+    bankId: string;
+    /** Tags applied to every retain — non-empty in per-project-tagged mode. */
+    retainTags?: string[];
+    /** Tag filter applied to every recall/reflect — non-empty in per-project-tagged mode. */
+    recallTags?: string[];
+    recallTagsMatch?: "any" | "all" | "any_strict" | "all_strict";
+    config: HindsightConfig;
+    session: AgentSession;
+    missionsSet: Set<string>;
+    lastRetainedTurn: number;
+    hasRecalledForFirstTurn: boolean;
+    lastRecallSnippet?: string;
+    lastInjectedRecallSnippetHash?: string;
+    /** Cached `<mental_models>` block injected into developer instructions. */
+    mentalModelsSnippet?: string;
+    /** When the cached snippet was last refreshed; gates the agent_end re-list. */
+    mentalModelsLoadedAt?: number;
+    /**
+     * In-flight ensure+load promise. `beforeAgentStartPrompt` awaits this on
+     * the first turn so the MM block lands in the system prompt before the
+     * LLM generates, even though `start()` returns before the load completes.
+     */
+    mentalModelsLoadPromise?: Promise<void>;
+    unsubscribe?: () => void;
+    /** Alias states delegate persistence config to a primary parent state. */
+    aliasOf?: HindsightSessionState;
+    readonly retainQueue: HindsightRetainQueue;
+    constructor(options: HindsightSessionStateOptions);
+    setSessionId(sessionId: string): void;
+    resetConversationTracking(): void;
+    /** Return the current recall payload, resolving subagent aliases to their primary state. */
+    getRecallSnippet(): string | undefined;
+    /** Return the current recall payload without consuming its one-shot injection eligibility. */
+    getRecallSnippetForInjection(): string | undefined;
+    /** Mark a recall payload consumed only after it has been accepted for provider injection. */
+    markRecallSnippetInjected(snippet: string): boolean;
+    enqueueRetain(content: string, context?: string): void;
+    flushRetainQueue(): Promise<void>;
+    recallForContext(query: string, signal?: AbortSignal): Promise<RecallOutcome>;
+    retainSession(messages: HindsightMessage[]): Promise<boolean>;
+    maybeRetainOnAgentEnd(): Promise<void>;
+    forceRetainCurrentSession(): Promise<void>;
+    maybeRecallOnAgentStart(): Promise<void>;
+    beforeAgentStartPrompt(promptText: string): Promise<string | undefined>;
+    recallForCompaction(messages: HindsightMessage[]): Promise<string | undefined>;
+    runMentalModelLoad(scope: BankScope): Promise<void>;
+    refreshMentalModelsSnippet(): Promise<boolean>;
+    reloadMentalModels(): Promise<boolean>;
+    attachSessionListeners(): void;
+    dispose(): Promise<void>;
+}
+export {};

package/dist/types/hindsight/transcript.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pull plain-text user/assistant messages out of a session manager.
+ *
+ * The Hindsight retain/recall API only takes flat `{role, content}` records,
+ * so we drop tool calls, tool results, bash execution wrappers, custom
+ * messages, and anything else that isn't a primary conversation turn. Each
+ * surviving message's `TextContent` parts are joined with newlines.
+ */
+import type { SessionEntry } from "../session/session-manager";
+import type { HindsightMessage } from "./content";
+export interface ReadonlySessionManagerLike {
+    getEntries(): SessionEntry[];
+}
+/**
+ * Walk session entries top-to-bottom, returning a flat user/assistant list.
+ *
+ * Implementation choices:
+ * - Skip entries whose type isn't `"message"` (compaction, branch_summary,
+ *   custom_message, tool exec records, ...). Those don't represent a
+ *   conversational turn, only the LLM's plain-text utterances do.
+ * - Skip messages whose role isn't `"user"` or `"assistant"`. We deliberately
+ *   ignore `toolResult`, `bashExecution`, `hookMessage`, etc. — they're noise
+ *   for memory purposes.
+ * - For assistant messages, only `text` blocks contribute. Thinking and
+ *   toolCall blocks are intentionally dropped: the user never saw them, so
+ *   retaining them would prime recall on internal monologue.
+ */
+export declare function extractMessages(sessionManager: ReadonlySessionManagerLike): HindsightMessage[];

package/dist/types/hooks/codex-native-hooks-config.d.ts

@@ -0,0 +1,29 @@
+export declare const SKC_MANAGED_CODEX_HOOK_EVENTS: readonly ["UserPromptSubmit", "Stop"];
+export type SkcManagedCodexHookEvent = (typeof SKC_MANAGED_CODEX_HOOK_EVENTS)[number];
+export interface CodexCommandHook {
+    type: "command";
+    command: string;
+    statusMessage?: string;
+    timeout?: number;
+}
+export interface CodexHookEntry {
+    hooks: CodexCommandHook[];
+}
+export interface SkcManagedCodexHooksConfig {
+    hooks: Record<SkcManagedCodexHookEvent, CodexHookEntry[]>;
+}
+export interface MergeSkcManagedCodexHooksResult {
+    content: string;
+    changed: boolean;
+    managedHookCount: number;
+}
+export interface SkcCodexHooksStatus {
+    hooksPath: string;
+    installed: boolean;
+    missingEvents: SkcManagedCodexHookEvent[];
+    managedHookCount: number;
+}
+export declare function buildSkcManagedCodexHooksConfig(): SkcManagedCodexHooksConfig;
+export declare function getDefaultCodexHooksPath(homeDir?: string): string;
+export declare function mergeSkcManagedCodexHooksConfig(existingContent: string | null): MergeSkcManagedCodexHooksResult;
+export declare function readSkcManagedCodexHooksStatus(content: string | null, hooksPath: string): SkcCodexHooksStatus;

package/dist/types/hooks/native-skill-hook.d.ts

@@ -0,0 +1,28 @@
+import { type EffectiveSkillConfigInput } from "./skill-state";
+export type SkcNativeHookEventName = "UserPromptSubmit" | "Stop";
+export interface SkcNativeHookDispatchResult {
+    hookEventName: SkcNativeHookEventName | null;
+    outputJson: Record<string, unknown> | null;
+}
+type HookPayload = Record<string, unknown>;
+interface SkcNativeHookDispatchOptions {
+    cwd?: string;
+    stateDir?: string;
+    effectiveSkillConfig?: EffectiveSkillConfigInput;
+    configPaths?: string[];
+}
+export declare function clearSkcNativeSkillHookCachesForTesting(): void;
+export declare function getSkcNativeSkillHookCacheStatsForTesting(): {
+    effectiveSkillConfigResolutions: number;
+};
+export declare function resolveSkcNativeSkillConfigForTesting(input: {
+    cwd: string;
+    configPaths?: string[];
+    sessionId?: string;
+    threadId?: string;
+    stateDir?: string;
+}): Promise<EffectiveSkillConfigInput>;
+export declare function dispatchSkcNativeSkillHook(payload: HookPayload, options?: SkcNativeHookDispatchOptions): Promise<SkcNativeHookDispatchResult>;
+export declare function runSkcNativeSkillHookInProcess(payload: HookPayload): Promise<string>;
+export declare function runSkcNativeSkillHookCli(): Promise<void>;
+export {};

package/dist/types/hooks/skill-keywords.d.ts

@@ -0,0 +1,18 @@
+import { type CanonicalSkcWorkflowSkill } from "../skill-state/active-state";
+export interface SkillKeywordDefinition {
+    keyword: string;
+    skill: SkcWorkflowSkill;
+    priority: number;
+    guidance: string;
+}
+export declare const SKC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
+export type SkcWorkflowSkill = CanonicalSkcWorkflowSkill;
+export declare const SKC_SKILL_KEYWORD_DEFINITIONS: readonly SkillKeywordDefinition[];
+export declare function isSkcWorkflowSkill(value: string): value is SkcWorkflowSkill;
+export declare function compareSkillKeywordMatches(a: {
+    priority: number;
+    keyword: string;
+}, b: {
+    priority: number;
+    keyword: string;
+}): number;

package/dist/types/hooks/skill-state.d.ts

@@ -0,0 +1,93 @@
+import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
+import { type SkillActiveState } from "../skill-state/active-state";
+import { initialPhaseForSkill } from "../skill-state/initial-phase";
+export { initialPhaseForSkill };
+import { type SkcWorkflowSkill } from "./skill-keywords";
+export declare const SKC_STATE_DIR = ".skc";
+export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
+export interface EffectiveSkillConfigInput {
+    skillsSettings?: SkillDiscoverySettings;
+    disabledExtensions?: string[];
+    unavailableReason?: string;
+}
+export declare function buildSanitizedEffectiveSkillConfigContext(input: EffectiveSkillConfigInput | undefined): string;
+export interface SkillKeywordMatch {
+    keyword: string;
+    skill: SkcWorkflowSkill;
+    priority: number;
+}
+export type { SkillActiveEntry, SkillActiveState } from "../skill-state/active-state";
+export interface ModeState {
+    active?: boolean;
+    current_phase?: string;
+    skill?: string;
+    session_id?: string;
+    thread_id?: string;
+    cwd?: string;
+    updated_at?: string;
+    handoff_from?: string;
+    handoff_to?: string;
+    handoff_at?: string;
+    [key: string]: unknown;
+}
+export interface RecordSkillActivationInput {
+    cwd: string;
+    text: string;
+    sessionId?: string;
+    threadId?: string;
+    turnId?: string;
+    nowIso?: string;
+    stateDir?: string;
+}
+export interface StopHookInput {
+    cwd: string;
+    sessionId?: string;
+    threadId?: string;
+    stateDir?: string;
+    sessionFile?: string;
+}
+export interface UserPromptSubmitStateInput {
+    cwd: string;
+    sessionId?: string;
+    threadId?: string;
+    stateDir?: string;
+    prompt?: string;
+    sessionFile?: string;
+}
+export declare function detectSkillKeywords(text: string): SkillKeywordMatch[];
+export declare function detectPrimarySkillKeyword(text: string): SkillKeywordMatch | null;
+export declare function resolveSkcStateDir(cwd: string, stateDir?: string): string;
+export interface StateRecoveryDiagnostic {
+    kind: "skill-active-state" | "mode-state";
+    statePath: string;
+    reason: "missing" | "corrupt" | "unreadable";
+    skill?: SkcWorkflowSkill;
+}
+export declare function buildStateRecoveryDiagnosticsContext(diagnostics: readonly StateRecoveryDiagnostic[]): string | null;
+export declare function collectUserPromptStateRecoveryDiagnostics(input: UserPromptSubmitStateInput): Promise<StateRecoveryDiagnostic[]>;
+export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, _stateDir?: string): Promise<SkillActiveState | null>;
+export declare function recordSkillActivation(input: RecordSkillActivationInput): Promise<SkillActiveState | null>;
+export interface EnsureWorkflowSkillActivationInput {
+    cwd: string;
+    skill: string;
+    sessionId?: string;
+    threadId?: string;
+    turnId?: string;
+    nowIso?: string;
+    stateDir?: string;
+}
+/**
+ * Idempotently seed `.skc/state` for a workflow skill that was invoked directly
+ * (e.g. via `/skill:<name>`) rather than through keyword detection. This ensures
+ * the mutation guard and Stop hook engage the moment a workflow skill becomes
+ * active, instead of relying on the skill prompt to run its own state-init steps.
+ *
+ * The seed is non-destructive: if an active entry for this skill already exists
+ * (for example after a `skc state handoff` promotion that carries
+ * `handoff_from`/`handoff_at` lineage), nothing is written so lineage is
+ * preserved. Non-workflow skills are ignored.
+ */
+export declare function ensureWorkflowSkillActivationState(input: EnsureWorkflowSkillActivationInput): Promise<SkillActiveState | null>;
+export declare function buildActiveUltragoalPromptContext(input: UserPromptSubmitStateInput): Promise<string | null>;
+export declare function buildSkillStopOutput(input: StopHookInput): Promise<Record<string, unknown> | null>;
+export declare function buildSkillActivationAdditionalContext(state: SkillActiveState, effectiveSkillConfig?: EffectiveSkillConfigInput): string;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,38 @@
+import { type MsgKey } from "./messages/en";
+export type Lang = "en" | "ko" | "zh" | "ja" | "es" | "fr" | "de";
+/** The value stored in settings — `auto` resolves to a concrete Lang. */
+export type LanguagePref = "auto" | Lang;
+export declare const SUPPORTED_LANGUAGES: readonly Lang[];
+/**
+ * Detect the user's language, defaulting to English.
+ *
+ * macOS often exports a misleading `LANG=en_US` even for non-English users, so:
+ *   1. an explicit non-English env locale wins (honors a deliberate override),
+ *   2. otherwise the real macOS UI locale (AppleLocale) is consulted,
+ *   3. otherwise the env locale (English) or Intl default is used.
+ */
+export declare function detectSystemLanguage(): Lang;
+/** Resolve a stored preference ("auto" | Lang) to a concrete Lang. */
+export declare function resolveLanguage(pref: LanguagePref): Lang;
+/** Set the active UI language. Accepts "auto" to follow the system locale. */
+export declare function setLanguage(pref: LanguagePref): void;
+export declare function getLanguage(): Lang;
+/**
+ * Translate `key` for the active language. Falls back: active → English → key.
+ * `params` interpolates `{name}` placeholders.
+ */
+export declare function t(key: MsgKey, params?: Record<string, string | number>): string;
+/**
+ * Translate a settings/command string by its path-derived `key`, falling back to
+ * the supplied English `fallback` (the schema's source value). For English (or any
+ * missing translation) the fallback is returned unchanged.
+ */
+export declare function td(key: string, fallback: string): string;
+/**
+ * Translate a runtime status/error/warning message. Tries an exact catalog match,
+ * then the longest known static prefix (translating the prefix and keeping the
+ * dynamic tail — a path, id, or error text — verbatim). Returns the original when
+ * nothing matches or the active language is English.
+ */
+export declare function tMessage(message: string): string;
+export type { MsgKey };

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

@@ -0,0 +1,2 @@
+import type { MsgKey } from "./en";
+export declare const de: Partial<Record<MsgKey, string>>;

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

@@ -0,0 +1 @@
+export declare const deMsgs: Record<string, string>;

package/dist/types/i18n/messages/de.settings.d.ts

@@ -0,0 +1 @@
+export declare const deSettings: Record<string, string>;

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

@@ -0,0 +1,82 @@
+export declare const en: {
+    readonly "lang.auto": "Auto (system)";
+    readonly "lang.en": "English";
+    readonly "lang.ko": "한국어";
+    readonly "lang.zh": "中文 (简体)";
+    readonly "lang.ja": "日本語";
+    readonly "lang.es": "Español";
+    readonly "lang.fr": "Français";
+    readonly "lang.de": "Deutsch";
+    readonly "welcome.tagline": "Coding should feel like thinking.";
+    readonly "welcome.workflows": "Workflows";
+    readonly "welcome.wf.deepInterview": "scope · interview → spec";
+    readonly "welcome.wf.ralplan": "consensus plan";
+    readonly "welcome.wf.ultragoal": "autonomous build";
+    readonly "welcome.wf.team": "parallel agents";
+    readonly "welcome.flowKeys": "Flow keys";
+    readonly "welcome.commands": "commands";
+    readonly "welcome.actions": "actions";
+    readonly "welcome.shell": "shell";
+    readonly "welcome.python": "python";
+    readonly "welcome.keymap": "keymap";
+    readonly "welcome.model": "model";
+    readonly "welcome.reasoning": "reasoning";
+    readonly "welcome.projectPulse": "Project pulse";
+    readonly "welcome.noLsp": "No LSP servers";
+    readonly "welcome.sessionTrail": "Session trail";
+    readonly "welcome.noSessions": "No saved trails";
+    readonly "welcome.chooseModel": "choose a model";
+    readonly "welcome.modelHint": "ctrl+l to pick · / for commands";
+    readonly "settings.tab.appearance": "Appearance";
+    readonly "settings.tab.model": "Model";
+    readonly "settings.tab.interaction": "Interaction";
+    readonly "settings.tab.context": "Context";
+    readonly "settings.tab.memory": "Memory";
+    readonly "settings.tab.editing": "Editing";
+    readonly "settings.tab.tools": "Tools";
+    readonly "settings.tab.tasks": "Tasks";
+    readonly "settings.tab.providers": "Providers";
+    readonly "settings.tab.integrations": "Integrations";
+    readonly "settings.tab.notifications": "Notifications";
+    readonly "settings.language.label": "Language";
+    readonly "settings.language.desc": "Interface language. Auto follows your system locale.";
+    readonly "help.usage": "USAGE";
+    readonly "help.flags": "FLAGS";
+    readonly "help.commands": "COMMANDS";
+    readonly "help.examples": "EXAMPLES";
+    readonly "help.envVars": "ENVIRONMENT VARIABLES";
+    readonly "help.tools": "AVAILABLE TOOLS";
+    readonly "help.usefulCommands": "USEFUL COMMANDS";
+    readonly "help.appDescription": "Sayknow-CLI — an AI coding assistant";
+    readonly "statusline.plan": "Plan";
+    readonly "statusline.goal": "Goal";
+    readonly "statusline.paused": "paused";
+    readonly "common.yes": "Yes";
+    readonly "common.no": "No";
+    readonly "nav.hint": "up/down navigate  enter select  esc cancel";
+    readonly "star.title": "Enjoying Sayknow-CLI?";
+    readonly "star.message": "Star {repo} on GitHub to support the project?";
+    readonly "cmd.settings": "Open settings menu";
+    readonly "cmd.theme": "Open theme selector";
+    readonly "cmd.model": "Select model (opens selector UI)";
+    readonly "cmd.help": "Show help";
+    readonly "cmd.export": "Export session to HTML file";
+    readonly "cmd.session": "Session management commands";
+    readonly "cmd.clear": "Clear the conversation";
+    readonly "cmd.quit": "Exit Sayknow-CLI";
+    readonly "modelSelector.presets": "Model presets";
+    readonly "modelSelector.createCustom": "Create custom preset";
+    readonly "modelSelector.browseAll": "Browse all models";
+    readonly "modelSelector.applySession": "Apply for this session";
+    readonly "modelSelector.setDefault": "Set as default";
+    readonly "modelSelector.pressEnterApply": "Press Enter to apply this preset";
+    readonly "modelSelector.presetPreview": "Preset preview: {name}";
+    readonly "modelSelector.showingScoped": "Showing models from --models scope";
+    readonly "modelSelector.modelsTab": "Models";
+    readonly "modelSelector.noMatching": "No matching models.";
+    readonly "modelSelector.modelName": "Model Name: {value}";
+    readonly "modelSelector.actionFor": "Action for: {id}";
+    readonly "modelSelector.reasoningFor": "Reasoning for {target}: {id}";
+    readonly "modelSelector.temporaryModel": "temporary model";
+};
+export type MsgKey = keyof typeof en;

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

@@ -0,0 +1,2 @@
+import type { MsgKey } from "./en";
+export declare const es: Partial<Record<MsgKey, string>>;

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

@@ -0,0 +1 @@
+export declare const esMsgs: Record<string, string>;

package/dist/types/i18n/messages/es.settings.d.ts

@@ -0,0 +1 @@
+export declare const esSettings: Record<string, string>;

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

@@ -0,0 +1,2 @@
+import type { MsgKey } from "./en";
+export declare const fr: Partial<Record<MsgKey, string>>;

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

@@ -0,0 +1 @@
+export declare const frMsgs: Record<string, string>;

package/dist/types/i18n/messages/fr.settings.d.ts

@@ -0,0 +1 @@
+export declare const frSettings: Record<string, string>;

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

@@ -0,0 +1,2 @@
+import type { MsgKey } from "./en";
+export declare const ja: Partial<Record<MsgKey, string>>;

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

@@ -0,0 +1 @@
+export declare const jaMsgs: Record<string, string>;

package/dist/types/i18n/messages/ja.settings.d.ts

@@ -0,0 +1 @@
+export declare const jaSettings: Record<string, string>;

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

@@ -0,0 +1,2 @@
+import type { MsgKey } from "./en";
+export declare const ko: Partial<Record<MsgKey, string>>;

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

@@ -0,0 +1 @@
+export declare const koMsgs: Record<string, string>;

package/dist/types/i18n/messages/ko.settings.d.ts

@@ -0,0 +1 @@
+export declare const koSettings: Record<string, string>;

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

@@ -0,0 +1,2 @@
+import type { MsgKey } from "./en";
+export declare const zh: Partial<Record<MsgKey, string>>;

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

@@ -0,0 +1 @@
+export declare const zhMsgs: Record<string, string>;

package/dist/types/i18n/messages/zh.settings.d.ts

@@ -0,0 +1 @@
+export declare const zhSettings: Record<string, string>;

package/dist/types/index.d.ts

@@ -0,0 +1,33 @@
+import { HookEditorComponent, HookInputComponent, HookSelectorComponent } from "./modes/components";
+export { Container, Markdown, Spacer, Text } from "@sayknow-cli/tui";
+export { getAgentDir, logger, VERSION } from "@sayknow-cli/utils";
+export * from "./config/keybindings";
+export * from "./config/model-registry";
+export type * from "./config/prompt-templates";
+export * from "./config/prompt-templates";
+export type { RetrySettings, SkillsSettings } from "./config/settings";
+export { Settings, settings } from "./config/settings";
+export type * from "./extensibility/custom-commands/types";
+export type * from "./extensibility/custom-tools";
+export * from "./extensibility/custom-tools";
+export type * from "./extensibility/extensions";
+export * from "./extensibility/extensions";
+export * from "./extensibility/skills";
+export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./extensibility/slash-commands";
+export * from "./hashline";
+export type * from "./lsp";
+export * from "./main";
+export * from "./modes";
+export * from "./modes/components";
+export * from "./modes/theme/theme";
+export * from "./sdk";
+export * from "./session/agent-session";
+export * from "./session/auth-storage";
+export * from "./session/messages";
+export * from "./session/session-dump-format";
+export * from "./session/session-manager";
+export * from "./task/executor";
+export type * from "./task/types";
+export * from "./tools";
+export * from "./utils/git";
+export { HookEditorComponent as ExtensionEditorComponent, HookInputComponent as ExtensionInputComponent, HookSelectorComponent as ExtensionSelectorComponent, };

package/dist/types/internal-urls/agent-protocol.d.ts

@@ -0,0 +1,12 @@
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
+/**
+ * Handler for agent:// URLs.
+ *
+ * Resolves output IDs like "reviewer_0" to their artifact files,
+ * with optional JSON extraction.
+ */
+export declare class AgentProtocolHandler implements ProtocolHandler {
+    readonly scheme = "agent";
+    readonly immutable = true;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+}

package/dist/types/internal-urls/artifact-protocol.d.ts

@@ -0,0 +1,6 @@
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
+export declare class ArtifactProtocolHandler implements ProtocolHandler {
+    readonly scheme = "artifact";
+    readonly immutable = true;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+}

package/dist/types/internal-urls/docs-index.generated.d.ts

@@ -0,0 +1,2 @@
+export declare const EMBEDDED_DOC_FILENAMES: readonly string[];
+export declare const EMBEDDED_DOCS: Readonly<Record<string, string>>;

package/dist/types/internal-urls/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Internal URL routing system for internal protocols like agent://, memory://,
+ * rule://, and local://.
+ *
+ * One process-global `InternalUrlRouter` is shared across sessions. Handlers
+ * are stateless; they pull whatever they need (active skills/rules, active
+ * MCP/async managers, AgentRegistry-listed sessions) from the owning module
+ * on each resolve call.
+ */
+export * from "./agent-protocol";
+export * from "./artifact-protocol";
+export * from "./issue-pr-protocol";
+export * from "./json-query";
+export * from "./local-protocol";
+export * from "./memory-protocol";
+export * from "./parse";
+export * from "./router";
+export * from "./rule-protocol";
+export * from "./skc-protocol";
+export type * from "./types";

package/dist/types/internal-urls/issue-pr-protocol.d.ts

@@ -0,0 +1,17 @@
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext } from "./types";
+/**
+ * Handler for `issue://` URLs.
+ */
+export declare class IssueProtocolHandler implements ProtocolHandler {
+    readonly scheme = "issue";
+    readonly immutable = true;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+}
+/**
+ * Handler for `pr://` URLs.
+ */
+export declare class PrProtocolHandler implements ProtocolHandler {
+    readonly scheme = "pr";
+    readonly immutable = true;
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+}

package/dist/types/internal-urls/json-query.d.ts

@@ -0,0 +1,30 @@
+/**
+ * JSON query parser and executor for agent:// URL extraction.
+ *
+ * Supports jq-like syntax: .foo, [0], .foo.bar[0].baz, ["special-key"]
+ * Also supports path form: /foo/bar/0 -> .foo.bar[0]
+ */
+/**
+ * Parse a jq-like query string into tokens.
+ *
+ * @example
+ * parseQuery(".foo.bar[0]") // ["foo", "bar", 0]
+ * parseQuery(".foo['special-key']") // ["foo", "special-key"]
+ */
+export declare function parseQuery(query: string): Array<string | number>;
+/**
+ * Apply a parsed query to a JSON value.
+ *
+ * @example
+ * applyQuery({ foo: { bar: [1, 2, 3] } }, ".foo.bar[0]") // 1
+ */
+export declare function applyQuery(data: unknown, query: string): unknown;
+/**
+ * Convert a URL path form to a query string.
+ *
+ * Path form: /foo/bar/0 -> .foo.bar[0]
+ * Trailing slash is normalized (ignored).
+ *
+ * Segments that are not valid identifiers use bracket notation: ['segment']
+ */
+export declare function pathToQuery(urlPath: string): string;