@gajae-code/coding-agent 0.18.6 → 0.18.8

package/dist/types/extensibility/extensions/types.d.ts

@@ -27,6 +27,7 @@ import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { CustomEditor } from "../../modes/components/custom-editor";
 import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/workflow-gate-broker";
 import type { Theme } from "../../modes/theme/theme";
+import type { ProjectProgressSnapshot } from "../../progress/progress-contract";
 import type { AgentSessionEventListener } from "../../session/agent-session";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
 import type { CustomMessage } from "../../session/messages";
@@ -339,6 +340,8 @@ export interface ExtensionContext {
         totalBytes: number;
     } | undefined>;
     getJobs(): unknown;
+    /** Read-only project progress snapshot (`session.progress`), derived from durable session state. */
+    getProjectProgress?(): Promise<ProjectProgressSnapshot>;
     /** Subscribe to foreground-wait folds (`bash_folded`). Returns an unsubscribe function. */
     onJobFold?(listener: (event: JobFoldEvent) => void): () => void;
     /** Observe session events synchronously in producer order. Returns an unsubscribe function. */
@@ -498,6 +501,8 @@ export interface AgentStartEvent extends SharedAgentStartEvent {
     sdkRunToken?: string;
     /** Complete set of SDK queue owners consumed together by this run. */
     sdkRunTokens?: string[];
+    /** Internal public lifecycle boundary; accepted retries with a suppressed predecessor end retain it. */
+    lifecycleScope?: AttemptScope;
 }
 /** Fired when an agent run fails before emitting agent_end. The error is the
  * sanitized `{ code, message }` diagnostic from the agent runtime — never the raw
@@ -1180,6 +1185,8 @@ export interface ExtensionContextActions {
         totalBytes: number;
     } | undefined>;
     getJobs?: () => unknown;
+    /** Read-only project progress snapshot backing the `session.progress` SDK query. */
+    getProjectProgress?: () => Promise<ProjectProgressSnapshot>;
     /** Subscribe to foreground-wait folds so the SDK host can publish `bash_folded`. Returns an unsubscribe. */
     onJobFold?: (listener: (event: JobFoldEvent) => void) => () => void;
     /** Ordered, synchronous AgentSession subscription, independent of async extension hooks. */

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

@@ -22,6 +22,19 @@ export declare function safePluginMcpDiagnostic(value: unknown): string;
 export declare function getGjcPluginToolDeclarations(cwd: string): Promise<GjcPluginToolDeclaration[]>;
 /** Serve the canonical schemas keyed by their stable tool surface id. */
 export declare function serveGjcPluginSchemas(cwd: string): Promise<Record<string, JsonSchema202012>>;
+/** Startup identity of a file: the object `hashStableFile` must still be reading. */
+export interface StableFileIdentity {
+    dev: number;
+    ino: number;
+    size: number;
+    mtimeMs: number;
+    ctimeMs: number;
+}
+/**
+ * Digest of a `node` that was on PATH at startup, or `undefined` when the path
+ * was not a startup candidate or no longer is the startup file object.
+ */
+export declare function getInitialNodeHash(realPath: string): Promise<string | undefined>;
 /**
  * SHA-256 of a regular file with the same stability contract as `readStableFile`
  * (follows symlinks, bounded size, rejects a file that changes while it is read),
@@ -29,7 +42,7 @@ export declare function serveGjcPluginSchemas(cwd: string): Promise<Record<strin
  * on PATH; buffering each interpreter (~120 MiB) held its full bytes in the
  * session process until exit.
  */
-export declare function hashStableFile(filePath: string, label: string, maxBytes: number): Promise<string>;
+export declare function hashStableFile(filePath: string, label: string, maxBytes: number, expected?: StableFileIdentity): Promise<string>;
 /**
  * Load the always-on plugin tool surfaces for the effective registry at `cwd`.
  *

package/dist/types/extensibility/plugins/marketplace/cache.d.ts

@@ -23,6 +23,8 @@ export declare function getCachedPluginPath(cacheDir: string, marketplace: strin
  * so a partial previous cache is never silently reused.
  */
 export declare function cachePlugin(sourcePath: string, cacheDir: string, marketplace: string, pluginName: string, version: string): Promise<string>;
