@gajae-code/coding-agent 0.11.11 → 0.12.1

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

@@ -186,6 +186,7 @@ export interface WorkerHeartbeatFile {
     last_turn_at: string;
     turn_count: number;
     alive: boolean;
+    process_start_time?: string;
 }
 export interface GjcWorkerIntegrationAttemptRequestResult {
     requested: boolean;
@@ -199,7 +200,14 @@ export interface GjcWorkerIntegrationAttemptRequestResult {
 export interface GjcWorkerIntegrationAttemptOptions {
     signal?: AbortSignal;
 }
-export declare const GJC_TEAM_API_OPERATIONS: readonly ["send-message", "broadcast", "mailbox-list", "mailbox-mark-delivered", "mailbox-mark-notified", "notification-list", "notification-read", "notification-replay", "notification-mark-pane-attempt", "worker-startup-ack", "create-task", "read-task", "list-tasks", "update-task", "claim-task", "transition-task-status", "transition-task", "release-task-claim", "read-config", "read-manifest", "read-worker-status", "update-worker-status", "read-worker-heartbeat", "recover-stale-claims", "update-worker-heartbeat", "write-worker-inbox", "write-worker-identity", "append-event", "read-events", "read-traces", "await-event", "write-shutdown-request", "read-shutdown-ack", "read-monitor-snapshot", "write-monitor-snapshot", "read-task-approval", "write-task-approval"];
+export declare const GJC_TEAM_API_OPERATIONS: readonly ["send-message", "broadcast", "mailbox-list", "mailbox-mark-delivered", "mailbox-mark-notified", "notification-list", "notification-read", "notification-replay", "notification-mark-pane-attempt", "worker-startup-ack", "create-task", "read-task", "list-tasks", "update-task", "claim-task", "transition-task-status", "transition-task", "release-task-claim", "read-config", "read-manifest", "read-worker-status", "update-worker-status", "read-worker-heartbeat", "recover-stale-claims", "update-worker-heartbeat", "read-worker-memory-guard", "update-worker-memory-guard", "apply-worker-memory-guard", "write-worker-inbox", "write-worker-identity", "append-event", "read-events", "read-traces", "await-event", "write-shutdown-request", "read-shutdown-ack", "read-monitor-snapshot", "write-monitor-snapshot", "read-task-approval", "write-task-approval"];
+export type GjcTeamApiOperation = (typeof GJC_TEAM_API_OPERATIONS)[number];
+export declare class UnknownGjcTeamApiOperationError extends Error {
+    readonly code = "unknown_team_api_operation";
+    readonly operation: string;
+    readonly suggestions: readonly string[];
+    constructor(operation: string, suggestions: readonly string[]);
+}
 export interface GjcTeamRuntimeTestSeams {
     nowMs?: () => number;
     continuationTmuxDispatch?: (command: string, args: readonly string[]) => {
@@ -224,6 +232,16 @@ export declare function resolveWorkerWorktreePath(input: {
     platform: NodeJS.Platform;
     isPsmux: boolean;
 }): string;
+/**
+ * Check whether the current process can launch a team without changing tmux state.
+ * Unlike the launch path, this never adopts or tags an unmanaged tmux session.
+ */
+export declare function probeGjcTeamAvailability(env?: NodeJS.ProcessEnv): {
+    available: true;
+} | {
+    available: false;
+    reason: string;
+};
 export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, argv?: string[], execPath?: string): string;
 export { buildWorkerCommand } from "./team-launch";
 export type GjcWorkerCheckpointClassification = {
@@ -256,6 +274,8 @@ export declare function requestGjcWorkerIntegrationAttempt(cwd?: string, env?: N
 export declare function buildTeamHudSummary(snapshot: GjcTeamSnapshot, latestEvent?: GjcTeamEvent, latestMessage?: GjcTeamMailboxMessage): Promise<WorkflowHudSummary>;
 export declare function monitorGjcTeam(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamSnapshot>;
 export declare function listGjcTeams(cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamSnapshot[]>;
+/** Positive stale windows are clamped so a worker can publish strictly before expiry. */
+export declare function parseHeartbeatStaleMs(env: NodeJS.ProcessEnv): number;
 export declare function shutdownGjcTeam(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamSnapshot>;
 export declare function listGjcTeamTasks(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamTask[]>;
 export declare function readGjcTeamTask(teamName: string, taskId: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamTask>;
@@ -277,6 +297,12 @@ export declare const readGjcWorkerStatus: (teamName: string, worker: string, cwd
 export declare function updateGjcWorkerStatus(teamName: string, worker: string, status: GjcWorkerStatusState, cwd?: string, env?: NodeJS.ProcessEnv, currentTaskId?: string, reason?: string): Promise<WorkerStatusFile>;
 export declare const readGjcWorkerHeartbeat: (teamName: string, worker: string, cwd?: string, env?: NodeJS.ProcessEnv) => Promise<WorkerHeartbeatFile | null>;
 export declare function updateGjcWorkerHeartbeat(teamName: string, worker: string, heartbeat: WorkerHeartbeatFile, cwd?: string, env?: NodeJS.ProcessEnv): Promise<WorkerHeartbeatFile>;
+/**
+ * Refresh liveness without discarding metadata written by other heartbeat
+ * producers. The read/merge/write sequence shares the team mutation fence with
+ * CLI heartbeat updates, so a runtime tick cannot overwrite a newer turn count.
+ */
+export declare function refreshGjcWorkerHeartbeat(teamName: string, worker: string, pid: number, cwd?: string, env?: NodeJS.ProcessEnv): Promise<WorkerHeartbeatFile>;
 export declare function writeGjcWorkerInbox(teamName: string, worker: string, content: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<{
     path: string;
 }>;

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

@@ -107,6 +107,18 @@ export interface GjcTeamApiClaimResult {
     claim_token?: string;
     reason?: string;
 }
+export type GjcTeamWorkerClaimSelection = {
+    kind: "none";
+} | {
+    kind: "exact";
+    task: GjcTeamTask;
+    claim: GjcTeamTaskClaim;
+} | {
+    kind: "ambiguous";
+    tasks: GjcTeamTask[];
+};
+export declare function selectCurrentClaimedTaskForWorker(tasks: readonly GjcTeamTask[], workerId: string): GjcTeamWorkerClaimSelection;
+export declare function findGjcTeamClaimedTaskForWorker(tasks: readonly GjcTeamTask[], workerId: string): GjcTeamTask | undefined;
 type EventAppender = (event: {
     type: string;
     task_id?: string;

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

@@ -0,0 +1,43 @@
+import { type WorkerHeartbeatFile } from "./team-runtime";
+export interface GjcTeamWorkerIdentity {
+    teamName: string;
+    workerId: string;
+}
+/** Resolves the team identity injected into a worker pane by `gjc team` startup. */
+export declare function resolveGjcTeamWorkerIdentity(env?: NodeJS.ProcessEnv): GjcTeamWorkerIdentity | undefined;
+/** Refresh cadence derived from the leader's stale window; `0` disables publishing. */
+export declare function resolveGjcTeamWorkerHeartbeatIntervalMs(env?: NodeJS.ProcessEnv): number;
+/**
+ * Publish one runtime-owned heartbeat for the worker this process is running as.
+ * Returns `undefined` when the process is not a team worker.
+ *
+ * `turn_count` and process-incarnation metadata are merged under the same
+ * mutation fence used by CLI heartbeat updates.
+ */
+export declare function writeGjcTeamWorkerRuntimeHeartbeat(cwd?: string, env?: NodeJS.ProcessEnv): Promise<WorkerHeartbeatFile | undefined>;
+export interface GjcTeamWorkerHeartbeatReporterOptions {
+    write: () => Promise<void>;
+    intervalMs: number;
+}
+/**
+ * Publishes a worker heartbeat while a turn is in flight.
+ *
+ * Writes never overlap; a slow or failing write is logged and skipped rather
+ * than queued, because only the most recent record matters. The timer is
+ * unreferenced so it can never hold the process open.
+ */
+export declare class GjcTeamWorkerHeartbeatReporter {
+    #private;
+    constructor(options: GjcTeamWorkerHeartbeatReporterOptions);
+    /** Reporter for the current process, or `undefined` when it is not a team worker. */
+    static forProcess(cwd: () => string, env?: NodeJS.ProcessEnv): GjcTeamWorkerHeartbeatReporter | undefined;
+    get isRunning(): boolean;
+    /** Publish immediately, then keep publishing until {@link stop} or {@link dispose}. */
+    start(): void;
+    /** Stop periodic publishing after one final record, so the idle stamp is fresh. */
+    stop(): void;
+    /** Await the write in flight, if any. */
+    flush(): Promise<void>;
+    /** Permanently stop publishing. Idempotent. */
+    dispose(): void;
+}

package/dist/types/gjc-runtime/team-worker-memory-guard.d.ts

@@ -0,0 +1,92 @@
+import { type StateWriterOptions } from "./state-writer";
+export type GjcTeamWorkerMemoryGuardState = "idle" | "advisory" | "retrying" | "checkpointed" | "replaced" | "blocked";
+export type GjcTeamWorkerMemoryGuardCheckpointKind = "clean" | "eligible" | "protected_only" | "conflicted" | "git_error";
+export type GjcTeamWorkerMemoryGuardPidProbe = {
+    kind: "live";
+    start_time: string;
+} | {
+    kind: "absent";
+} | {
+    kind: "unverifiable";
+    reason: string;
+};
+export interface GjcTeamWorkerMemoryGuardCheckpoint {
+    kind: GjcTeamWorkerMemoryGuardCheckpointKind;
+    files: string[];
+    head?: string | null;
+    commit?: string | null;
+    recorded_at: string;
+}
+export interface GjcTeamWorkerMemoryGuardReplacement {
+    old_pane_id?: string;
+    new_pane_id?: string;
+    recorded_at: string;
+}
+export interface GjcTeamWorkerMemoryGuardLedger {
+    schema_version: 1;
+    worker_id: string;
+    platform: string;
+    state: GjcTeamWorkerMemoryGuardState;
+    automatic_action_allowed: boolean;
+    retry_count: number;
+    retry_limit: number;
+    current_task_id?: string;
+    last_incident_id?: string;
+    last_reason?: string;
+    last_pid_probe?: GjcTeamWorkerMemoryGuardPidProbe;
+    last_checkpoint?: GjcTeamWorkerMemoryGuardCheckpoint;
+    last_replacement?: GjcTeamWorkerMemoryGuardReplacement;
+    updated_at: string;
+}
+export interface GjcTeamWorkerMemoryGuardSelectionCandidate {
+    worker_id: string;
+    platform: string;
+    excess_bytes: number;
+    retry_count: number;
+    retry_limit: number;
+    blocked?: boolean;
+    current_task_id?: string;
+}
+export interface GjcTeamWorkerMemoryGuardSelection {
+    worker_id: string;
+    excess_bytes: number;
+    retry_count: number;
+    current_task_id?: string;
+}
+export declare function workerMemoryGuardLedgerPath(dir: string, workerId: string): string;
+export declare function normalizeGjcTeamWorkerMemoryGuardPidProbe(value: unknown): GjcTeamWorkerMemoryGuardPidProbe | undefined;
+export declare function isCanonicalGjcTeamWorkerMemoryGuardCheckpoint(value: unknown): value is GjcTeamWorkerMemoryGuardCheckpoint;
+export declare function isCanonicalGjcTeamWorkerMemoryGuardReplacement(value: unknown): value is GjcTeamWorkerMemoryGuardReplacement;
+export declare function isCanonicalGjcTeamWorkerMemoryGuardPidProbe(value: unknown): value is GjcTeamWorkerMemoryGuardPidProbe;
+export declare function isCanonicalGjcTeamWorkerMemoryGuardLedger(value: unknown): value is GjcTeamWorkerMemoryGuardLedger;
+export declare function createInitialGjcTeamWorkerMemoryGuardLedger(input: {
+    workerId: string;
+    platform: string;
+    now: string;
+    retryLimit?: number;
+}): GjcTeamWorkerMemoryGuardLedger;
+export declare function selectGjcTeamWorkerMemoryGuardCandidate(candidates: readonly GjcTeamWorkerMemoryGuardSelectionCandidate[]): GjcTeamWorkerMemoryGuardSelection | undefined;
+export type TeamWorkerMemoryGuardAction = "advisory" | "replace" | "blocked";
+export type TeamWorkerMemoryGuardResult = "noop" | "scheduled" | "succeeded" | "failed" | "blocked";
+export interface TeamWorkerMemoryGuardLedgerEntry {
+    schema_version: 1;
+    recorded_at: string;
+    incident_id: string;
+    team_name: string;
+    worker_id: string;
+    task_id: string;
+    claim_token: string;
+    attempt: number;
+    platform: NodeJS.Platform;
+    action: TeamWorkerMemoryGuardAction;
+    result: TeamWorkerMemoryGuardResult;
+    reason: string;
+}
+export declare function isCanonicalTeamWorkerMemoryGuardLedgerEntry(value: unknown): value is TeamWorkerMemoryGuardLedgerEntry;
+export declare function teamWorkerMemoryGuardDir(workerDirPath: string): string;
+export declare function teamWorkerMemoryGuardLedgerPath(workerDirPath: string): string;
+export declare function canMutateTeamWorkerMemoryGuard(platform: NodeJS.Platform): boolean;
+export declare function advisoryReasonForTeamWorkerMemoryGuard(platform: NodeJS.Platform): string | undefined;
+export declare function appendTeamWorkerMemoryGuardLedgerEntry(workerDirPath: string, entry: TeamWorkerMemoryGuardLedgerEntry, options?: StateWriterOptions): Promise<string>;
+export declare function readTeamWorkerMemoryGuardLedger(workerDirPath: string): Promise<TeamWorkerMemoryGuardLedgerEntry[]>;
+export declare function nextTeamWorkerMemoryGuardAttempt(entries: readonly TeamWorkerMemoryGuardLedgerEntry[], incidentId: string): number;

package/dist/types/gjc-runtime/tmux-owner-isolation.d.ts

@@ -31,6 +31,16 @@ export interface TmuxServerProof {
     startTime?: string;
     cgroup?: CgroupInfo;
     sessionNames?: string[];
+    /**
+     * Whether `pid` is kernel-proved evidence about the live tmux server.
+     *
+     * Only Linux can prove a server PID (`/proc` + cgroup classification), so
+     * probes on other platforms may report a placeholder PID with this flag set
+     * to `false`. Guards must not build a `#{pid}` predicate from an unproven
+     * PID: no live tmux server can ever satisfy it. Omitted means proven, which
+     * keeps every probe that reads a real `#{pid}` unchanged.
+     */
+    pidProven?: boolean;
 }
 export interface PlanRequest {
     schema_version: 1;
@@ -267,6 +277,13 @@ export interface LifecyclePaths {
     journalFile: string;
 }
 export declare function lifecyclePaths(stateDir: string, sessionId: string, generation: string): LifecyclePaths;
+export interface MemoryGuardClaimPaths {
+    root: string;
+    databaseFile: string;
+    walFile: string;
+    shmFile: string;
+}
+export declare function memoryGuardClaimPaths(stateDir: string, sessionId: string): MemoryGuardClaimPaths;
 export declare function replaceOwnerGeneration(stateDir: string, sessionId: string, generation?: string, expectedBaseline?: OwnerGenerationBaseline): Promise<string>;
 export type OwnerGenerationBaseline = {
     state: "absent";

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

@@ -39,6 +39,14 @@ export declare function computeUltragoalPlanGeneration(input: {
     basis: UltragoalCompletionVerification["basis"];
 };
 export declare function findLedgerReceiptEvent(ledger: readonly UltragoalLedgerEvent[], receipt: UltragoalCompletionVerification): UltragoalLedgerEvent | null;
+/**
+ * A final-aggregate receipt whose recorded ledger checkpoint quality gate is
+ * missing a clean `criticReview` OKAY can never satisfy the completion guard,
+ * yet is not "stale" under {@link validateReceiptFreshBase}. Detect it so an
+ * identical-evidence complete replay can re-verify and re-mint with a
+ * corrected gate instead of no-opping into a permanently blocked run.
+ */
+export declare function finalAggregateReceiptMissingCriticOkay(ledger: readonly UltragoalLedgerEvent[], receipt: UltragoalCompletionVerification): boolean;
 export declare function validateReceiptFreshBase(input: {
     plan: UltragoalPlan;
     ledger: readonly UltragoalLedgerEvent[];

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

@@ -5,37 +5,6 @@ export { CRITIC_GATE_HARD_STOP_EVENT, CRITIC_GATE_OVERRIDE_EVENT, CRITIC_VERDICT
 export { captureUltragoalRecoverySnapshot, parseStrictTerminalTranscript, persistUltragoalRecoveryDecision, planUltragoalOwnerLossRecovery, type UltragoalOwnerLossReceipt, type UltragoalRecoveryBinding, type UltragoalRecoveryDecision, type UltragoalRecoverySnapshot, validateOwnerLossBinding, validateRawUltragoalEvidence, validateRecoveryAdmission, validateRecoveryPath, } from "./ultragoal-owner-loss-recovery";
 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;
@@ -50,31 +19,6 @@ export interface UltragoalValidationBatchInput {
     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;
@@ -87,7 +31,6 @@ export interface UltragoalGoal {
     evidence?: string;
     steering?: Record<string, unknown>;
     completionVerification?: UltragoalCompletionVerification;
-    pipelineMetadata?: UltragoalPipelineMetadata;
     validationBatch?: UltragoalValidationBatchMetadata;
 }
 export interface UltragoalPlan {
@@ -204,7 +147,6 @@ export interface UltragoalStatusSummary {
     nudgeRemaining?: number;
     nudgeGoalId?: string;
     nudgeTargetKind?: UltragoalNudgeTargetKind;
-    pipelineOverlap?: JsonObject;
 }
 export interface UltragoalCommandResult {
     reviewBlockerGoalIds?: string[];
@@ -267,22 +209,6 @@ export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
 export declare function writePlan(cwd: string, plan: UltragoalPlan, sessionId?: string | null): Promise<void>;
 export declare function nonEmptyString(value: unknown): string | null;
 export declare function stringArray(value: unknown): string[] | null;
-export declare function hashPipelineMetadata(metadata: Omit<UltragoalPipelineMetadata, "metadataHash">): string;
-export declare function validateValidationBatchPipelineExclusion(goal: UltragoalGoal): void;
-export declare function targetsAreDisjoint(left: UltragoalPipelineTargets, right: UltragoalPipelineTargets): boolean;
-export declare function targetsOverlap(left: UltragoalPipelineTargets, right: UltragoalPipelineTargets): boolean;
-export declare function requireNonEmptyPipelineTargets(value: unknown, fieldName: string): UltragoalPipelineTargets;
-export declare function collectPipelineBlockerFootprints(result: JsonObject, fieldName: string): UltragoalPipelineTargets[];
-export declare function pipelinePeer(plan: UltragoalPlan, metadata: UltragoalPipelineMetadata): UltragoalGoal | undefined;
-export declare function handleIdsFromValue(value: JsonObject | JsonObject[], fieldName: string): string[];
-export declare function resultHandleIds(value: JsonObject, fieldName: string): string[];
-export declare function requireCoveredHandles(expected: readonly string[], actual: readonly string[], fieldName: string): void;
-export declare function requireFreshPipelineMetadata(goal: UltragoalGoal): UltragoalPipelineMetadata;
-export declare function openPipelineOverlap(plan: UltragoalPlan): {
-    prior: UltragoalGoal;
-    next: UltragoalGoal;
-    overlapId: string;
-} | null;
 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;
@@ -291,8 +217,6 @@ export declare function createUltragoalPlan(input: {
     brief: string;
     gjcGoalMode?: UltragoalGjcGoalMode;
     sessionId?: string | null;
-    goalMetadata?: UltragoalGoalMetadataInput[];
-    goalMetadataJson?: string;
     validationBatches?: UltragoalValidationBatchInput[];
     validationBatchJson?: string;
 }): Promise<UltragoalPlan>;
@@ -304,10 +228,6 @@ export interface UltragoalRunCompletionState {
     hasBlockers: boolean;
     needsFinalAggregateReceipt: boolean;
 }
-export declare function requireJsonObjectValue(value: unknown, fieldName: string): JsonObject;
-export declare function requireJsonObjectOrArrayValue(value: unknown, fieldName: string): JsonObject | JsonObject[];
-import { joinUltragoalPipelineOverlap, rebaselineUltragoalPipelineOverlap, startUltragoalPipelineOverlap } from "./ultragoal-pipeline";
-export { joinUltragoalPipelineOverlap, rebaselineUltragoalPipelineOverlap, startUltragoalPipelineOverlap };
 export declare function getUltragoalRunCompletionState(plan: UltragoalPlan, options?: {
     retryFailed?: boolean;
 }): UltragoalRunCompletionState;
@@ -343,6 +263,22 @@ export declare function startNextUltragoalGoal(input: {
 }>;
 export declare function qualityGateObject(value: unknown): JsonObject | null;
 export declare function nonEmptyStringArray(value: unknown): string[] | null;
+export interface UltragoalQualityGateDiagnostic {
+    path: string;
+    code: string;
+    message: string;
+}
+/**
+ * Collects every quality-gate defect in one pass instead of throwing on the first.
+ * Authoring a valid gate is otherwise an edit/retry loop at the most expensive phase
+ * of a run (#3474). The aggregate error message keeps each individual message verbatim
+ * so existing callers and assertions that match on a single message still work, and
+ * `diagnostics` carries the machine-readable stable `path` + `code` pairs.
+ */
+export declare class UltragoalQualityGateError extends Error {
+    readonly diagnostics: readonly UltragoalQualityGateDiagnostic[];
+    constructor(diagnostics: readonly UltragoalQualityGateDiagnostic[]);
+}
 export declare function requireQualityGateObject(value: unknown, fieldName: string): JsonObject;
 export declare function requireObjectArray(value: unknown, fieldName: string): JsonObject[];
 export declare function requiredStringField(row: JsonObject, key: string, fieldName: string): string;
@@ -386,6 +322,21 @@ export declare function validateExecutorQaRedTeamEvidenceForReview(cwd: string,
     mode?: "review";
     changeSet?: UltragoalChangeSet;
 }): Promise<void>;
+/**
+ * Read-only quality-gate validation (#3474). Applies exactly the same rules as
+ * `checkpoint --status complete` — including deferred-vs-boundary gate selection and
+ * artifact existence checks — but never touches `goals.json`, `ledger.jsonl`, or goal
+ * state, and reports every diagnostic in one run instead of the first failure.
+ */
+export declare function validateUltragoalQualityGateReadOnly(input: {
+    cwd: string;
+    qualityGateJson: string;
+    goalId?: string;
+    sessionId?: string | null;
+}): Promise<{
+    valid: boolean;
+    errors: readonly UltragoalQualityGateDiagnostic[];
+}>;
 export declare function checkpointUltragoalGoal(input: {
     cwd: string;
     goalId: string;

package/dist/types/gjc-runtime/workflow-manifest.d.ts

@@ -1,6 +1,7 @@
 /**
  * TypeScript is the authoritative source of truth for GJC workflow manifests.
- * Keep the checked-in JSON projection synchronized manually with this module.
+ * Any JSON manifest projection is derived from this module and must never be
+ * hand-edited.
  */
 import { type CanonicalGjcWorkflowSkill } from "../skill-state/canonical-skills";
 export interface WorkflowState {
@@ -17,9 +18,7 @@ export interface WorkflowVerb {
     name: string;
     planned?: boolean;
     /** Invocation surface that exposes this verb in the real CLI parser. */
-    surface?: "state-action" | "command-positional" | "command-flag" | "draft-action";
-    /** Legacy surface retained for callers that have not migrated to normal typed commands. */
-    compatibilityOnly?: boolean;
+    surface?: "state-action" | "command-positional" | "command-flag";
 }
 export interface TypedArgSpec {
     name: string;
@@ -27,7 +26,6 @@ export interface TypedArgSpec {
     enumValues?: string[];
     required?: boolean;
     appliesToVerbs?: string[];
-    compatibilityOnly?: boolean;
     planned?: boolean;
 }
 export interface RetentionPolicy {

package/dist/types/internal-urls/local-root-gc.d.ts

@@ -0,0 +1,2 @@
+import type { GcStoreAdapter } from "../gjc-runtime/gc-runtime";
+export declare const localRootsGcAdapter: GcStoreAdapter;

package/dist/types/main.d.ts

@@ -96,7 +96,7 @@ export declare const BARE_RESUME_INTERACTIVE_ERROR = "--resume requires an inter
 export declare function resolveManagedAgentDirForScope(_cwd: string): string;
 export declare const BARE_RESUME_OPEN_ERROR = "Could not open the selected session. Use --resume <id>.";
 export declare function runInteractiveMode(session: AgentSession, version: string, changelogMarkdown: string | undefined, notifs: (InteractiveModeNotify | null)[], startupUpdate: StartupUpdateOrchestrator, initialMessages: string[], setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers: LspStartupServerInfo[] | undefined, mcpManager: MCPManager | undefined, eventBus?: EventBus, initialMessage?: string, initialImages?: ImageContent[], createInteractiveMode?: CreateInteractiveMode, resumeAction?: "continue-tail" | "open-idle"): Promise<void>;
-declare function getChangelogForDisplay(parsed: Args): Promise<string | undefined>;
+export declare function getChangelogForDisplay(parsed: Args): Promise<string | undefined>;
 export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings): Promise<SessionManager | undefined>;
 /**
  * Research-mode (RLM) preset hook. Lets `gjc rlm` augment the session options

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

@@ -25,4 +25,6 @@ export declare function clearMemoryData(agentDir: string, cwd: string): Promise<
  * Force-enqueue global consolidation maintenance work.
  */
 export declare function enqueueMemoryConsolidation(agentDir: string, cwd: string, sourceUpdatedAt?: number): void;
+/** Secret scrubbing applied to every phase-2 consolidation output. Test seam. */
+export declare function redactMemorySecretsForTesting(input: string): string;
 export declare function getMemoryRoot(agentDir: string, cwd: string): string;

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

@@ -1,5 +1,5 @@
 import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type AvailableCommand, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type DeleteSessionRequest, type DeleteSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
-import { type AcpProviderRegistration, AcpSdkAdapter } from "../../sdk/acp";
+import { type AcpProviderRegistration, type AcpReverseConnection, AcpSdkAdapter } from "../../sdk/acp";
 import type { AcpStartupOptions } from "./startup-options";
 export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
 type JsonObject = Record<string, unknown>;
@@ -195,30 +195,21 @@ export declare function acpPromptPayload(blocks: PromptRequest["prompt"]): {
         mimeType: string;
     }>;
 };
+/**
+ * `AcpSdkAdapterError.code` is an internal string, but the SDK only derives a
+ * JSON-RPC code from a `RequestError`. Everything else collapses to an opaque
+ * `-32603 Internal error`, which hides the reason and defeats client-side
+ * recovery (an ACP client cannot see that it must authenticate). Map the codes
+ * that have a defined ACP/JSON-RPC counterpart onto a real `RequestError`.
+ */
+export declare function acpRequestFailure(error: unknown): unknown;
 /** Registers a permission provider only when the ACP client requires prompts. */
 export declare function acpProviderRegistrations(capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): AcpProviderRegistration[];
+export declare function createAcpReverseConnection(connection: AgentSideConnection, sessionId: string): AcpReverseConnection;
 /** Maps ACP permission handling to the session's canonical SDK policy. */
 export declare function applyAcpPermissionMode(adapter: Pick<AcpSdkAdapter, "control">, capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): Promise<void>;
 /** Applies CLI-provided ACP startup settings through SDK controls before session exposure. */
 export declare function applyAcpStartupOptions(adapter: Pick<AcpSdkAdapter, "setModel" | "control">, options: AcpStartupOptions | undefined): Promise<void>;
-/** ACP form elicitation uses the client-facing reverse surface without owning a session runtime. */
-export declare function createAcpExtensionUiContext(connection: AgentSideConnection, getSessionId: () => string, capabilities: ClientCapabilities | undefined): {
-    select: (message: string, options: string[], dialog?: {
-        signal?: AbortSignal;
-        timeout?: number;
-        onTimeout?: () => void;
-    }) => Promise<string | undefined>;
-    confirm: (message: string, detail?: string, dialog?: {
-        signal?: AbortSignal;
-        timeout?: number;
-        onTimeout?: () => void;
-    }) => Promise<boolean>;
-    input: (message: string, placeholder?: string, dialog?: {
-        signal?: AbortSignal;
-        timeout?: number;
-        onTimeout?: () => void;
-    }) => Promise<string | undefined>;
-};
 /**
  * ACP is a pure SDK client. Session processes are created and resumed by the
  * broker, while all per-session operations use that session's authenticated SDK

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

@@ -10,11 +10,13 @@ export declare class AssistantMessageComponent extends Container {
     #private;
     private hideThinkingBlock;
     private readonly onImageUpdate?;
-    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, viewportAnchorId?: string);
+    private readonly onVisibleMutation?;
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, viewportAnchorId?: string, onVisibleMutation?: (() => void) | undefined);
     invalidate(): void;
     setHideThinkingBlock(hide: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     setUsageInfo(usage: Usage): void;
     updateContent(message: AssistantMessage, options?: AssistantMessageUpdateOptions): void;
+    dispose(): void;
 }
 export {};

package/dist/types/modes/components/gjc-bundle-settings.d.ts

@@ -0,0 +1,34 @@
+import { Container } from "@gajae-code/tui";
+import { type GjcLifecycleContext } from "../../extensibility/gjc-plugins/lifecycle";
+import { type GjcRuntimeSnapshotProvider } from "../../extensibility/gjc-plugins/runtime-quarantine";
+import type { GjcBundleIdentity, GjcBundleSummary, GjcLifecycleResult, GjcReviewedUpdateToken, GjcToggleResult, GjcUpdateApplyResult, GjcUpdatePreview } from "../../extensibility/gjc-plugins/types";
+/** Injectable lifecycle boundary; Settings never reads registries or executes bundle code. */
+export interface GjcBundleLifecyclePort {
+    listGjcBundles(ctx: GjcLifecycleContext): Promise<GjcBundleSummary[]>;
+    getGjcBundle(ctx: GjcLifecycleContext, identity: GjcBundleIdentity): Promise<GjcLifecycleResult<GjcBundleSummary>>;
+    previewGjcBundleUpdate(ctx: GjcLifecycleContext, identity: GjcBundleIdentity): Promise<GjcLifecycleResult<GjcUpdatePreview>>;
+    applyGjcBundleUpdate(ctx: GjcLifecycleContext, token: GjcReviewedUpdateToken): Promise<GjcLifecycleResult<GjcUpdateApplyResult>>;
+    setGjcBundleEnabled(ctx: GjcLifecycleContext, identity: GjcBundleIdentity, enabled: boolean): Promise<GjcLifecycleResult<GjcToggleResult>>;
+    setGjcBundleSurfaceEnabled(ctx: GjcLifecycleContext, identity: GjcBundleIdentity, surfaceId: string, enabled: boolean): Promise<GjcLifecycleResult<GjcToggleResult>>;
+}
+export interface GjcBundleSettingsDependencies {
+    lifecycle?: GjcBundleLifecyclePort;
+    runtimeSnapshotProvider?: GjcRuntimeSnapshotProvider;
+    activationGeneration?: number;
+}
+export interface GjcBundleSettingsCallbacks {
+    onClose: () => void;
+    onBundlesChanged?: () => void;
+}
+export type GjcBundleSettingsState = "loading" | "error" | "empty" | "list" | "detail" | "unsupported-source" | "update-review" | "update-confirm" | "update-running" | "update-result" | "stale-result" | "quarantined-blocked" | "mutation-in-flight-locked";
+/** Scope-qualified, lifecycle-backed Settings UI for installed GJC bundles. */
+export declare class GjcBundleSettingsComponent extends Container {
+    #private;
+    private readonly callbacks;
+    private readonly dependencies;
+    constructor(cwd: string, callbacks: GjcBundleSettingsCallbacks, dependencies?: GjcBundleSettingsDependencies);
+    get stateId(): GjcBundleSettingsState;
+    get navigationLocked(): boolean;
+    dispose(): void;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/irc-sidebar.d.ts

@@ -2,12 +2,50 @@ import { type Component, type ViewportAnchorProvider, type ViewportAnchorRender
 import type { IrcObservationLedger } from "../irc-observation-ledger";
 export declare const IRC_SIDEBAR_WIDTH_RATIO = 0.3;
 export declare const IRC_SIDEBAR_MAX_RENDER_ROWS = 2048;
+export declare const __ircSidebarPerfCounters: {
+    enabled: boolean;
+    projectionMemoHits: number;
+    projectionMemoMisses: number;
+    recordsVisited: number;
+    sourceBytes: number;
+    rows: number;
+    styledCacheHits: number;
+    styledCacheMisses: number;
+    wrapCalls: number;
+    snapshot(): {
+        projectionMemoHits: number;
+        projectionMemoMisses: number;
+        recordsVisited: number;
+        sourceBytes: number;
+        rows: number;
+        styledCacheHits: number;
+        styledCacheMisses: number;
+        wrapCalls: number;
+    };
+    enable(): void;
+    disable(): void;
+    reset(): void;
+};
 /** Computes transcript/sidebar widths while preserving at least half the terminal for the transcript. */
 export declare function computeIrcSplitWidths(width: number): {
     leftWidth: number;
     separatorWidth: number;
     rightWidth: number;
 };
+type SemanticLine = Readonly<{
+    kind: "header" | "body" | "elision" | "blank";
+    text: string;
+    sender?: string;
+    recipient?: string;
+    time?: string;
+}>;
+export type IrcSidebarSemanticProjection = Readonly<{
+    token: string;
+    lines: readonly SemanticLine[];
+}>;
+/** The authoritative bounded, display-neutral IRC sidebar projection. */
+export declare function getIrcSidebarSemanticProjection(ledger: IrcObservationLedger, width: number): IrcSidebarSemanticProjection;
+export declare function getIrcSidebarSemanticToken(ledger: IrcObservationLedger, width: number): string;
 export interface IrcSidebarTheme {
     fg(color: "dim" | "accent", text: string): string;
     bold(text: string): string;
@@ -26,7 +64,10 @@ export declare class IrcSplitViewComponent implements ViewportAnchorProvider {
     get visible(): boolean;
     effectiveSidebarVisible(width?: number): boolean;
     setVisible(visible: boolean): void;
+    invalidateTheme(): void;
+    resetSource(): void;
     render(width: number): string[];
     renderWithViewportAnchors(width: number): ViewportAnchorRender;
     invalidate(): void;
 }
+export {};