@jawcode-dev/coding-agent 1.1.0

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

@@ -0,0 +1,29 @@
+export declare const GJC_MANAGED_CODEX_HOOK_EVENTS: readonly ["UserPromptSubmit", "Stop"];
+export type JwcManagedCodexHookEvent = (typeof GJC_MANAGED_CODEX_HOOK_EVENTS)[number];
+export interface CodexCommandHook {
+    type: "command";
+    command: string;
+    statusMessage?: string;
+    timeout?: number;
+}
+export interface CodexHookEntry {
+    hooks: CodexCommandHook[];
+}
+export interface JwcManagedCodexHooksConfig {
+    hooks: Record<JwcManagedCodexHookEvent, CodexHookEntry[]>;
+}
+export interface MergeJwcManagedCodexHooksResult {
+    content: string;
+    changed: boolean;
+    managedHookCount: number;
+}
+export interface JwcCodexHooksStatus {
+    hooksPath: string;
+    installed: boolean;
+    missingEvents: JwcManagedCodexHookEvent[];
+    managedHookCount: number;
+}
+export declare function buildJwcManagedCodexHooksConfig(): JwcManagedCodexHooksConfig;
+export declare function getDefaultCodexHooksPath(homeDir?: string): string;
+export declare function mergeJwcManagedCodexHooksConfig(existingContent: string | null): MergeJwcManagedCodexHooksResult;
+export declare function readJwcManagedCodexHooksStatus(content: string | null, hooksPath: string): JwcCodexHooksStatus;

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

@@ -0,0 +1,16 @@
+import { type EffectiveSkillConfigInput } from "./skill-state";
+export type JwcNativeHookEventName = "UserPromptSubmit" | "Stop";
+export interface JwcNativeHookDispatchResult {
+    hookEventName: JwcNativeHookEventName | null;
+    outputJson: Record<string, unknown> | null;
+}
+type HookPayload = Record<string, unknown>;
+interface JwcNativeHookDispatchOptions {
+    cwd?: string;
+    stateDir?: string;
+    effectiveSkillConfig?: EffectiveSkillConfigInput;
+    configPaths?: string[];
+}
+export declare function dispatchJwcNativeSkillHook(payload: HookPayload, options?: JwcNativeHookDispatchOptions): Promise<JwcNativeHookDispatchResult>;
+export declare function runJwcNativeSkillHookCli(): Promise<void>;
+export {};

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