+/** Write a regular file. A symlink at the destination is removed, not followed. */
+export declare function writeCachedRegularFile(targetPath: string, content: string): Promise<void>;
 export declare function stageCachedPlugin(sourcePath: string, stagingPath: string): Promise<string>;
 export declare function digestCachedPlugin(targetPath: string): Promise<string | undefined>;
 export declare function inspectCachedPlugin(targetPath: string): Promise<{

package/dist/types/extensibility/plugins/plugin-link-path.d.ts

@@ -0,0 +1,2 @@
+/** Resolve a package.json name under the plugins node_modules root, or throw. */
+export declare function resolvePluginLinkPath(root: string, name: string): string;

package/dist/types/extensibility/runtime-skill-discovery.d.ts

@@ -47,6 +47,8 @@ export interface DiscoverRuntimeSkillsOptions {
     offset?: number;
     source?: RuntimeSkillDiscoveryScope | "all";
     policy?: SkillsSettings;
+    /** User-owned permission to read external user skill symlinks; defaults to the direct policy value. */
+    allowExternalUserSkillSymlinks?: boolean;
 }
 /**
  * Upper bound every caller's `limit` clamps to. Exported so `gjc skills discover`
@@ -71,5 +73,5 @@ export declare function describeDisabledSkillScopes(source: RuntimeSkillDiscover
  */
 export declare function describeNoSkillMatch(query: string | undefined, scanned: number): string | undefined;
 export declare function discoverRuntimeSkills(options: DiscoverRuntimeSkillsOptions): Promise<RuntimeSkillDiscoveryResult>;
-export declare function findRuntimeSkillByName(cwd: string, name: string, policy?: SkillsSettings, home?: string, agentDir?: string, profileAuthority?: "default" | "custom"): Promise<Skill | undefined>;
+export declare function findRuntimeSkillByName(cwd: string, name: string, policy?: SkillsSettings, home?: string, agentDir?: string, profileAuthority?: "default" | "custom", allowExternalUserSkillSymlinks?: boolean): Promise<Skill | undefined>;
 export {};

package/dist/types/extensibility/skill-management.d.ts

@@ -80,8 +80,10 @@ export declare function listNativeSkillsForManagement(options: {
     cwd: string;
     home?: string;
     agentDir?: string;
-    /** Resolver-owned profile classification; unlike path comparison, this survives HOME refreshes. */
+    /** Resolver-owned profile classification; unlike path comparison, this survives HOME/config refreshes. */
     profileAuthority?: "default" | "custom";
+    /** User-owned permission to follow symlinks outside user skill scan roots. */
+    allowExternalUserSkillSymlinks?: boolean;
     policy?: SkillManagementPolicy;
 }): Promise<ManagedSkillRecord[]>;
 /**

package/dist/types/extensibility/skills.d.ts

@@ -59,6 +59,8 @@ export interface LoadSkillsOptions extends SkillsSettings {
     agentDir?: string;
     /** Resolver-owned classification for the selected agent directory. */
     profileAuthority?: "default" | "custom";
+    /** User-owned permission to follow symlinks outside user skill scan roots. */
+    allowExternalUserSkillSymlinks?: boolean;
 }
 /**
  * Load skills from all configured locations.

package/dist/types/gjc-runtime/deep-interview-crystallize.d.ts

@@ -0,0 +1,74 @@
+export type CrystalClassification = "confirmed" | "inferred" | "disputed";
+export type CrystalItemKind = "goal" | "constraint" | "decision" | "acceptance_criterion" | "non_goal";
+export interface CrystalMessage {
+    index: number;
+    role: "user" | "assistant" | "system" | "tool" | "toolResult" | "developer";
+    content: string;
+}
+export interface CrystalSnapshot {
+    revision: number;
+    start: number;
+    end: number;
+    digest: string;
+    messages: CrystalMessage[];
+}
+export interface CrystalItem {
+    id: string;
+    kind: CrystalItemKind;
+    classification: CrystalClassification;
+    statement: string;
+    anchor?: {
+        message_index: number;
+        quote: string;
+    };
+}
+export interface CrystalInput {
+    snapshot: CrystalSnapshot;
+    current_revision: number;
+    items: CrystalItem[];
+    removed_ids?: string[];
+    removed_item_anchors?: CrystalResolutionAnchor[];
+    open_gaps?: string[];
+    conflicts?: string[];
+    resolved_open_gaps?: string[];
+    resolved_conflicts?: string[];
+    resolved_open_gap_anchors?: CrystalResolutionAnchor[];
+    resolved_conflict_anchors?: CrystalResolutionAnchor[];
+    prior?: DeepInterviewCrystal;
+}
+export interface CrystalResolutionAnchor {
+    item: string;
+    message_index: number;
+    quote: string;
+    resolution: string;
+}
+export interface CrystalDelta {
+    kind: "none" | "additive" | "intent-changed" | "goal-replaced" | "stale";
+    changed_ids: string[];
+    added_ids: string[];
+    preserved_ids: string[];
+    approval_invalidated: boolean;
+}
+export interface DeepInterviewCrystal {
+    schema_version: 1;
+    spec_version: number;
+    lifecycle: "ready" | "needs-questions" | "stale" | "superseded";
+    source: {
+        revision: number;
+        start: number;
+        end: number;
+        digest: string;
+        messages: CrystalMessage[];
+    };
+    items: CrystalItem[];
+    removed_ids?: string[];
+    removed_item_anchors?: CrystalResolutionAnchor[];
+    pending_removals?: string[];
+    open_gaps: string[];
+    conflicts: string[];
+    delta: CrystalDelta;
+    execution_approval: "not-approved";
+}
+export declare function crystalSnapshotDigest(snapshot: Pick<CrystalSnapshot, "revision" | "start" | "end" | "messages">): string;
+export declare function crystallizeDeepInterview(value: unknown): DeepInterviewCrystal;
+export declare function crystalMarkdown(crystal: DeepInterviewCrystal): string;

package/dist/types/gjc-runtime/deep-interview-runtime.d.ts

@@ -1,3 +1,4 @@
+import { type CrystalSnapshot } from "./deep-interview-crystallize";
 export * from "./deep-interview-recorder";
 /**
  * Native implementation of `gjc deep-interview`.
@@ -13,6 +14,16 @@ export interface DeepInterviewCommandResult {
     stdout?: string;
     stderr?: string;
 }
+export declare function authoritativeConversationSnapshot(cwd: string, sessionId: string): Promise<{
+    revision: number;
+    messages: CrystalSnapshot["messages"];
+    transcriptPath: string;
+    transcriptSha256: string;
+}>;
+export declare function assertDeepInterviewCrystalCoversLiveTranscript(cwd: string, sessionId: string, requireCrystalTail?: boolean): Promise<{
+    transcriptPath: string;
+    transcriptSha256: string;
+}>;
 export declare function deepInterviewStatePath(cwd: string, sessionId?: string): string;
 export interface ResolvedDeepInterviewSpecWriteArgs {
     stage: "final";

package/dist/types/gjc-runtime/gc-runtime.d.ts

@@ -181,6 +181,11 @@ export interface GcDiskRecord {
     action: GcDiskAction;
     reason: string;
     error?: string;
+    /** Exact incomplete retirement phase surfaced by the owning session adapter. */
+    phase?: "artifacts" | "transcript";
+    task_artifact_owner_retired?: true;
+    task_artifact_owner_payload_retired?: true;
+    task_artifact_owner_namespace_retained?: true;
     /** Set when `bytes` is a floor because a walk was capped or partially unreadable. */
     partial?: true;
     /** Set when this entry was a reclaim candidate that its surface withheld on incomplete evidence. */

