@gajae-code/coding-agent 0.11.1 → 0.11.2

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

@@ -0,0 +1,78 @@
+import type { GjcTeamConfig, GjcTeamLivenessRecoveryResult, GjcTeamPhase, GjcTeamShutdownMode, GjcTeamSnapshot, GjcTeamWorker, GjcTeamWorkerLifecycle, GjcTeamWorkerLifecycleState, GjcWorkerStatusState, WorkerHeartbeatFile, WorkerStatusFile } from "./team-runtime";
+import type { GjcTeamTask, GjcTeamTaskClaim, GjcTeamTaskMutationCapability } from "./team-store";
+export interface GjcTeamWorkerLifecycleContext {
+    config: GjcTeamConfig;
+    worker: GjcTeamWorker;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export interface GjcTeamWorkerRuntime {
+    findTeamDir(teamName: string, cwd: string, env: NodeJS.ProcessEnv): Promise<string>;
+    readConfig(dir: string): Promise<GjcTeamConfig>;
+    assertKnownWorker(config: GjcTeamConfig, worker: string): void;
+    assertKnownParticipant(config: GjcTeamConfig, worker: string): void;
+    findKnownWorker(config: GjcTeamConfig, worker: string): GjcTeamWorker;
+    workerDir(dir: string, worker: string): string;
+    readJson<T>(filePath: string): Promise<T | null>;
+    writeJson(filePath: string, value: unknown): Promise<void>;
+    appendEvent(dir: string, event: {
+        type: string;
+        worker?: string;
+        task_id?: string;
+        message: string;
+        data?: Record<string, unknown>;
+    }): Promise<unknown>;
+    now(): string;
+    nowMs(): number;
+    stableHash(value: string): string;
+}
+export interface GjcTeamWorkerOrchestrationRuntime extends GjcTeamWorkerRuntime {
+    readTasks(dir: string): Promise<GjcTeamTask[]>;
+    withTaskMutation<T>(dir: string, fn: (capability: GjcTeamTaskMutationCapability) => Promise<T>): Promise<T>;
+    appendTelemetry(dir: string, event: {
+        type: string;
+        message: string;
+        data?: Record<string, unknown>;
+    }): Promise<unknown>;
+    paneBelongsToTeamTarget(config: GjcTeamConfig, paneId: string): boolean;
+    parseDurationEnv(env: NodeJS.ProcessEnv, name: string, fallback: number): number;
+    parseHeartbeatStaleMs(env: NodeJS.ProcessEnv): number;
+    killWorkerPanes(config: GjcTeamConfig): void;
+    removeCleanCreatedWorktrees(workers: GjcTeamWorker[]): Promise<void>;
+    readMonitorSnapshot(dir: string): Promise<unknown>;
+    hasPendingIntegration(dir: string, config: GjcTeamConfig, monitor: unknown): Promise<boolean>;
+    writePhase(dir: string, phase: GjcTeamPhase): Promise<void>;
+    readSnapshot(teamName: string, cwd: string, env: NodeJS.ProcessEnv): Promise<GjcTeamSnapshot>;
+}
+export declare function workerLifecycleContext(config: GjcTeamConfig, worker: GjcTeamWorker, cwd: string, env: NodeJS.ProcessEnv): GjcTeamWorkerLifecycleContext;
+export type GjcShutdownAuthority = {
+    state: "proven_absent";
+} | {
+    state: "valid_present";
+} | {
+    state: "invalid_or_unreadable";
+};
+export declare function isGjcShutdownRequestRecord(value: unknown): boolean;
+/** Distinguishes a missing shutdown record from a present JSON `null` or invalid record. */
+export declare function readGjcShutdownAuthority(runtime: GjcTeamWorkerRuntime, filePath: string): Promise<GjcShutdownAuthority>;
+export declare function parseGjcWorkerStatusState(value: unknown): GjcWorkerStatusState;
+export declare function lifecycleStateForWorkerStatus(status: GjcWorkerStatusState): GjcTeamWorkerLifecycleState;
+export declare function readWorkerStatusFile(runtime: GjcTeamWorkerRuntime, dir: string, worker: string): Promise<WorkerStatusFile>;
+export declare function readWorkerLifecycleRecord(runtime: GjcTeamWorkerRuntime, dir: string, worker: GjcTeamWorker): Promise<GjcTeamWorkerLifecycle>;
+export declare function readWorkerLifecycleById(runtime: GjcTeamWorkerRuntime, dir: string, config: GjcTeamConfig): Promise<Record<string, GjcTeamWorkerLifecycle>>;
+export declare function writeWorkerLifecycleRecord(runtime: GjcTeamWorkerRuntime, dir: string, worker: GjcTeamWorker, lifecycleState: GjcTeamWorkerLifecycleState, updates?: Partial<GjcTeamWorkerLifecycle>): Promise<GjcTeamWorkerLifecycle>;
+export declare function writeWorkerLifecycleForConfig(runtime: GjcTeamWorkerRuntime, dir: string, config: GjcTeamConfig, lifecycleState: GjcTeamWorkerLifecycleState, updatesFor?: (worker: GjcTeamWorker) => Partial<GjcTeamWorkerLifecycle>): Promise<Record<string, GjcTeamWorkerLifecycle>>;
+export declare function readGjcWorkerStatus(runtime: GjcTeamWorkerRuntime, teamName: string, worker: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<WorkerStatusFile>;
+export declare function updateGjcWorkerStatus(runtime: GjcTeamWorkerRuntime, teamName: string, worker: string, status: GjcWorkerStatusState, cwd?: string, env?: NodeJS.ProcessEnv, currentTaskId?: string, reason?: string): Promise<WorkerStatusFile>;
+export declare function readGjcWorkerHeartbeat(runtime: GjcTeamWorkerRuntime, teamName: string, worker: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<WorkerHeartbeatFile | null>;
+export declare function updateGjcWorkerHeartbeat(runtime: GjcTeamWorkerRuntime, teamName: string, worker: string, heartbeat: WorkerHeartbeatFile, cwd?: string, env?: NodeJS.ProcessEnv): Promise<WorkerHeartbeatFile>;
+export declare function writeGjcWorkerStartupAck(runtime: GjcTeamWorkerRuntime, teamName: string, worker: string, cwd: string, env: NodeJS.ProcessEnv, input: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function writeGjcShutdownRequest(runtime: GjcTeamWorkerRuntime, teamName: string, worker: string, requestedBy: string, cwd: string | undefined, env: NodeJS.ProcessEnv | undefined, requestId: string, mode?: GjcTeamShutdownMode, requestedAt?: string): Promise<Record<string, unknown>>;
+export declare function readGjcShutdownAck(runtime: GjcTeamWorkerRuntime, teamName: string, worker: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<Record<string, unknown> | null>;
+export declare const GJC_TEAM_CONTINUATION_PROMPT = "Continue only your current claimed GJC team task. Re-read current GJC team state; do not replay prior output; report status.";
+export declare function gjcContinuationReservationDigest(reservation: Record<string, unknown>): string;
+export declare function isValidGjcContinuationReservation(value: unknown, incident: string, attempt: number, config: GjcTeamConfig, worker: string, task: GjcTeamTask, claim: GjcTeamTaskClaim, heartbeatAt: string, paneId: string): value is Record<string, unknown>;
+export declare function isValidGjcContinuationOutcome(value: unknown, reservation: Record<string, unknown>, incident: string, attempt: number): value is Record<string, unknown>;
+export declare function reconcileGjcTeamStaleClaims(runtime: GjcTeamWorkerOrchestrationRuntime, teamName: string, dir: string, config: GjcTeamConfig, env: NodeJS.ProcessEnv): Promise<GjcTeamLivenessRecoveryResult>;
+export declare function reconcileGjcTeamStaleClaimsUnlocked(runtime: GjcTeamWorkerOrchestrationRuntime, teamName: string, dir: string, config: GjcTeamConfig, env: NodeJS.ProcessEnv, capability: GjcTeamTaskMutationCapability): Promise<GjcTeamLivenessRecoveryResult>;
+export declare function shutdownGjcTeamWorkers(runtime: GjcTeamWorkerOrchestrationRuntime, teamName: string, cwd: string, env: NodeJS.ProcessEnv): Promise<GjcTeamSnapshot>;

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

@@ -150,6 +150,14 @@ export interface TmuxOwnerIsolationExecutionDependencies {
     }): void;
 }
 export declare function isExactScopedBootstrapSuccessReceipt(stdout: string): boolean;
+export declare function isSafeServerProof(server: TmuxServerProof, platform?: NodeJS.Platform): server is TmuxServerProof & {
+    state: "safe";
+    pid: number;
+    startTime: string;
+    cgroup: CgroupInfo;
+};
+/** Compares the stable identity fields of independently observed tmux servers. */
+export declare function sameServerIdentity(left: TmuxServerProof, right: TmuxServerProof): boolean;
 /**
  * Synchronous equivalent of the target-server truth table for managed callers.
  * Attempt persistence is injected so a caller can use its existing atomic state writer.

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

@@ -0,0 +1,13 @@
+import { type UltragoalChangeSet, type UltragoalChangeSetPath } from "./ultragoal-runtime";
+export declare function spawnText(command: string[], options: {
+    cwd: string;
+    timeoutMs?: number;
+}): Promise<{
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
+export declare function parseGitNameStatus(output: string): UltragoalChangeSetPath[];
+export declare function computeCheckpointChangeSet(cwd: string): Promise<UltragoalChangeSet | undefined>;
+export declare function parseUnifiedDiffPaths(diff: string): UltragoalChangeSetPath[];

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

@@ -0,0 +1,38 @@
+import { type JsonObject, type SurfaceFamily } from "./ultragoal-runtime";
+export declare function pngCrc32(bytes: Buffer): number;
+export declare function parsePngDimensions(bytes: Buffer): {
+    width: number;
+    height: number;
+    headerBytes: number;
+    sampleBytes?: Buffer;
+} | null;
+export declare function parseJpegDimensions(bytes: Buffer): {
+    width: number;
+    height: number;
+    headerBytes: number;
+    sampleBytes?: Buffer;
+} | null;
+export declare function validateStructuralArtifact(cwd: string, row: JsonObject, fieldName: string, options: {
+    surfaceFamily: SurfaceFamily;
+    live: boolean;
+}): Promise<boolean>;
+export declare function isAllowedGitReplayCommand(args: readonly string[]): boolean;
+export declare function readCliReplayRecord(cwd: string, row: JsonObject, fieldName: string): Promise<JsonObject | null>;
+export interface ReplayProcessHandle {
+    readonly exited: Promise<number>;
+    kill(signal?: number | NodeJS.Signals): void;
+}
+export declare function waitForReplayProcessWithTimeout(process: ReplayProcessHandle, timeoutMs: number, graceMs?: number): Promise<number>;
+export declare function validateReplayExemptFallback(cwd: string, record: JsonObject, fieldName: string, artifactRefs: Map<string, JsonObject>, options: {
+    surfaceFamily: SurfaceFamily;
+    live: boolean;
+}): Promise<boolean>;
+export declare function validateCliReplay(cwd: string, row: JsonObject, fieldName: string, options: {
+    live: boolean;
+}): Promise<boolean>;
+export declare function validateLiveSurfaceProofPresence(cwd: string, family: SurfaceFamily, artifactIds: string[], artifactRefs: Map<string, JsonObject>): Promise<void>;
+export declare function validateSurfaceStructuralRequirement(cwd: string, family: SurfaceFamily, artifactIds: string[], artifactRefs: Map<string, JsonObject>, fieldName: string): Promise<void>;
+export declare function validateArtifactProof(cwd: string, row: JsonObject, fieldName: string, options: {
+    surfaceFamily: SurfaceFamily;
+    live: boolean;
+}): Promise<void>;

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

@@ -17,6 +17,13 @@ export interface UltragoalAskBlockDiagnostic {
 export interface CurrentGoalLike {
     objective: string;
     status?: string;
+    provenance?: {
+        source: "ultragoal";
+        runId: string;
+        goalId: string;
+    } | {
+        source: "user";
+    };
 }
 export declare function validateCompletionReceipt(input: {
     plan: UltragoalPlan;

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

@@ -0,0 +1,23 @@
+import { type JsonObject, type UltragoalGoal, type UltragoalPipelineOverlapReceipt, type UltragoalPlan } from "./ultragoal-runtime";
+export declare function requirePipelineStartable(plan: UltragoalPlan, prior: UltragoalGoal, next: UltragoalGoal): void;
+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>;

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

@@ -209,11 +209,15 @@ export interface UltragoalCommandResult {
     stderr?: string;
     createdPlan?: boolean;
 }
-interface JsonObject {
+export interface JsonObject {
     [key: string]: unknown;
 }
+export declare function currentUltragoalSessionId(cwd: string): string;
+export declare const PASSED_STATUS = "passed";
 export declare function hashStructuredValue(value: unknown): string;
 export declare function getUltragoalPaths(cwd: string, sessionId?: string | null): UltragoalPaths;
+export declare function isEnoent(error: unknown): boolean;
+export declare function appendLedger(cwd: string, event: JsonObject, sessionId?: string | null): Promise<UltragoalLedgerEvent>;
 export declare function readUltragoalLedger(cwd: string, sessionId?: string | null): Promise<UltragoalLedgerEvent[]>;
 export declare const DEFAULT_ULTRAGOAL_NUDGE_BUDGET = 10;
 /** Pure: count ledger `nudge` rows for an exact goalId. */
@@ -255,6 +259,25 @@ export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
     reason: string;
     currentGoalObjective?: string;
 }): Promise<UltragoalNudgeOutcome>;
+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;
@@ -276,27 +299,10 @@ 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 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;
@@ -309,16 +315,25 @@ export declare function startNextUltragoalGoal(input: {
     goal?: UltragoalGoal;
     allComplete: boolean;
 }>;
-type SurfaceFamily = "web" | "cli" | "native" | "api-package" | "algorithm-math" | "unknown";
-type UltragoalChangeStatus = "added" | "modified" | "deleted" | "renamed" | "copied" | "unknown";
-type UltragoalChangeCategory = "code" | "generated-binding" | "tool" | "settings-registry" | "prompt-doc-behavior" | "docs-static" | "other";
-interface UltragoalChangeSetPath extends JsonObject {
+export declare function qualityGateObject(value: unknown): JsonObject | null;
+export declare function nonEmptyStringArray(value: unknown): string[] | null;
+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;
+export declare function requireStringLinks(value: unknown, fieldName: string): string[];
+export declare function requireResolvedLinks(ids: string[], map: Map<string, JsonObject>, fieldName: string): void;
+export declare function normalizedEvidenceKind(row: JsonObject): string;
+export declare function evidenceKindMatches(kind: string, words: string[]): boolean;
+export type SurfaceFamily = "web" | "cli" | "native" | "api-package" | "algorithm-math" | "unknown";
+export type UltragoalChangeStatus = "added" | "modified" | "deleted" | "renamed" | "copied" | "unknown";
+export type UltragoalChangeCategory = "code" | "generated-binding" | "tool" | "settings-registry" | "prompt-doc-behavior" | "docs-static" | "other";
+export interface UltragoalChangeSetPath extends JsonObject {
     path: string;
     status: UltragoalChangeStatus;
     oldPath?: string;
     category?: UltragoalChangeCategory;
 }
-interface UltragoalChangeSet extends JsonObject {
+export interface UltragoalChangeSet extends JsonObject {
     source: "checkpoint-git" | "review-pr" | "review-branch" | "review-worktree" | "review-spec";
     baseRef?: string;
     headRef?: string;
@@ -328,13 +343,19 @@ interface UltragoalChangeSet extends JsonObject {
     rawDiff?: string;
     trusted: true;
 }
+export declare function normalizeRepoPath(value: string): string;
+export declare function categorizeComputerChangePath(value: string): UltragoalChangeCategory;
+export declare function isSettingsSchemaPath(value: string): boolean;
 export declare function normalizeSurfaceToken(value: string): string;
 export declare function surfaceFamily(value: string): SurfaceFamily;
-export interface ReplayProcessHandle {
-    readonly exited: Promise<number>;
-    kill(signal?: number | NodeJS.Signals): void;
-}
-export declare function waitForReplayProcessWithTimeout(process: ReplayProcessHandle, timeoutMs: number, graceMs?: number): Promise<number>;
+export declare function isLiveSurfaceFamily(family: SurfaceFamily): boolean;
+export declare function isSubstantiveEvidence(value: unknown): boolean;
+export declare function hasTypedVerifiedReceipt(value: unknown): boolean;
+export declare function hasExistingNonEmptyArtifact(cwd: string, value: unknown): Promise<boolean>;
+export declare function readArtifactBytes(cwd: string, row: JsonObject, fieldName: string): Promise<Buffer | null>;
+import { validateArtifactProof, validateCliReplay, validateLiveSurfaceProofPresence, validateReplayExemptFallback, validateStructuralArtifact, validateSurfaceStructuralRequirement, waitForReplayProcessWithTimeout } from "./ultragoal-evidence";
+export type { ReplayProcessHandle } from "./ultragoal-evidence";
+export { validateArtifactProof, validateCliReplay, validateLiveSurfaceProofPresence, validateReplayExemptFallback, validateStructuralArtifact, validateSurfaceStructuralRequirement, waitForReplayProcessWithTimeout, };
 export declare function validateExecutorQaRedTeamEvidenceForReview(cwd: string, executorQa: Record<string, unknown>, options?: {
     mode?: "review";
     changeSet?: UltragoalChangeSet;
@@ -405,6 +426,7 @@ interface UltragoalReviewResult extends JsonObject {
     weakContractCapApplied: boolean;
     blockerGoalIds?: string[];
 }
-export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
+import { computeCheckpointChangeSet, parseGitNameStatus, parseUnifiedDiffPaths, resolveGitBase, spawnText } from "./ultragoal-change-set";
+export { computeCheckpointChangeSet, parseGitNameStatus, parseUnifiedDiffPaths, resolveGitBase, spawnText };
 export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string): Promise<UltragoalCommandResult>;

package/dist/types/gjc-runtime/workflow-cli-common.d.ts

@@ -0,0 +1,8 @@
+export declare class CommandError extends Error {
+    readonly exitStatus: number;
+    constructor(exitStatus: number, message: string);
+}
+export declare function flagValue(args: readonly string[], flag: string): string | undefined;
+export declare function hasFlag(args: readonly string[], flag: string): boolean;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function assertSafePathComponent(value: string, label: string): void;

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

@@ -44,6 +44,9 @@ export interface SkillManifest {
     retention: RetentionPolicy[];
     hudFields: string[];
     graphLabel: string;
+    stopReleasingPhases: readonly string[];
+    phaseLock: readonly string[];
+    canonicalOverrides: readonly string[];
 }
 export declare const WORKFLOW_MANIFEST: Record<CanonicalGjcWorkflowSkill, SkillManifest>;
 export declare function getSkillManifest(skill: CanonicalGjcWorkflowSkill): SkillManifest;

package/dist/types/goals/continuation-timeout-guard.d.ts

@@ -0,0 +1,22 @@
+export type ToolOutcomeKind = "timeout" | "success" | "other-error";
+export interface TimeoutToolOutcome {
+    toolName: string;
+    argsKey: string;
+    kind: ToolOutcomeKind;
+}
+export interface TimeoutHoldState {
+    heldSnapshotKey?: string;
+    fingerprint?: string;
+    streak: number;
+}
+export declare function toResultText(result: unknown): string;
+export declare function classifyToolOutcome(isError: unknown, text: string): ToolOutcomeKind;
+export declare function canonicalArgsKey(args: unknown): string;
+export declare function turnTimeoutFingerprint(outcomes: readonly TimeoutToolOutcome[]): string | null;
+export declare function decideTimeoutHold(prev: TimeoutHoldState, turn: {
+    snapshotKey: string;
+    fingerprint: string | null;
+}): {
+    hold: boolean;
+    next: TimeoutHoldState;
+};

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

@@ -50,6 +50,7 @@ export declare class GoalRuntime {
     flushUsage(currentUsage?: GoalTokenUsage): Promise<void>;
     createGoal(input: {
         objective: string;
+        provenance?: Goal["provenance"];
     }): Promise<GoalModeState>;
     replaceGoal(input: {
         objective: string;

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

@@ -1,5 +1,12 @@
 import type { UsageStatistics } from "../session/session-manager";
 export type GoalStatus = "active" | "paused" | "complete" | "dropped";
+export type GoalProvenance = {
+    source: "ultragoal";
+    runId: string;
+    goalId: string;
+} | {
+    source: "user";
+};
 export interface Goal {
     id: string;
     objective: string;
@@ -8,6 +15,7 @@ export interface Goal {
     timeUsedSeconds: number;
     createdAt: number;
     updatedAt: number;
+    provenance?: GoalProvenance;
 }
 export interface GoalModeState {
     enabled: boolean;

package/dist/types/harness-control-plane/lifecycle-reconciliation.d.ts

@@ -0,0 +1,17 @@
+import type { Observation, SessionState } from "./types";
+export declare const OWNER_STARTUP_BLOCKER = "owner-died-before-first-prompt";
+export interface CompletedTerminalEvent {
+    cursor: number;
+    createdAt: string;
+    kind: string;
+}
+export declare function isOwnerLivenessBlocker(blocker: string): boolean;
+export declare function needsVanishedOwnerBlock(state: SessionState, observation: Observation, completedTerminal: CompletedTerminalEvent | null): boolean;
+export declare function reconcileOwnerLifecycle(input: {
+    state: SessionState;
+    observation: Observation;
+    completedTerminal: CompletedTerminalEvent | null;
+    startupBlocked: boolean;
+    persist: (state: SessionState) => Promise<void>;
+    nowIso: () => string;
+}): Promise<SessionState>;

package/dist/types/harness-control-plane/phase-rollup.d.ts

@@ -1,12 +1,9 @@
 /**
- * Phase-boundary receipt rollup builder (receipt-of-receipts).
+ * EXPERIMENTAL: Phase-boundary receipt rollup builder (receipt-of-receipts).
  *
- * At a harness lifecycle boundary, N child task receipts can be superseded by a
- * single `phase-rollup` receipt that preserves per-child pointers (id, status,
- * outputRef, sha256) plus aggregate ROI totals. The rollup is hash-sealed via
- * the standard receipt envelope and validated fail-closed like every other
- * family (see `validatePhaseRollup` in receipts.ts). Pure builder — no runtime
- * injection behavior is changed here.
+ * This builder is not wired into finalize or retire yet; child receipts remain
+ * authoritative until a lifecycle integration preserves their supersession
+ * semantics. It is retained for controlled integration experiments only.
  */
 import type { TaskResultReceipt } from "../task/receipt";
 import { type BuildReceiptInput, type PhaseRollupEvidence, type ReceiptEnvelope } from "./receipts";

package/dist/types/harness-control-plane/receipt-ingest.d.ts

@@ -1,3 +1,8 @@
+/**
+ * EXPERIMENTAL: Receipt ingestion is a pure evaluator and is not yet wired to
+ * finalize or retire lifecycle mutation. Callers must not treat its result as
+ * authoritative lifecycle persistence.
+ */
 import type { ReceiptEnvelope } from "./receipts";
 import type { HarnessLifecycle, ReceiptFamily, SessionState } from "./types";
 export declare const RECEIPT_DIGEST_MAX_CHARS = 280;

package/dist/types/harness-control-plane/receipt-spool.d.ts

@@ -10,6 +10,10 @@ export interface ReceiptSpoolAppendResult {
     cursor: string;
     path: string;
 }
+/** @internal Test-only instrumentation for steady-state spool scan coverage. */
+export declare function receiptSpoolFullScanCountForTesting(): number;
+/** @internal Test-only cache reset. */
+export declare function resetReceiptSpoolCursorCacheForTesting(): void;
 export declare function withReceiptSpoolDir<T>(spoolDir: string, fn: () => Promise<T>): Promise<T>;
 export declare function resolveReceiptSpoolDir(env?: NodeJS.ProcessEnv): string | undefined;
 export declare function receiptSpoolPath(spoolDir: string): string;

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

@@ -44,7 +44,7 @@ export declare class HindsightRetainQueue {
     get depth(): number;
     enqueue(content: string, context?: string): void;
     flush(): Promise<void>;
-    dispose(): void;
+    dispose(): Promise<void>;
 }
 /** Per-session Hindsight runtime state owned by its AgentSession. */
 export declare class HindsightSessionState {
@@ -64,6 +64,7 @@ export declare class HindsightSessionState {
     lastRetainedTurn: number;
     hasRecalledForFirstTurn: boolean;
     lastRecallSnippet?: string;
+    lastInjectedRecallSnippetHash?: string;
     /** Cached `<mental_models>` block injected into developer instructions. */
     mentalModelsSnippet?: string;
     /** When the cached snippet was last refreshed; gates the agent_end re-list. */
@@ -81,19 +82,25 @@ export declare class HindsightSessionState {
     constructor(options: HindsightSessionStateOptions);
     setSessionId(sessionId: string): void;
     resetConversationTracking(): void;
+    /** Return the current recall payload, resolving subagent aliases to their primary state. */
+    getRecallSnippet(): string | undefined;
+    /** Return the current recall payload without consuming its one-shot injection eligibility. */
+    getRecallSnippetForInjection(): string | undefined;
+    /** Mark a recall payload consumed only after it has been accepted for provider injection. */
+    markRecallSnippetInjected(snippet: string): boolean;
     enqueueRetain(content: string, context?: string): void;
     flushRetainQueue(): Promise<void>;
     recallForContext(query: string, signal?: AbortSignal): Promise<RecallOutcome>;
-    retainSession(messages: HindsightMessage[]): Promise<void>;
+    retainSession(messages: HindsightMessage[]): Promise<boolean>;
     maybeRetainOnAgentEnd(): Promise<void>;
     forceRetainCurrentSession(): Promise<void>;
     maybeRecallOnAgentStart(): Promise<void>;
     beforeAgentStartPrompt(promptText: string): Promise<string | undefined>;
     recallForCompaction(messages: HindsightMessage[]): Promise<string | undefined>;
     runMentalModelLoad(scope: BankScope): Promise<void>;
-    refreshMentalModelsSnippet(): Promise<void>;
+    refreshMentalModelsSnippet(): Promise<boolean>;
     reloadMentalModels(): Promise<boolean>;
     attachSessionListeners(): void;
-    dispose(): void;
+    dispose(): Promise<void>;
 }
 export {};

package/dist/types/lsp/lspmux.d.ts

@@ -25,9 +25,11 @@ interface LspmuxState {
  * Detect lspmux availability and state.
  * Results are cached for STATE_CACHE_TTL_MS.
  *
- * Set PI_DISABLE_LSPMUX=1 to disable.
+ * Set GJC_DISABLE_LSPMUX=1 or PI_DISABLE_LSPMUX=1 to disable.
  */
-export declare function detectLspmux(): Promise<LspmuxState>;
+export declare function detectLspmux(cwd?: string): Promise<LspmuxState>;
+/** Reset cached lspmux detection state for focused tests. */
+export declare function resetLspmuxStateForTesting(): void;
 /**
  * Check if a server command is supported by lspmux.
  */
@@ -54,5 +56,5 @@ export declare function wrapWithLspmux(originalCommand: string, originalArgs: st
  * @param args - Original command arguments
  * @returns Command and args to use (possibly wrapped with lspmux)
  */
-export declare function getLspmuxCommand(command: string, args?: string[]): Promise<LspmuxWrappedCommand>;
+export declare function getLspmuxCommand(command: string, args?: string[], cwd?: string): Promise<LspmuxWrappedCommand>;
 export {};

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

@@ -0,0 +1 @@
+export declare function isProjectControlledPath(candidate: string, cwd: string): boolean;

package/dist/types/main.d.ts

@@ -18,7 +18,7 @@ import type { SubmittedUserInput } from "./modes/types";
 import type { MCPManager } from "./runtime-mcp";
 import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
-import { type ResumeSessionIdentity, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
+import { type ResumeSessionIdentity, type SessionDirectoryMigrationPolicy, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
 import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
 import type { LspStartupServerInfo } from "./tools";
 import type { EventBus } from "./utils/event-bus";
@@ -87,7 +87,7 @@ type CreateInteractiveMode = (options: InteractiveModeFactoryOptions) => Interac
 type ResumePickerTerminalCheck = () => boolean;
 type ListForResumePickerReadOnly = (cwd: string, sessionDir?: string) => Promise<SessionInfo[]>;
 type SelectResumeSession = (sessions: SessionInfo[]) => Promise<SessionSelectionResult>;
-type OpenExistingSessionStrict = (identity: ResumeSessionIdentity, sessionDir?: string) => Promise<StrictSessionOpenResult>;
+type OpenExistingSessionStrict = (identity: ResumeSessionIdentity, sessionDir?: string, migrationPolicy?: SessionDirectoryMigrationPolicy) => Promise<StrictSessionOpenResult>;
 export declare const BARE_RESUME_CONFLICT_ERROR = "--resume without a session cannot be combined with --continue, --fork, or --no-session.";
 export declare const BARE_RESUME_INTERACTIVE_ERROR = "--resume requires an interactive terminal; use --resume <id>.";
 export declare const BARE_RESUME_OPEN_ERROR = "Could not open the selected session. Use --resume <id>.";
@@ -127,6 +127,7 @@ export interface RunRootCommandDependencies {
     selectResumeSession?: SelectResumeSession;
     openExistingSessionStrict?: OpenExistingSessionStrict;
     initializeSettings?: typeof Settings.init;
+    loadSettingsForScope?: typeof Settings.loadForScope;
 }
 export declare function runRootCommand(parsed: Args, rawArgs: string[], deps?: RunRootCommandDependencies): Promise<void>;
 export declare function main(args: string[]): Promise<void>;

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

@@ -33,6 +33,7 @@ export declare function clearMemoryData(db: Database): void;
 export declare function upsertThreads(db: Database, threads: MemoryThread[]): void;
 export declare function claimStage1Jobs(db: Database, params: {
     nowSec: number;
+    cwd: string;
     threadScanLimit: number;
     maxRolloutsPerStartup: number;
     maxRolloutAgeDays: number;

package/dist/types/modes/action-registry.d.ts

@@ -0,0 +1,29 @@
+import type { AppKeybinding } from "../config/keybindings";
+export type FocusDomain = "composer" | "selector" | "overlay" | "global";
+export interface ActionMetadata {
+    id: AppKeybinding;
+    title: string;
+    category: string;
+    bindingId?: AppKeybinding;
+    domains: readonly FocusDomain[];
+    exclusiveGroup?: string | false;
+}
+export declare const APP_ACTION_METADATA: readonly ActionMetadata[];
+export interface ActionDefinition<Context> extends ActionMetadata {
+    availability(context: Context): boolean;
+    execute(context: Context): void | Promise<void>;
+}
+export interface ActionRegistryOptions<Context> {
+    context: Context;
+    showError(error: string): void;
+}
+export declare class ActionRegistry<Context> {
+    #private;
+    private readonly options;
+    constructor(options: ActionRegistryOptions<Context>);
+    register(action: ActionDefinition<Context>): void;
+    get(id: AppKeybinding): ActionDefinition<Context> | undefined;
+    all(): readonly ActionDefinition<Context>[];
+    isAvailable(id: AppKeybinding): boolean;
+    execute(id: AppKeybinding): Promise<boolean>;
+}

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

@@ -0,0 +1,14 @@
+import { Container, type SelectItem, SelectList } from "@gajae-code/tui";
+export interface FramedSelectOptions {
+    maxVisible?: number;
+    selectedValue?: string;
+    onSelect?: (item: SelectItem) => void;
+    onCancel?: () => void;
+    onSelectionChange?: (item: SelectItem) => void;
+}
+export interface FramedSelect {
+    container: Container;
+    selectList: SelectList;
+}
+/** Build the shared border/list selector chrome used by compact mode selectors. */
+export declare function FramedSelect(title: string | undefined, items: ReadonlyArray<SelectItem>, opts?: FramedSelectOptions): FramedSelect;