@gajae-code/coding-agent 0.8.2 → 0.9.0

package/dist/types/export/ttsr.d.ts

@@ -11,9 +11,16 @@ export interface TtsrMatchContext {
     /** Stable key to isolate buffering (for example a tool call ID). */
     streamKey?: string;
 }
+/** Tracks when a rule was last injected (for repeat gating). */
+export interface TtsrInjectionRecord {
+    name: string;
+    lastInjectedAt: number;
+    repeatMode?: "once" | "after-gap";
+    repeatGap?: number;
+}
 export declare class TtsrManager {
     #private;
-    constructor(settings?: TtsrSettings);
+    constructor(settings?: Partial<TtsrSettings>);
     /** Add a TTSR rule to be monitored. */
     addRule(rule: Rule): boolean;
     /**
@@ -29,8 +36,10 @@ export declare class TtsrManager {
     markInjectedByNames(ruleNames: string[]): void;
     /** Get names of all injected rules (for persistence). */
     getInjectedRuleNames(): string[];
-    /** Restore injected state from a list of rule names. */
-    restoreInjected(ruleNames: string[]): void;
+    /** Get full injected rule records (for persistence). */
+    getInjectedRecords(): TtsrInjectionRecord[];
+    /** Restore injected state from legacy rule names or persisted records. */
+    restoreInjected(records: string[] | TtsrInjectionRecord[]): void;
     /** Reset stream buffers (called on new turn). */
     resetBuffer(): void;
     /** Check if any TTSR rules are registered. */
@@ -39,6 +48,8 @@ export declare class TtsrManager {
     incrementMessageCount(): void;
     /** Get current message count. */
     getMessageCount(): number;
+    /** Restore message counter after session resume. */
+    restoreMessageCount(messageCount: number): void;
     /** Get settings. */
     getSettings(): Required<TtsrSettings>;
 }

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

@@ -92,8 +92,11 @@ export declare function deriveRoundKey(interviewId: string | undefined, input: {
  * legacy flattened fields hoisted in losslessly, transcript duplicates removed
  * from the top level, and `rounds`/`established_facts` guaranteed to be arrays.
  *
- * Idempotent: a canonical envelope is returned unchanged in shape. Never deletes
- * unknown envelope or nested fields, and never mutates the input.
+ * Idempotent: a canonical envelope is returned unchanged in shape. Preserves all
+ * unknown envelope and nested fields except the envelope-reserved keys that leak
+ * into `state` (see `ENVELOPE_RESERVED_STATE_KEYS`), which are stripped so a
+ * malformed envelope-in-state write cannot permanently nest state. Never mutates
+ * the input.
  */
 export declare function normalizeDeepInterviewEnvelope(value: unknown): DeepInterviewStateEnvelope;
 /**

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

@@ -3,6 +3,11 @@ export declare const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_S
 export declare const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
 export declare const GJC_COORDINATOR_SESSION_BRANCH_ENV = "GJC_COORDINATOR_SESSION_BRANCH";
 export type RuntimeState = "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored";
+/** Test-only counters for runtime sidecar hot-path assertions. */
+export declare const __sessionStateSidecarPerfCounters: {
+    persistFromEventCalls: number;
+    reset(): void;
+};
 interface RuntimeStateEvent {
     type: string;
     messages?: unknown[];
@@ -26,6 +31,8 @@ export declare function readTerminalRuntimeStateMarker(input: {
     cwd?: string | null;
     sessionFile?: string | null;
 }): Promise<TerminalRuntimeStateStatus>;
+export declare function stateForEvent(event: RuntimeStateEvent): RuntimeState | null;
+export declare function eventAffectsCoordinatorRuntimeState(event: RuntimeStateEvent): boolean;
 export declare function persistCoordinatorRuntimeStateFromEvent(event: RuntimeStateEvent, context: RuntimeStateContext): Promise<void>;
 export declare function persistCoordinatorRuntimeStateFromPostmortem(reason: postmortem.Reason, context: RuntimeStateContext): void;
 export declare function registerCoordinatorRuntimeStateFinalizer(context: RuntimeStateContext): () => void;

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

@@ -142,6 +142,8 @@ export declare function readExistingStateForMutation(filePath: string): Promise<
 export declare function workflowEnvelopeContentSha256(value: unknown): string;
 export declare function stampWorkflowEnvelopeChecksum<T>(value: T, filePath: string, computedAt?: string): T;
 export declare function detectWorkflowEnvelopeIntegrityMismatch(filePath: string): Promise<WorkflowEnvelopeIntegrityMismatch | undefined>;
+type ActiveStateCacheInvalidator = (cwd?: string, sessionId?: string) => void;
+export declare function setActiveStateCacheInvalidator(invalidator: ActiveStateCacheInvalidator): void;
 export declare function persistedStateRevision(value: unknown): number;
 export declare function writeGuardedJsonAtomic(targetPath: string, value: unknown, options: GuardedStateWriterOptions): Promise<GuardedWriteResult>;
 export declare function writeGuardedWorkflowEnvelopeAtomic(targetPath: string, value: unknown, options: GuardedStateWriterOptions): Promise<GuardedWriteResult>;
@@ -239,3 +241,4 @@ export declare function beginWorkflowTransactionJournal(input: {
 }): Promise<string>;
 export declare function updateWorkflowTransactionJournal(cwd: string, sessionId: string, mutationId: string, patch: Partial<WorkflowTransactionJournal>): Promise<string>;
 export declare function completeWorkflowTransactionJournal(cwd: string, sessionId: string, mutationId: string): Promise<void>;
+export {};

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

@@ -146,6 +146,7 @@ export interface GjcTeamWorkerLifecycle {
 }
 export type GjcTeamNotificationDeliveryState = "pending" | "sent" | "queued" | "deferred" | "failed" | "delivered" | "acknowledged";
 export type GjcTeamPaneAttemptResult = "sent" | "queued" | "deferred" | "failed";
+export type GjcTeamMailboxDeliveryTransportKind = "notifications_sdk" | "pane";
 export interface GjcTeamNotification {
     id: string;
     kind: "mailbox_message" | "worker_lifecycle" | "invalid_attempt";
@@ -164,6 +165,29 @@ export interface GjcTeamNotification {
     updated_at: string;
     replay_count: number;
 }
+export interface GjcTeamMailboxDeliveryInput {
+    team_name: string;
+    state_dir: string;
+    config: GjcTeamConfig;
+    notification: GjcTeamNotification;
+    message: GjcTeamMailboxMessage;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export type GjcTeamMailboxDeliveryResult = {
+    transport: "notifications_sdk";
+    state: GjcTeamNotificationDeliveryState;
+    reason?: string;
+} | {
+    transport: "pane";
+    state: GjcTeamPaneAttemptResult;
+    reason?: string;
+};
+export interface GjcTeamMailboxDeliveryTransport {
+    deliverMailboxMessage(input: GjcTeamMailboxDeliveryInput): Promise<GjcTeamMailboxDeliveryResult | null>;
+}
+export declare function setGjcTeamMailboxDeliveryTransport(transport: GjcTeamMailboxDeliveryTransport | undefined): () => void;
+export declare function setGjcTeamMailboxDeliveryTransportForTest(transport: GjcTeamMailboxDeliveryTransport | undefined): () => void;
 export interface GjcTeamNotificationSummary {
     total: number;
     replay_eligible: number;
@@ -197,6 +221,7 @@ export interface GjcTeamStartOptions {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     dryRun?: boolean;
+    mailboxDeliveryTransport?: GjcTeamMailboxDeliveryTransport;
 }
 export interface GjcTeamApiClaimResult {
     ok: boolean;
@@ -306,6 +331,7 @@ export declare function classifyGjcTeamCheckpointFiles(files: string[]): {
     protected: string[];
 };
 export declare function classifyWorkerCheckpointStatus(cwd: string): GjcWorkerCheckpointClassification;
+export declare function classifyWorkerCheckpointStatusAsync(cwd: string): Promise<GjcWorkerCheckpointClassification>;
 export declare function startGjcTeam(options: GjcTeamStartOptions): Promise<GjcTeamSnapshot>;
 export declare function readGjcTeamSnapshot(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv, options?: GjcTeamSnapshotOptions): Promise<GjcTeamSnapshot>;
 export declare function monitorGjcTeamSnapshot(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamSnapshot>;

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

@@ -0,0 +1,42 @@
+import type { UltragoalCompletionVerification, UltragoalGoal, UltragoalGoalStatus, UltragoalLedgerEvent, UltragoalPlan, UltragoalReceiptKind } from "./ultragoal-runtime";
+export type UltragoalReceiptFreshnessDiagnostic = {
+    state: "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
+    message: string;
+    goalId?: string;
+};
+export declare function requiredUltragoalGoals(plan: UltragoalPlan): UltragoalGoal[];
+export declare function receiptRelevantGoals(plan: UltragoalPlan, goal: UltragoalGoal, receiptKind: UltragoalReceiptKind): UltragoalGoal[];
+export declare function computeUltragoalPlanGeneration(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    goal: UltragoalGoal;
+    receiptKind: UltragoalReceiptKind;
+    beforeStatus: UltragoalGoalStatus;
+    excludeEventId?: string;
+    targetGoalUpdatedAt?: string;
+}): {
+    planGeneration: string;
+    basis: UltragoalCompletionVerification["basis"];
+};
+export declare function findLedgerReceiptEvent(ledger: readonly UltragoalLedgerEvent[], receipt: UltragoalCompletionVerification): UltragoalLedgerEvent | null;
+export declare function validateReceiptFreshBase(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    goal: UltragoalGoal;
+    receipt: UltragoalCompletionVerification;
+    receiptKind: UltragoalReceiptKind;
+}): UltragoalReceiptFreshnessDiagnostic | null;
+export declare function findFreshBatchCloseReceipt(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    deferredGoal: UltragoalGoal;
+    deferredReceipt: UltragoalCompletionVerification;
+}): UltragoalCompletionVerification | null;
+export declare function validateDeferredMemberReceiptFresh(input: {
+    plan: UltragoalPlan;
+    ledger: readonly UltragoalLedgerEvent[];
+    goal: UltragoalGoal;
+    receipt: UltragoalCompletionVerification;
+    receiptKind: UltragoalReceiptKind;
+    requireClose: boolean;
+}): UltragoalReceiptFreshnessDiagnostic;

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

@@ -1,6 +1,77 @@
 import type { WorkflowHudSummary } from "../skill-state/active-state";
+export { computeUltragoalPlanGeneration, receiptRelevantGoals } from "./ultragoal-receipt-freshness";
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus = "pending" | "active" | "complete" | "failed" | "blocked" | "review_blocked" | "superseded";
+export type UltragoalPipelineMetadataSource = "original_plan_graph" | "legacy_brief_only" | "steering";
+export type UltragoalPipelineOverlapState = "none" | "open" | "joined_clean" | "blocked_disjoint_continue" | "quarantine_required" | "rebaseline_complete";
+export interface UltragoalPipelineTargets extends JsonObject {
+    files: string[];
+    surfaces: string[];
+}
+export interface UltragoalPipelineMetadata extends JsonObject {
+    schemaVersion: 1;
+    goalId: string;
+    source: UltragoalPipelineMetadataSource;
+    eligible: boolean;
+    dependsOn: string[];
+    independentOf: string[];
+    targets: UltragoalPipelineTargets;
+    metadataHash: string;
+    overlap: UltragoalPipelineOverlapState;
+    overlapId?: string;
+    priorGoalId?: string;
+    nextGoalId?: string;
+    blockerFootprints?: UltragoalPipelineTargets[];
+    invalidationReason?: string;
+    invalidatedAt?: string;
+}
+export interface UltragoalGoalMetadataInput {
+    schemaVersion: 1;
+    goalId: string;
+    source: UltragoalPipelineMetadataSource;
+    dependsOn?: string[];
+    independentOf?: string[];
+    targets?: Partial<UltragoalPipelineTargets>;
+}
+export interface UltragoalValidationBatchMetadata extends JsonObject {
+    schemaVersion: 1;
+    batchId: string;
+    memberIds: string[];
+    finalGoalId: string;
+    mode: "aggregate-only";
+    metadataHash: string;
+}
+export interface UltragoalValidationBatchInput {
+    schemaVersion: 1;
+    batchId: string;
+    memberIds: string[];
+    finalGoalId: string;
+}
+export interface UltragoalPipelineOverlapHandles extends JsonObject {
+    review: JsonObject;
+    qa: JsonObject;
+    implementation: JsonObject;
+}
+export interface UltragoalPipelineOverlapReceipt extends JsonObject {
+    ok: true;
+    event: string;
+    overlap_id: string;
+    prior_goal_id: string;
+    next_goal_id?: string;
+    goal_id?: string;
+    status?: UltragoalPipelineOverlapState;
+    next_goal_status?: UltragoalGoalStatus;
+    goals_path: string;
+    ledger_path: string;
+}
+export type UltragoalPipelineLedgerEventName = "pipeline_overlap_started" | "pipeline_overlap_joined" | "pipeline_overlap_blocked" | "pipeline_overlap_quarantined" | "pipeline_overlap_rebaselined";
+export interface UltragoalPipelineLedgerEvent extends UltragoalLedgerEvent {
+    event: UltragoalPipelineLedgerEventName;
+    schemaVersion: 1;
+    overlapId: string;
+    priorGoalId: string;
+    nextGoalId: string;
+}
 export interface UltragoalGoal {
     id: string;
     title: string;
@@ -13,6 +84,8 @@ export interface UltragoalGoal {
     evidence?: string;
     steering?: Record<string, unknown>;
     completionVerification?: UltragoalCompletionVerification;
+    pipelineMetadata?: UltragoalPipelineMetadata;
+    validationBatch?: UltragoalValidationBatchMetadata;
 }
 export interface UltragoalPlan {
     version: 1;
@@ -45,6 +118,26 @@ export interface UltragoalCompletionVerification {
         requiredGoalSetHashBeforeCheckpoint: string;
     };
     checkpointLedgerEventId: string;
+    validationBatch?: {
+        schemaVersion: 1;
+        role: "deferred-member";
+        batchId: string;
+        memberIds: string[];
+        finalGoalId: string;
+        metadataHash: string;
+        changeSetHash: string;
+    } | {
+        schemaVersion: 1;
+        role: "batch-close";
+        batchId: string;
+        memberIds: string[];
+        finalGoalId: string;
+        memberMetadataHashes: Record<string, string>;
+        memberReceiptIds: Record<string, string>;
+        memberCheckpointLedgerEventIds: Record<string, string>;
+        memberChangeSetHashes: Record<string, string>;
+        unionHash: string;
+    };
 }
 export interface UltragoalLedgerEvent extends JsonObject {
     eventId?: string;
@@ -106,6 +199,7 @@ export interface UltragoalStatusSummary {
     nudgeRemaining?: number;
     nudgeGoalId?: string;
     nudgeTargetKind?: UltragoalNudgeTargetKind;
+    pipelineOverlap?: JsonObject;
 }
 export interface UltragoalCommandResult {
     reviewBlockerGoalIds?: string[];
@@ -161,18 +255,6 @@ export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
     reason: string;
     currentGoalObjective?: string;
 }): Promise<UltragoalNudgeOutcome>;
-export declare function computeUltragoalPlanGeneration(input: {
-    plan: UltragoalPlan;
-    ledger: readonly UltragoalLedgerEvent[];
-    goal: UltragoalGoal;
-    receiptKind: UltragoalReceiptKind;
-    beforeStatus: UltragoalGoalStatus;
-    excludeEventId?: string;
-    targetGoalUpdatedAt?: string;
-}): {
-    planGeneration: string;
-    basis: UltragoalCompletionVerification["basis"];
-};
 export declare function readUltragoalPlan(cwd: string, sessionId?: string | null): Promise<UltragoalPlan | null>;
 export declare function getUltragoalStatus(cwd: string, sessionId?: string | null): Promise<UltragoalStatusSummary>;
 export declare function buildUltragoalHudSummary(summary: UltragoalStatusSummary, latestLedger?: UltragoalLedgerEvent): WorkflowHudSummary;
@@ -181,6 +263,10 @@ export declare function createUltragoalPlan(input: {
     brief: string;
     gjcGoalMode?: UltragoalGjcGoalMode;
     sessionId?: string | null;
+    goalMetadata?: UltragoalGoalMetadataInput[];
+    goalMetadataJson?: string;
+    validationBatches?: UltragoalValidationBatchInput[];
+    validationBatchJson?: string;
 }): Promise<UltragoalPlan>;
 export interface UltragoalRunCompletionState {
     requiredGoals: UltragoalGoal[];
@@ -190,6 +276,27 @@ export interface UltragoalRunCompletionState {
     hasBlockers: boolean;
     needsFinalAggregateReceipt: boolean;
 }
+export declare function startUltragoalPipelineOverlap(input: {
+    cwd: string;
+    priorGoalId: string;
+    nextGoalId: string;
+    reviewHandles: JsonObject | JsonObject[];
+    qaHandles: JsonObject | JsonObject[];
+    implementationHandle: JsonObject;
+}): Promise<UltragoalPipelineOverlapReceipt>;
+export declare function joinUltragoalPipelineOverlap(input: {
+    cwd: string;
+    overlapId: string;
+    reviewResult: JsonObject;
+    qaResult: JsonObject;
+}): Promise<UltragoalPipelineOverlapReceipt>;
+export declare function rebaselineUltragoalPipelineOverlap(input: {
+    cwd: string;
+    overlapId: string;
+    goalId: string;
+    evidence: string;
+    targetState: JsonObject;
+}): Promise<UltragoalPipelineOverlapReceipt>;
 export declare function getUltragoalRunCompletionState(plan: UltragoalPlan, options?: {
     retryFailed?: boolean;
 }): UltragoalRunCompletionState;
@@ -301,4 +408,3 @@ interface UltragoalReviewResult extends JsonObject {
 export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
 export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string): Promise<UltragoalCommandResult>;
-export {};

package/dist/types/goals/runtime.d.ts

@@ -35,6 +35,7 @@ export declare class GoalRuntime {
     #private;
     constructor(host: GoalRuntimeHost);
     get snapshot(): GoalRuntimeSnapshot;
+    shouldTrackTurnBaseline(): boolean;
     onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void;
     onToolCompleted(toolName: string): Promise<void>;
     onGoalToolCompleted(): Promise<void>;

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

@@ -11,6 +11,18 @@ interface GjcNativeHookDispatchOptions {
     effectiveSkillConfig?: EffectiveSkillConfigInput;
     configPaths?: string[];
 }
+export declare function clearGjcNativeSkillHookCachesForTesting(): void;
+export declare function getGjcNativeSkillHookCacheStatsForTesting(): {
+    effectiveSkillConfigResolutions: number;
+};
+export declare function resolveGjcNativeSkillConfigForTesting(input: {
+    cwd: string;
+    configPaths?: string[];
+    sessionId?: string;
+    threadId?: string;
+    stateDir?: string;
+}): Promise<EffectiveSkillConfigInput>;
 export declare function dispatchGjcNativeSkillHook(payload: HookPayload, options?: GjcNativeHookDispatchOptions): Promise<GjcNativeHookDispatchResult>;
+export declare function runGjcNativeSkillHookInProcess(payload: HookPayload): Promise<string>;
 export declare function runGjcNativeSkillHookCli(): Promise<void>;
 export {};

package/dist/types/modes/components/assistant-message.d.ts

@@ -1,5 +1,8 @@
 import type { AssistantMessage, ImageContent, Usage } from "@gajae-code/ai";
 import { Container } from "@gajae-code/tui";
+interface AssistantMessageUpdateOptions {
+    streaming?: boolean;
+}
 /**
  * Component that renders a complete assistant message
  */
@@ -12,5 +15,6 @@ export declare class AssistantMessageComponent extends Container {
     setHideThinkingBlock(hide: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     setUsageInfo(usage: Usage): void;
-    updateContent(message: AssistantMessage): void;
+    updateContent(message: AssistantMessage, options?: AssistantMessageUpdateOptions): void;
 }
+export {};

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

@@ -90,5 +90,14 @@ export declare class StatusLineComponent implements Component {
      * everything fits on one row.
      */
     getPreviewContent(width: number): string;
+    getCacheStatsForTest(): {
+        rowHits: number;
+        rowMisses: number;
+    };
+    invalidateBranchForTest(): void;
+    setCachedPrForTest(pr: {
+        number: number;
+        url: string;
+    } | null): void;
     render(width: number): string[];
 }

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

@@ -23,6 +23,7 @@ export declare class CommandController {
     handleContextCommand(): void;
     handleMemoryCommand(text: string): Promise<void>;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;

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

@@ -1,5 +1,10 @@
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __eventControllerPerfCounters: {
+    messageUpdateContentVisits: number;
+    reset(): void;
+};
 export declare class EventController {
     #private;
     private ctx;

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

@@ -27,6 +27,7 @@ import { type WelcomeLogoMode } from "./components/welcome";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
 import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
 export declare function resolveWelcomeLogoMode(mode: WelcomeBannerSettingMode, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): WelcomeLogoMode;
 /** Options for creating an InteractiveMode instance (for future API use) */
@@ -189,6 +190,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleToolsCommand(): void;
     handleContextCommand(): void;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;

package/dist/types/modes/rpc/rpc-types.d.ts

@@ -12,6 +12,7 @@ import type { ContextUsage } from "../../extensibility/extensions/types";
 import type { SessionStats } from "../../session/agent-session";
 import type { TodoPhase } from "../../tools/todo-write";
 export type RpcGetStateInclude = "tools" | "dumpTools" | "systemPrompt";
+export type RpcCapability = "compact_message_update";
 export type RpcCommand = {
     id?: string;
     type: "prompt";
@@ -59,6 +60,10 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "get_pending_workflow_gates";
+} | {
+    id?: string;
+    type: "set_capabilities";
+    capabilities: RpcCapability[];
 } | {
     id?: string;
     type: "set_model";
@@ -258,6 +263,15 @@ export type RpcResponse = {
     data: {
         gates: RpcWorkflowGate[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_capabilities";
+    success: true;
+    data: {
+        acceptedCapabilities: RpcCapability[];
+        unsupported: string[];
+    };
 } | {
     id?: string;
     type: "response";

package/dist/types/modes/shared/agent-wire/event-contract.d.ts

@@ -13,6 +13,7 @@
  * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
  * conformance tests can assert fixture coverage equals the registry exactly.
  */
+import type { AssistantMessageEvent } from "@gajae-code/ai";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 /** Wire protocol version. Bump on breaking envelope/semantic changes. */
 export declare const AGENT_WIRE_PROTOCOL_VERSION: 2;
@@ -29,6 +30,23 @@ export interface AgentWireEventPayload {
     event_type: AgentWireEventType;
     event: AgentSessionEvent;
 }
+export type AgentWireCompactAssistantMessageEvent = AssistantMessageEvent extends infer TEvent ? TEvent extends {
+    type: string;
+} ? Omit<TEvent, "partial" | "message" | "error"> : never : never;
+export interface AgentWireCompactMessageUpdatePayload {
+    event_type: "message_update";
+    /** Compact RPC opt-in payload: delta-only update plus minimal routing metadata. */
+    compact: true;
+    message_id: string | null;
+    content_index: number | null;
+    assistantMessageEvent: AgentWireCompactAssistantMessageEvent;
+    /** Full message checkpoint, snapshotted synchronously when this frame is enqueued. */
+    checkpoint_message?: Extract<AgentSessionEvent, {
+        type: "message_update";
+    }>["message"];
+    checkpoint_reason?: "periodic";
+}
+export type AgentWireEventFramePayload = AgentWireEventPayload | AgentWireCompactMessageUpdatePayload;
 /**
  * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
  * the Harness `ObservedSignal` set; the Harness type aliases this in a later
@@ -82,3 +100,4 @@ export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = Agent
 }
 /** An `AgentSessionEvent` serialized into a versioned wire frame. */
 export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;
+export type AgentWireCompactEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventFramePayload>;

package/dist/types/modes/shared/agent-wire/event-envelope.d.ts

@@ -1,5 +1,6 @@
 import type { AgentSessionEvent } from "../../../session/agent-session";
-import { type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
+import { type AgentWireCompactAssistantMessageEvent, type AgentWireCompactEventFrame, type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
+export declare const AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL = 32;
 /**
  * Resolve the stable wire event-type for an `AgentSessionEvent`.
  *
@@ -27,6 +28,27 @@ export type BridgeFrameSequencer = AgentWireFrameSequencer;
 export declare function toAgentWireEventFrame(event: AgentSessionEvent, sequencer: AgentWireFrameSequencer): AgentWireEventFrame;
 /** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
 export declare function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload;
+export declare function sanitizeAssistantMessageEventForCompact(assistantMessageEvent: Extract<AgentSessionEvent, {
+    type: "message_update";
+}>["assistantMessageEvent"]): AgentWireCompactAssistantMessageEvent;
+export interface AgentWireCompactMessageUpdateOptions {
+    checkpointInterval?: number;
+}
+/**
+ * Stateful compact event serializer for opt-in RPC clients.
+ *
+ * Only `message_update` changes shape: it carries the immutable provider delta
+ * plus message/content identifiers, with periodic full-message checkpoints that
+ * are cloned synchronously before the caller returns to the event loop. All other
+ * event variants remain canonical full event frames so legacy bridge/RPC behavior
+ * and terminal `message_end` reconstruction are unchanged.
+ */
+export declare class AgentWireCompactEventEncoder {
+    #private;
+    constructor(sequencer: AgentWireFrameSequencer, options?: AgentWireCompactMessageUpdateOptions);
+    frame(event: AgentSessionEvent): AgentWireCompactEventFrame;
+}
+export declare function toAgentWireCompactEventFrame(event: AgentSessionEvent, encoder: AgentWireCompactEventEncoder): AgentWireCompactEventFrame;
 /** Back-compat alias for {@link toAgentWireEventFrame}. */
 export declare const toBridgeEventFrame: typeof toAgentWireEventFrame;
 /**

package/dist/types/modes/types.d.ts

@@ -198,6 +198,7 @@ export interface InteractiveModeContext {
     handleDumpCommand(): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -6,6 +6,7 @@ import type { SessionContext } from "../../session/session-manager";
 interface RenderInitialMessagesOptions {
     preserveExistingChat?: boolean;
 }
+export declare function argsWithPartialJson(args: unknown, partialJson: unknown): unknown;
 export declare class UiHelpers {
     #private;
     private ctx;

package/dist/types/notifications/config.d.ts

@@ -17,6 +17,12 @@ export interface NotificationConfig {
 }
 /** Read typed config from Settings. */
 export declare function getNotificationConfig(settings: Settings): NotificationConfig;
+export declare function hasNonBlankValue(value: string | undefined): boolean;
+/** Is Telegram configured with usable non-blank boundary credentials? */
+export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+    botToken: string;
+    chatId: string;
+};
 /** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
 export declare function isGloballyConfigured(cfg: NotificationConfig): boolean;
 /** Resolve whether the notifications extension should be registered at SDK startup. */

package/dist/types/notifications/telegram-daemon.d.ts

@@ -254,6 +254,8 @@ export declare class TelegramNotificationDaemon {
     private readonly opts;
     readonly aliasTable: AliasTable;
     readonly messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
+    /** Telegram message id backing each streamed `${sessionId}:${coalesceKey}`, for in-place edits. */
+    private readonly liveMessages;
     readonly sessions: Map<string, SessionSocket>;
     private readonly runtime;
     private readonly sessionRouter;
@@ -375,6 +377,12 @@ export declare class TelegramNotificationDaemon {
     private cleanupAllAttachmentDirs;
     private resolveInboundAttachment;
     private flushPool;
+    /**
+     * Track the Telegram message id backing a streamed `(sessionId, coalesceKey)`
+     * so later live/finalized frames edit it in place. Evicts this session's stale
+     * same-category entries (e.g. prior turns) so the map stays bounded.
+     */
+    private recordLiveMessage;
     private deliverFlatFallback;
     private pairedChatIsPrivate;
     private notifyThreadedFallback;

package/dist/types/notifications/threaded-render.d.ts

@@ -28,6 +28,12 @@ export interface ThreadedSend {
     coalesceKey?: string;
     /** True for the one-time identity header (the daemon pins it once). */
     identity?: boolean;
+    /**
+     * When true the daemon may deliver this as an in-place edit of the message
+     * previously sent under the same `(sessionId, coalesceKey)` instead of a new
+     * message. Set for streamed turn frames so live + finalized share one message.
+     */
+    editable?: boolean;
 }
 interface ThreadedFrame {
     type?: unknown;