package/dist/types/gjc-runtime/ralplan-runtime.d.ts

@@ -117,11 +117,6 @@ export declare function countRalplanOnDiskLaneArtifacts(cwd: string, sessionId:
     architect: number;
     critic: number;
 }>;
-/**
- * Load index rows for cap enforcement. Unlike HUD reads, returns structural
- * signals so callers can fail closed when the ledger is empty/malformed while
- * opener artifacts already exist on disk.
- */
 export declare function loadRalplanIndexForCap(cwd: string, sessionId: string, runId: string): Promise<{
     rows: RalplanIndexRow[];
     indexPresent: boolean;

package/dist/types/gjc-runtime/state-argv.d.ts

@@ -1,4 +1,4 @@
-export type StateAction = "read" | "write" | "clear" | "contract" | "handoff" | "graph" | "prune" | "gc" | "migrate" | "status" | "doctor";
+export type StateAction = "read" | "write" | "clear" | "contract" | "approve-execution" | "handoff" | "graph" | "prune" | "gc" | "migrate" | "status" | "doctor";
 export declare const STATE_ACTION_NAMES: ReadonlySet<StateAction>;
 export declare const STATE_FLAGS_WITH_VALUES: ReadonlySet<string>;
 export declare const STATE_BOOLEAN_FLAGS: ReadonlySet<string>;

package/dist/types/gjc-runtime/state-migrations.d.ts

@@ -20,6 +20,14 @@ export interface MigrateWorkflowStateResult {
     changed: boolean;
 }
 export type WorkflowStateMigration = (state: Record<string, unknown>, skill: CanonicalGjcWorkflowSkill) => Record<string, unknown>;
+/**
+ * A newer workflow envelope is not a legacy shape.  Treating it as one would
+ * silently downgrade state written by a newer runtime when any sanctioned
+ * read/modify/write path persists the result.  Callers that can surface a
+ * command error should use this guard before doing any merge; the migration
+ * primitive also enforces it so internal writers cannot bypass that boundary.
+ */
+export declare function assertNotFutureWorkflowState(state: Record<string, unknown>, skill: string, surface?: string): void;
 export declare function migrateWorkflowState(raw: Record<string, unknown>, skill: string): MigrateWorkflowStateResult;
 /**
  * Pure legacy state normalizer for background/internal readers.

package/dist/types/gjc-runtime/state-runtime.d.ts

@@ -36,5 +36,100 @@ export declare function reconcileWorkflowSkillState(options: {
     stateFile: string;
 }>;
 export declare function readWorkflowStateJson(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string, onWarning?: StateWarningSink): Promise<Record<string, unknown>>;
+/**
+ * A user-origin execution choice is deliberately kept outside the workflow
+ * envelope.  The envelope is agent/runtime state and therefore cannot itself
+ * be evidence that a human selected the execution path.  This record is the
+ * short-lived bridge from the structured ask surface to the explicit
+ * `approve-execution` command.
+ */
+export declare const DEEP_INTERVIEW_EXECUTION_APPROVAL_RECORD_FILE = "deep-interview-execution-approval.json";
+export declare const DEEP_INTERVIEW_EXECUTION_APPROVAL_MAX_AGE_MS: number;
+export interface ExecutionApprovalTranscriptBoundary {
+    byte_length: number;
+    device: string;
+    inode: string;
+    leaf_id: string | null;
+    approval_tool_call_id: string;
+}
+export declare function captureExecutionApprovalTranscriptBoundary(cwd: string, sessionId: string, transcriptPath: string, transcriptSha256: string, approvalToolCallId: string): Promise<ExecutionApprovalTranscriptBoundary>;
+export declare function assertExecutionApprovalTranscriptBoundary(cwd: string, sessionId: string, transcriptPath: string, transcriptSha256: string, boundary: unknown): Promise<void>;
+export type ExecutionApprovalStage = "deep-interview" | "ralplan";
+/** Select lineage before validation; malformed Crystal evidence must never fall back. */
+export declare function executionApprovalLineage(cwd: string, sessionId: string, stage: ExecutionApprovalStage): Promise<"crystal" | "ordinary">;
+export interface ExecutionApprovalPresentation {
+    state_path: string;
+    state_revision: number;
+    artifact_path: string;
+    artifact_sha256: string;
+    run_id: string | null;
+}
+export declare function nonCrystalExecutionApprovalRecordPath(cwd: string, sessionId: string, stage: ExecutionApprovalStage): string;
+/** Capture the exact publication shown by an execution approval gate. */
+export declare function captureExecutionApprovalPresentation(cwd: string, sessionId: string, stage: ExecutionApprovalStage): Promise<ExecutionApprovalPresentation>;
+export declare function recordNonCrystalExecutionApproval(options: {
+    cwd: string;
+    sessionId: string;
+    approvalStage: ExecutionApprovalStage;
+    questionId: string;
+    gateId: string;
+    target: "ultragoal";
+    selectedOptions: string[];
+    transcriptPath: string;
+    transcriptSha256: string;
+    toolCallId: string;
+    presentation: ExecutionApprovalPresentation;
+}): Promise<void>;
+export declare function revokeNonCrystalExecutionApproval(cwd: string, sessionId: string, stage: ExecutionApprovalStage): Promise<void>;
+export interface DeepInterviewExecutionApprovalRecord {
+    schema_version: 1;
+    status: "pending" | "consumed";
+    session_id: string;
+    target: "ultragoal";
+    state_path: string;
+    state_revision: number;
+    spec_path: string;
+    spec_sha256: string;
+    crystal_spec_version: number;
+    crystal_source_digest: string;
+    crystal_digest: string;
+    question_id: string;
+    gate_id: string;
+    answer_hash: string;
+    transcript_path: string;
+    transcript_sha256: string;
+    transcript_boundary: ExecutionApprovalTranscriptBoundary;
+    approval_stage?: "deep-interview" | "ralplan";
+    ralplan_state_path?: string;
+    ralplan_state_revision?: number;
+    ralplan_run_id?: string;
+    ralplan_final_path?: string;
+    ralplan_final_sha256?: string;
+    created_at: string;
+    expires_at: string;
+    consumed_at?: string;
+    consumed_mutation_id?: string;
+}
+export declare function deepInterviewExecutionApprovalRecordPath(cwd: string, sessionId: string): string;
+export declare function recordDeepInterviewExecutionApproval(options: {
+    cwd: string;
+    sessionId: string;
+    questionId: string;
+    gateId?: string;
+    target: string;
+    selectedOptions: readonly string[];
+    customInput?: string;
+    transcriptPath: string;
+    transcriptSha256: string;
+    toolCallId: string;
+    approvalStage?: "deep-interview" | "ralplan";
+    presentation: ExecutionApprovalPresentation;
+}): Promise<{
+    path: string;
+    record: DeepInterviewExecutionApprovalRecord;
+}>;
+export declare function revokeDeepInterviewExecutionApproval(cwd: string, sessionId: string): Promise<void>;
+/** Whether a verified automatic Ultragoal admission already authorizes handoff. */
+export declare function hasSanctionedRalplanFinalAdmissionForHandoff(cwd: string, sessionId: string): Promise<boolean>;
 export declare function runNativeStateCommand(args: string[], cwd?: string): Promise<StateCommandResult>;
 export {};

package/dist/types/gjc-runtime/state-writer.d.ts

@@ -56,6 +56,7 @@ export interface WorkflowTransactionJournal {
     callee?: CanonicalGjcWorkflowSkill;
     paths: string[];
     steps: string[];
+    approval_audit_offset?: number;
 }
 export type StateWritePolicy = "source" | "cache";
 export interface GuardedStateWriterOptions extends StateWriterOptions {
@@ -247,6 +248,12 @@ export declare function removeFileAudited(targetPath: string, options?: StateWri
 export declare function writeActiveEntry(cwd: string, sessionScope: string | ActiveSessionScope | undefined, skill: string, entry: SkillActiveEntry, options?: StateWriterOptions): Promise<GuardedWriteResult>;
 export declare function removeActiveEntry(cwd: string, sessionScope: string | ActiveSessionScope | undefined, skill: string, options?: StateWriterOptions): Promise<DeleteResult>;
 export declare function readActiveEntries(cwd: string, sessionScope?: string | ActiveSessionScope): Promise<SkillActiveEntry[]>;
+/**
+ * Failure-observable counterpart of `readActiveEntries`: an entry file that exists
+ * but holds no usable skill entry throws instead of being skipped, so its absence
+ * from the result always means the entry does not exist.
+ */
+export declare function readActiveEntriesStrict(cwd: string, sessionScope?: string | ActiveSessionScope): Promise<SkillActiveEntry[]>;
 export declare function rebuildActiveSnapshot(cwd: string, sessionScope?: string | ActiveSessionScope, options?: StateWriterOptions): Promise<string>;
 export declare function mergeActiveState(cwd: string, sessionScope: string | ActiveSessionScope | undefined, skill: string, entry: SkillActiveEntry, options?: StateWriterOptions): Promise<ActiveEntryWriteResult>;
 export declare function writeArtifact(targetPath: string, content: string, options?: StateWriterOptions): Promise<string>;
@@ -256,7 +263,10 @@ export declare function softDelete(targetPath: string, meta: Record<string, unkn
 export declare function hardPruneJson(targetPaths: readonly string[], selector: HardPruneSelector, options?: StateWriterOptions): Promise<string[]>;
 export declare function hardPrune(targets: readonly GenericHardPruneTarget[], selector: GenericHardPruneSelector, options?: StateWriterOptions): Promise<string[]>;
 export declare function forceOverwrite(targetPath: string, rawValue: unknown, options?: ForceOverwriteOptions): Promise<string>;
-export declare function appendAuditEntry(cwd: string, sessionIdOrEntry: string | AuditEntry, maybeEntry?: AuditEntry): Promise<string>;
+export declare function appendAuditEntry(cwd: string, sessionIdOrEntry: string | AuditEntry, maybeEntry?: AuditEntry, options?: {
+    lockHeld?: boolean;
+    beforeAppend?: (offset: number) => Promise<unknown>;
+}): Promise<string>;
 export declare function readWorkflowTransactionJournal(cwd: string, sessionId: string, mutationId: string): Promise<WorkflowTransactionJournal | undefined>;
 export declare function beginWorkflowTransactionJournal(input: {
     cwd: string;

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -251,6 +251,14 @@ export declare function createUltragoalPlan(input: {
     validationBatches?: UltragoalValidationBatchInput[];
     validationBatchJson?: string;
 }): Promise<UltragoalPlan>;
+/**
+ * Scheduler order shared with read-only projections: active, then pending, then failed
+ * only when the caller explicitly opts into retrying failed goals. Blocked,
+ * review_blocked, complete, and superseded goals are never schedulable.
+ */
+export declare function selectNextSchedulableGoal<T extends {
+    status: UltragoalGoalStatus;
+}>(goals: readonly T[], retryFailed: boolean): T | undefined;
 export interface UltragoalRunCompletionState {
     requiredGoals: UltragoalGoal[];
     incompleteGoals: UltragoalGoal[];

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

@@ -0,0 +1 @@
+export declare function realSkillPath(baseDir: string, targetPath: string): Promise<string>;

package/dist/types/lsp/workspace-path.d.ts

@@ -0,0 +1 @@
+export declare function assertInsideWorkspace(cwd: string, filePath: string): Promise<void>;

package/dist/types/modes/acp/acp-agent.d.ts

@@ -390,6 +390,13 @@ export declare function acpSkillInvocation(blocks: PromptRequest["prompt"]): {
     name: string;
     args: string;
 } | undefined;
+/**
+ * Recognize the builtin `/progress` command only when it is the complete, single text
+ * prompt. Like the TUI (`allowArgs: false`), `/progress <args>` is not the command.
+ */
+export declare function isAcpProgressCommand(blocks: PromptRequest["prompt"]): boolean;
+/** Render the `session.progress` query result as the plain-text `/progress` view. */
+export declare function acpProgressReportText(query: unknown): string;
 /** Convert every ACP prompt block the agent advertises without silently discarding context. */
 export declare function acpPromptPayload(blocks: PromptRequest["prompt"]): {
     text: string;

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

@@ -49,6 +49,12 @@ export declare class CustomEditor extends Editor {
     onQueue?: () => void;
     /** Called when Caps Lock is pressed. */
     onCapsLock?: () => void;
+    /**
+     * Called when typed text is what macOS composes for a bound Option chord
+     * (for example `œ` for a bound `alt+q`), meaning the terminal sent Option as
+     * text. The text is still inserted; the callback only explains the miss.
+     */
+    onUnforwardedOptionChord?: (key: KeyId, text: string) => void;
     /** Called when PageUp/PageDown should scroll the transcript viewport instead of prompt history. */
     onViewportPageScroll?: (direction: -1 | 1) => void;
     /** Called before regular composer input should return the transcript viewport to the live bottom. */

package/dist/types/modes/components/customization/customization-dashboard.d.ts

@@ -24,6 +24,7 @@ import { type CustomizationSurface, type GjcScope } from "../../../customization
 /** Minimal settings slice the dashboard reads and writes. */
 export interface CustomizationSettingsSlice {
     get(key: string): unknown;
+    getGlobal?(key: string): unknown;
     set?(key: string, value: unknown): void;
 }
 export declare class CustomizationDashboard extends Container {

package/dist/types/modes/components/extensions/state-manager.d.ts

@@ -1,3 +1,4 @@
+import type { Settings } from "../../../config/settings";
 import type { DashboardState, Extension, FlatTreeItem, ProviderTab, TreeNode } from "./types";
 /**
  * Settings manager interface for granular toggle persistence.
@@ -9,7 +10,7 @@ export interface ExtensionSettingsManager {
 /**
  * Load all extensions from all capabilities.
  */
-export declare function loadAllExtensions(cwd?: string, disabledIds?: string[]): Promise<Extension[]>;
+export declare function loadAllExtensions(cwd?: string, disabledIds?: string[], settings?: Settings): Promise<Extension[]>;
 /**
  * Build sidebar tree from extensions.
  * Groups by provider → kind.
@@ -39,7 +40,7 @@ export declare function applyDisabledExtensionsToState(state: DashboardState, di
 /**
  * Create initial dashboard state.
  */
-export declare function createInitialState(cwd?: string, disabledIds?: string[]): Promise<DashboardState>;
+export declare function createInitialState(cwd?: string, disabledIds?: string[], settings?: Settings): Promise<DashboardState>;
 /**
  * Toggle provider enabled state.
  */
@@ -47,4 +48,4 @@ export declare function toggleProvider(providerId: string): boolean;
 /**
  * Refresh state after toggle.
  */
-export declare function refreshState(state: DashboardState, cwd?: string, disabledIds?: string[]): Promise<DashboardState>;
+export declare function refreshState(state: DashboardState, cwd?: string, disabledIds?: string[], settings?: Settings): Promise<DashboardState>;

package/dist/types/modes/controllers/input-controller.d.ts

@@ -37,6 +37,15 @@ export declare class InputController {
     toggleQueuePane(): void;
     sendNow(): Promise<void>;
     handleDequeue(): void;
+    /**
+     * Generate the automatic session title from the first user message. Called
+     * from the editor submit and queue-shortcut paths (idle and streaming) and
+     * from interactive startup messages; it is a no-op once the session has a
+     * user message, a name, or a title request already in flight. The result is
+     * bound to the session that requested it: a completion that lands after the
+     * session was replaced (New Session, switch, resume) is discarded.
+     */
+    maybeGenerateSessionTitle(text: string): void;
     /** Send editor text as a follow-up message (queued behind current stream). */
     handleFollowUp(): Promise<void>;
     /** Send editor text explicitly as a queued next-turn message. */

package/dist/types/modes/interactive-mode.d.ts

@@ -307,6 +307,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleCtrlZ(): void;
     handleDequeue(): void;
     handleBackgroundCommand(): void;
+    maybeGenerateSessionTitle(text: string): void;
     handleImagePaste(): Promise<boolean>;
     handleBtwCommand(question: string): Promise<void>;
     hasActiveBtw(): boolean;

package/dist/types/modes/utils/interrupt-ownership.d.ts

@@ -0,0 +1,3 @@
+import type { InteractiveModeContext } from "../types";
+/** Ordinary focused UI owns interrupt/back before background work does. */
+export declare function focusedUiOwnsInterrupt(ctx: Pick<InteractiveModeContext, "ui" | "editor" | "hookSelector" | "hookInput" | "hookEditor">): boolean;

package/dist/types/modes/utils/keybinding-matchers.d.ts

@@ -6,5 +6,6 @@
  * keybindings registered. In that case, fall back to raw Escape matching.
  */
 export declare function matchesAppInterrupt(data: string): boolean;
+export declare function matchesAppClear(data: string): boolean;
 export declare function matchesSelectCancel(data: string): boolean;
 export declare function matchesAppExternalEditor(data: string): boolean;

package/dist/types/modes/utils/macos-option-forwarding.d.ts

@@ -0,0 +1,17 @@
+import type { KeyId } from "@gajae-code/tui";
+/** The Option chord that composes `text` on the macOS US/ABC layout, if any. */
+export declare function macosOptionChordForComposedText(text: string): KeyId | undefined;
+/** Terminal-specific instruction for sending Option as Alt/Meta, when the terminal is known. */
+export declare function macosOptionForwardingInstruction(terminalProgram: string | undefined): string | undefined;
+export interface UnforwardedOptionChordWarnerOptions {
+    platform: NodeJS.Platform;
+    terminalProgram: string | undefined;
+    formatKeyHint: (key: KeyId) => string;
+    showWarning: (message: string) => void;
+}
+/**
+ * Builds the composer callback that explains, once, why a bound Option shortcut
+ * produced a character instead of firing. Returns undefined off macOS, where the
+ * composition table does not apply.
+ */
+export declare function createUnforwardedOptionChordWarner(options: UnforwardedOptionChordWarnerOptions): ((key: KeyId, text: string) => void) | undefined;

package/dist/types/progress/collect-project-progress.d.ts

@@ -0,0 +1,38 @@
+import type { SubagentLifecycle } from "../async/job-manager";
+import type { Goal, GoalModeState } from "../goals/state";
+import type { SessionManager } from "../session/session-manager";
+import { type TodoPhase } from "../tools/todo-write";
+import { type ProjectProgressInput, type ProjectProgressReport } from "./project-progress";
+/** Session-owned state the overview reads; everything else comes from durable `.gjc` files. */
+export interface ProjectProgressSessionView {
+    cwd: string;
+    /** GJC session id that scopes `.gjc/_session-{id}` state; without it no workflow state is read. */
+    sessionId: string | undefined;
+    goal: Goal | undefined;
+    todoPhases: readonly TodoPhase[];
+    subagents: readonly SubagentLifecycle[];
+}
+/**
+ * Gather progress input strictly by reading state. A source that fails to read
+ * is reported as unreadable and excluded; it never aborts the overview and is
+ * never replaced by a guess. A source rebuilt from authoritative per-entry
+ * records after its snapshot failed to read is reported as recovered; one whose
+ * readable derived snapshot listed stale rows is reported as discarded; one whose
+ * rows could not be attributed to an authority is reported as unresolved.
+ */
+export declare function collectProjectProgressInput(view: ProjectProgressSessionView): Promise<ProjectProgressInput>;
+/** The live session state `/progress` and `session.progress` read; satisfied by `AgentSession`. */
+export interface ProjectProgressSessionSource {
+    getGoalModeState(): GoalModeState | undefined;
+    getTodoPhases(): TodoPhase[];
+    getSubagentLifecycleStatuses(): SubagentLifecycle[];
+}
+/**
+ * Single entry point shared by the human view and the machine snapshot.
+ *
+ * Todos come from the persisted branch history, as `/todo` reads them: the live
+ * list drops completed and abandoned items when a session is resumed, so it is
+ * only the fallback when no todo state was ever persisted. A persisted empty
+ * list is authoritative and is not replaced by live state.
+ */
+export declare function buildSessionProjectProgress(session: ProjectProgressSessionSource, sessionManager: Pick<SessionManager, "getCwd" | "getSessionId" | "getBranch">): Promise<ProjectProgressReport>;