@@ -0,0 +1,18 @@
+import { type CanonicalJwcWorkflowSkill } from "../skill-state/active-state";
+export interface SkillKeywordDefinition {
+    keyword: string;
+    skill: JwcWorkflowSkill;
+    priority: number;
+    guidance: string;
+}
+export declare const GJC_WORKFLOW_SKILLS: readonly ["jaw-interview", "plan", "goal", "team"];
+export type JwcWorkflowSkill = CanonicalJwcWorkflowSkill;
+export declare const JWC_SKILL_KEYWORD_DEFINITIONS: readonly SkillKeywordDefinition[];
+export declare function isJwcWorkflowSkill(value: string): value is JwcWorkflowSkill;
+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,88 @@
+import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
+import { type SkillActiveState } from "../skill-state/active-state";
+import { type JwcWorkflowSkill } from "./skill-keywords";
+export declare const GJC_STATE_DIR = ".jwc/state";
+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: JwcWorkflowSkill;
+    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 resolveJwcStateDir(cwd: string, stateDir?: string): string;
+import { initialPhaseForSkill } from "../skill-state/initial-phase";
+export { initialPhaseForSkill };
+interface ReadVisibleSkillActiveStateOptions {
+    strictSession?: boolean;
+}
+export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, stateDir?: string, options?: ReadVisibleSkillActiveStateOptions): 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 `.jwc/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 `jwc 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 buildActiveGoalPromptContext(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/index.d.ts

@@ -0,0 +1,33 @@
+import { HookEditorComponent, HookInputComponent, HookSelectorComponent } from "./modes/components";
+export { Container, Markdown, Spacer, Text } from "@jawcode-dev/tui";
+export { getAgentDir, logger, VERSION } from "@jawcode-dev/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 "./jwc-protocol";
+export * from "./local-protocol";
+export * from "./memory-protocol";
+export * from "./parse";
+export * from "./router";
+export * from "./rule-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;

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

@@ -0,0 +1,19 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+/**
+ * Handler for jwc:// URLs.
+ *
+ * Resolves documentation file names to their content, or lists available docs.
+ */
+export declare class JwcProtocolHandler implements ProtocolHandler {
+    #private;
+    readonly scheme: string;
+    readonly immutable = true;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}
+/**
+ * Legacy alias: gjc:// resolves identically to jwc:// during the transition
+ * window (065.1 D). Remove after the deprecation period.
+ */
+export declare class LegacyJwcProtocolAliasHandler extends JwcProtocolHandler {
+    readonly scheme: string;
+}

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

@@ -0,0 +1,39 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+export interface LocalProtocolOptions {
+    getArtifactsDir?: () => string | null;
+    getSessionId?: () => string | null;
+}
+export declare function resolveLocalRoot(options: LocalProtocolOptions): string;
+export declare function resolveLocalUrlToPath(input: string | InternalUrl, options: LocalProtocolOptions): string;
+/**
+ * Protocol handler for local:// URLs.
+ *
+ * URL forms:
+ * - local:// - Lists files at the session local root
+ * - local://<path> - Reads a file under the session local root
+ */
+export declare class LocalProtocolHandler implements ProtocolHandler {
+    #private;
+    readonly scheme = "local";
+    readonly immutable = false;
+    /**
+     * Install a process-global override that wins over the AgentRegistry-based
+     * derivation. Used by SDK consumers that wire `localProtocolOptions` on
+     * `createAgentSession` and by subagents that share their parent's root.
+     */
+    static setOverride(value: LocalProtocolOptions | undefined): void;
+    /** Reset the process-global override. Test-only. */
+    static resetOverrideForTests(): void;
+    /**
+     * Returns the active local-protocol options.
+     *
+     * Resolution order:
+     * 1. Explicit override installed via {@link setOverride} (used by subagents
+     *    that share their parent's root and by SDK consumers with a custom
+     *    artifacts/session id mapping).
+     * 2. The main session in `AgentRegistry.global()`. Its `SessionManager`
+     *    supplies both `getArtifactsDir` and `getSessionId`.
+     */
+    static resolveOptions(): LocalProtocolOptions | undefined;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}

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

@@ -0,0 +1,12 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+/**
+ * Protocol handler for mcp:// URLs.
+ *
+ * URL form:
+ * - mcp://<resource-uri> (e.g. mcp://test://notes, mcp://ibkr://portfolio/positions)
+ */
+export declare class McpProtocolHandler implements ProtocolHandler {
+    readonly scheme = "mcp";
+    readonly immutable = true;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}

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

@@ -0,0 +1,23 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+/**
+ * Snapshot of memory roots for every registered session, deduped.
+ * Each session has its own cwd (possibly a worktree), so subagents and main
+ * may see different roots.
+ */
+export declare function memoryRootsFromRegistry(): string[];
+/**
+ * Resolve a memory:// URL to an absolute filesystem path under memory root.
+ */
+export declare function resolveMemoryUrlToPath(url: InternalUrl, memoryRoot: string): string;
+/**
+ * Protocol handler for memory:// URLs.
+ *
+ * Walks every active session's memory root. Worktree-based subagents have
+ * their own root; first one containing the file wins. Parent and subagent
+ * sharing a cwd see the same file regardless of order.
+ */
+export declare class MemoryProtocolHandler implements ProtocolHandler {
+    readonly scheme = "memory";
+    readonly immutable = true;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Internal URL parser that handles colons in the host segment.
+ *
+ * Standard `new URL()` interprets colons as port separators, which breaks
+ * namespaced internal URLs like `skill://plugin:name`. This parser extracts
+ * components via regex first, then falls back to a minimal URL-like object
+ * when `new URL()` fails.
+ *
+ * All code that parses internal URLs (router, protocol handlers, tools)
+ * MUST use this function instead of calling `new URL()` directly.
+ */
+import type { InternalUrl } from "./types";
+/**
+ * Parse an internal URL into an InternalUrl.
+ *
+ * Handles URLs where `new URL()` would fail (e.g., `skill://plugin:name`
+ * where the colon is not a port separator).
+ */
+export declare function parseInternalUrl(input: string): InternalUrl;

package/dist/types/internal-urls/registry-helpers.d.ts

@@ -0,0 +1,11 @@
+import type { ResolveContext } from "./types";
+/**
+ * Snapshot of artifacts dirs explicitly authorized for the calling session.
+ *
+ * Normal reads are scoped to the caller's artifacts directory. Parent/child
+ * agent tree sharing is allowed only when the caller supplies explicit
+ * authorized directories at the ResolveContext boundary. This intentionally
+ * does not enumerate AgentRegistry.global(); live but unrelated sessions are
+ * not an authorization source.
+ */
+export declare function authorizedArtifactsDirsFromContext(context?: ResolveContext): string[];

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

@@ -0,0 +1,14 @@
+import type { InternalResource, ProtocolHandler, ResolveContext } from "./types";
+export declare class InternalUrlRouter {
+    #private;
+    constructor();
+    /** Process-global router instance. */
+    static instance(): InternalUrlRouter;
+    /** Reset the global instance in tests. */
+    static resetForTests(): void;
+    register(handler: ProtocolHandler): void;
+    unregister(scheme: string): boolean;
+    getHandler(scheme: string): ProtocolHandler | undefined;
+    canHandle(input: string): boolean;
+    resolve(input: string, context?: ResolveContext): Promise<InternalResource>;
+}

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

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

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

@@ -0,0 +1,13 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+/**
+ * Validate that a path is safe (no traversal, no absolute paths).
+ */
+export declare function validateRelativePath(relativePath: string): void;
+/**
+ * Handler for skill:// URLs.
+ */
+export declare class SkillProtocolHandler implements ProtocolHandler {
+    readonly scheme = "skill";
+    readonly immutable = true;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}

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

@@ -0,0 +1,109 @@
+/**
+ * Types for the internal URL routing system.
+ *
+ * Internal URLs (agent://, artifact://, memory://, rule://, gjc://, local://) are resolved by tools like read,
+ * providing access to agent outputs and server resources without exposing filesystem paths.
+ */
+/**
+ * Raw resource payload returned by protocol handlers. The `immutable` flag is
+ * applied by the router from {@link ProtocolHandler.immutable}, so handlers do
+ * not need to set it themselves.
+ */
+export interface InternalResource {
+    /** Canonical URL that was resolved */
+    url: string;
+    /** Resolved text content */
+    content: string;
+    /** MIME type: text/markdown, application/json, or text/plain */
+    contentType: "text/markdown" | "application/json" | "text/plain";
+    /** Content size in bytes */
+    size?: number;
+    /** Underlying filesystem path (for debugging, not exposed to agent) */
+    sourcePath?: string;
+    /** Additional notes about resolution */
+    notes?: string[];
+    /**
+     * True when the resolved content cannot be edited by the agent (e.g. sealed
+     * artifacts, harness docs, machine-generated memory summaries). Hashline
+     * anchors and similar edit affordances are suppressed for immutable
+     * resources. Mutable resources (e.g. local://) behave like editable files.
+     */
+    immutable?: boolean;
+}
+/**
+ * Parsed internal URL with preserved host casing.
+ */
+export interface InternalUrl extends URL {
+    /**
+     * Raw host segment extracted from input, preserving case.
+     */
+    rawHost: string;
+    /**
+     * Raw pathname extracted from input, preserving traversal markers before URL normalization.
+     */
+    rawPathname?: string;
+}
+/**
+ * Caller-supplied context that the router threads into protocol handlers.
+ *
+ * Read tool calls `InternalUrlRouter.resolve(url, { cwd, settings, signal })`
+ * so handlers can resolve relative defaults (e.g. `issue://N` → which repo?)
+ * against the actual session that initiated the read, not whichever session
+ * happens to be registered first in the global `AgentRegistry`.
+ */
+export interface ResolveContext {
+    /** Working directory of the calling session. */
+    cwd?: string;
+    /** Settings of the calling session (used by `issue://`/`pr://` for cache TTLs). */
+    settings?: unknown;
+    /** Artifacts directory of the calling session. */
+    getArtifactsDir?: () => string | null;
+    /** Additional artifacts directories explicitly authorized for this caller (for parent/child agent trees). */
+    getAuthorizedArtifactsDirs?: () => readonly string[];
+    /** Caller's abort signal. */
+    signal?: AbortSignal;
+}
+/**
+ * Caller context for write operations dispatched to host-owned URI handlers.
+ * Mirrors {@link ResolveContext} so handlers that share read/write state can
+ * accept the same shape.
+ */
+export interface WriteContext {
+    /** Working directory of the calling session. */
+    cwd?: string;
+    /** Caller's abort signal. */
+    signal?: AbortSignal;
+}
+/**
+ * Handler for a specific internal URL scheme (e.g., agent://, memory://).
+ */
+export interface ProtocolHandler {
+    /** The scheme this handler processes (without trailing ://) */
+    readonly scheme: string;
+    /**
+     * Whether resources produced by this handler are immutable (cannot be
+     * edited by the agent). When true, callers suppress hashline anchors and
+     * other edit affordances. When false, resources behave like editable files.
+     */
+    readonly immutable: boolean;
+    /**
+     * Resolve an internal URL to its content. The router stamps the
+     * {@link InternalResource.immutable} flag from {@link ProtocolHandler.immutable}.
+     *
+     * @param url Parsed URL object
+     * @param context Optional caller context. Handlers that depend on caller
+     *   identity (working directory, settings) **MUST** consume this in
+     *   preference to global state.
+     * @throws Error with user-friendly message if resolution fails
+     */
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    /**
+     * Optional write hook. When present, the write tool dispatches
+     * `write(url, content)` to this handler instead of writing to a filesystem
+     * path. The handler is responsible for any persistence and validation.
+     *
+     * Handlers that omit this method are treated as read-only; the write tool
+     * surfaces a clear "not writable" error when invoked against them.
+     */
+    write?(url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
+}

package/dist/types/jaw-interview/structured-renderer.d.ts

@@ -0,0 +1,20 @@
+import { type Component } from "@jawcode-dev/tui";
+import type { AskGateQuestionMeta } from "../modes/shared/agent-wire/jaw-interview-gate";
+import { type Theme } from "../modes/theme/theme";
+/**
+ * Structured TUI renderer for jaw-interview questions (042 D040-3 / D041-A).
+ *
+ * Renders the round header from the ask tool's structured `meta` field instead of
+ * regex-parsing a `Round N | ...` text protocol. Language-safe by construction:
+ * no English keyword anchors, so Korean (or any) sessions render identically.
+ */
+export interface StructuredInterviewQuestion {
+    question: string;
+    meta: AskGateQuestionMeta;
+}
+/** Render one structured interview question for tool-call display. */
+export declare function renderInterviewQuestion(input: StructuredInterviewQuestion, uiTheme: Theme): Component;
+/** Plain-text selector prompt built from structured meta (selector dialogs take a string). */
+export declare function formatInterviewSelectorPrompt(input: StructuredInterviewQuestion): string;
+/** Questions with structured meta get numbered options, mirroring the legacy behavior. */
+export declare function isStructuredInterviewQuestion(meta: AskGateQuestionMeta | undefined): meta is AskGateQuestionMeta;