@gajae-code/coding-agent 0.12.0 → 0.12.2

package/dist/types/extensibility/gjc-plugins/lifecycle-reconciliation.d.ts

@@ -0,0 +1,55 @@
+import { type GjcBundleIdentity, type GjcPluginQuarantineEntry, type GjcPluginRegistryEntry, type GjcPluginScope, type NormalizedGjcPluginBundle, type NormalizedGjcPluginSurfaces } from "./types";
+export declare function bundleIdentity(scope: GjcPluginScope, name: string): GjcBundleIdentity;
+export declare function identityKey(identity: GjcBundleIdentity): string;
+export declare function identityEquals(a: GjcBundleIdentity, b: GjcBundleIdentity): boolean;
+/** All stable surface IDs of a surface set, sorted and de-duplicated. */
+export declare function surfaceIdsOf(surfaces: NormalizedGjcPluginSurfaces): string[];
+/**
+ * Fingerprint of the exact installed target: identity plus the persisted bytes
+ * that any update must not silently replace.
+ */
+export declare function targetFingerprint(entry: GjcPluginRegistryEntry): string;
+/**
+ * Fingerprint of the exact installed baseline an update compares against: the
+ * installed content, the persisted enablement intent it must carry forward,
+ * and the stored source descriptor the update re-resolves from.
+ *
+ * Toggling the bundle or any surface changes this, so a preview taken before
+ * the toggle can no longer be applied. Binding the source matters just as much:
+ * apply re-resolves `entry.source.uri` before taking the locks, so a descriptor
+ * that changed in between must invalidate the reviewed baseline rather than let
+ * an update be committed from a locator the reviewer never saw.
+ */
+export declare function baselineFingerprint(entry: GjcPluginRegistryEntry): string;
+/** Fingerprint of an update candidate before it is written anywhere. */
+export declare function candidateFingerprint(scope: GjcPluginScope, bundle: NormalizedGjcPluginBundle): string;
+/**
+ * Fingerprint of everything besides the target and candidate bytes that the
+ * update decision depended on: opposite-scope same-name entries and the
+ * effective collision universe.
+ */
+export declare function decisionContextFingerprint(target: GjcBundleIdentity, effectiveEntries: readonly GjcPluginRegistryEntry[]): string;
+/**
+ * Fingerprint of the inputs that decide live activation. Changes here (and only
+ * here) advance the activation generation.
+ */
+export declare function activationFingerprint(entries: readonly GjcPluginRegistryEntry[]): string;
+export interface ReconciledEnablement {
+    disabledSurfaceIds: string[];
+    quarantine: GjcPluginQuarantineEntry[];
+}
+/**
+ * Carry persisted enablement intent across an update:
+ * - surviving disabled IDs stay disabled,
+ * - IDs whose surface disappeared are dropped,
+ * - new surface IDs are enabled by omission,
+ * - quarantine is recomputed from candidateQuarantine against the candidate's
+ *   surface set; omitted input means no candidate quarantine is justified.
+ */
+export declare function reconcileEnablement(previousDisabledSurfaceIds: readonly string[], candidateSurfaceIds: readonly string[], candidateQuarantine?: readonly GjcPluginQuarantineEntry[]): ReconciledEnablement;
+export interface SurfaceDelta {
+    addedSurfaceIds: string[];
+    removedSurfaceIds: string[];
+    retainedSurfaceIds: string[];
+}
+export declare function diffSurfaceIds(currentSurfaceIds: readonly string[], candidateSurfaceIds: readonly string[]): SurfaceDelta;

package/dist/types/extensibility/gjc-plugins/lifecycle.d.ts

@@ -0,0 +1,64 @@
+import type { GjcBundleIdentity, GjcBundleSummary, GjcInstallResult, GjcLifecycleResult, GjcPluginRegistryEntry, GjcPluginRegistrySource, GjcPluginScope, GjcReviewedUpdateToken, GjcToggleResult, GjcUpdateApplyResult, GjcUpdatePreview } from "./types";
+/**
+ * GJC bundle lifecycle service.
+ *
+ * This module is the ONLY policy and persistence writer for GJC bundles: fresh
+ * install, update preview/apply, bundle enable/disable, and surface
+ * enable/disable. Callers (CLI, Settings) never touch the registry writers or
+ * the installer transaction directly.
+ */
+export interface GjcLifecycleContext {
+    cwd: string;
+}
+export declare function redactSourceLocator(source: GjcPluginRegistrySource): string;
+/** Safe, redacted DTO for one installed bundle. */
+export declare function toBundleSummary(entry: GjcPluginRegistryEntry): GjcBundleSummary;
+/**
+ * Rebuild the exact locator an update must re-resolve from. A git ref is stored
+ * separately from the URI, so re-resolving the bare URI would silently drop the
+ * reviewed branch or tag and update from the default branch instead.
+ */
+declare function storedSourceLocator(source: GjcPluginRegistrySource): string;
+/** Exposed for locator-reconstruction tests; not part of the lifecycle API. */
+export declare const storedSourceLocatorForTest: typeof storedSourceLocator;
+/** Exposed so a test can pin parity with the installer's source predicates. */
+export declare const isLocalDirectorySourceForTest: typeof isLocalDirectorySource;
+/** All installed bundles across both scopes, deterministically ordered. */
+export declare function listGjcBundles(ctx: GjcLifecycleContext): Promise<GjcBundleSummary[]>;
+/** One bundle by exact (scope, name) identity. Opposite scope never matches. */
+export declare function getGjcBundle(ctx: GjcLifecycleContext, identity: GjcBundleIdentity): Promise<GjcLifecycleResult<GjcBundleSummary>>;
+/**
+ * True only for strings the installer would treat as a local path rather than
+ * a remote locator. This deliberately mirrors the installer's own `looksLikeGit`
+ * predicate: if the two ever disagreed, a remote locator could be read as a
+ * relative path and shadowed by a local directory of the same shape.
+ */
+declare function isLocalDirectorySource(source: string): boolean;
+/**
+ * Fresh install only. An existing target in the same scope is create-only and
+ * is refused identically with or without force; upgrading is a separate,
+ * scope-qualified operation.
+ */
+export declare function installGjcBundle(ctx: GjcLifecycleContext, scope: GjcPluginScope, source: string): Promise<GjcLifecycleResult<GjcInstallResult>>;
+/**
+ * Re-resolve the stored source descriptor and describe what an update would do.
+ * The returned token binds the candidate, the exact installed baseline, and the
+ * deterministic decision context; apply is a compare-and-swap on all three.
+ */
+export declare function previewGjcBundleUpdate(ctx: GjcLifecycleContext, identity: GjcBundleIdentity): Promise<GjcLifecycleResult<GjcUpdatePreview>>;
+/**
+ * Apply a previously reviewed update. Any drift in the candidate bytes, the
+ * installed baseline, or the decision context returns a typed stale error with
+ * zero mutation.
+ */
+export declare function applyGjcBundleUpdate(ctx: GjcLifecycleContext, token: GjcReviewedUpdateToken): Promise<GjcLifecycleResult<GjcUpdateApplyResult>>;
+/**
+ * Enable or disable a whole bundle. Deterministic quarantine blocks enabling;
+ * disabling is always allowed so operators can always de-escalate.
+ */
+export declare function setGjcBundleEnabled(ctx: GjcLifecycleContext, identity: GjcBundleIdentity, enabled: boolean): Promise<GjcLifecycleResult<GjcToggleResult>>;
+/** Enable or disable one surface of a bundle by its stable extension ID. */
+export declare function setGjcBundleSurfaceEnabled(ctx: GjcLifecycleContext, identity: GjcBundleIdentity, surfaceId: string, enabled: boolean): Promise<GjcLifecycleResult<GjcToggleResult>>;
+/** Deterministic activation generation for the current persisted state. */
+export declare function currentActivationFingerprint(ctx: GjcLifecycleContext): Promise<string>;
+export {};

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

@@ -0,0 +1,67 @@
+import type { GjcBundleIdentity, GjcRuntimeFinding, GjcRuntimeSnapshot, GjcRuntimeSnapshotState } from "./types";
+/**
+ * Deterministic numeric activation generation for an activation fingerprint.
+ *
+ * Equal activation inputs yield an equal generation, so a consumer holding a
+ * snapshot can tell whether it still describes the state it is rendering.
+ * Derived from the fingerprint's leading hex so it stays inside the safe
+ * integer range.
+ */
+export declare function gjcActivationGenerationFor(activationFingerprint: string): number;
+/**
+ * Caller-owned accumulator for scope-qualified runtime evidence.
+ *
+ * Producers (loaders, adapters, validators) hand findings to an accumulator
+ * they were given; they never publish. Exactly one coordinator publishes a
+ * complete generation snapshot, and consumers merge it only when the identity
+ * and generation match.
+ */
+export declare class GjcRuntimeFindingAccumulator {
+    readonly generation: number;
+    private readonly findings;
+    constructor(generation: number);
+    add(finding: GjcRuntimeFinding): void;
+    addAll(findings: readonly GjcRuntimeFinding[]): void;
+    /** Sorted, de-duplicated snapshot for the generation this accumulator owns. */
+    snapshot(): GjcRuntimeSnapshot;
+}
+/** Read-only view of the most recently published complete generation. */
+export interface GjcRuntimeSnapshotProvider {
+    current(): GjcRuntimeSnapshotState;
+}
+/**
+ * Single-writer publisher for runtime evidence.
+ *
+ * Passes can overlap: the session's prompt rebuild is re-entrant, so a second
+ * pass may start while a first is still awaiting its producers. Publication is
+ * therefore fenced by a monotonic epoch. A pass reserves an epoch when it
+ * begins, which immediately retires whatever was published before, and its
+ * later publish is accepted only if no newer pass has reserved since. A slow or
+ * failed older pass can never overwrite a newer one, and an incomplete pass
+ * simply never publishes, leaving consumers at `unavailable`.
+ */
+export declare class GjcRuntimeSnapshotStore implements GjcRuntimeSnapshotProvider {
+    private state;
+    private epoch;
+    /**
+     * Begin a pass. Retires the current snapshot and returns the epoch token the
+     * caller must present to publish.
+     */
+    beginPass(): number;
+    /** Publish only if `epoch` is still the newest reserved pass. */
+    publish(snapshot: GjcRuntimeSnapshot, epoch?: number): void;
+    invalidate(): void;
+    current(): GjcRuntimeSnapshotState;
+}
+/**
+ * Findings for one bundle, but only when the snapshot is current AND describes
+ * the exact generation the consumer is rendering. Missing provider, mismatched
+ * generation, or unavailable state resolve to `unavailable` — never to a
+ * silently empty "clear" result.
+ */
+export declare function findingsForBundle(provider: GjcRuntimeSnapshotProvider | undefined, identity: GjcBundleIdentity, expectedGeneration: number): {
+    status: "unavailable";
+} | {
+    status: "current";
+    findings: GjcRuntimeFinding[];
+};

package/dist/types/extensibility/gjc-plugins/session-validation.d.ts

@@ -1,4 +1,4 @@
-import type { GjcPluginLoadErrorCode, GjcPluginRegistryEntry } from "./types";
+import type { GjcBundleIdentity, GjcPluginLoadErrorCode, GjcPluginRegistryEntry } from "./types";
 /**
  * Session-start validation: the registry is the collision authority. Capability
  * provider output is supplied as EVIDENCE only; plugin surfaces are never
@@ -16,6 +16,8 @@ export interface SessionCapabilityEvidence {
     appendixIds?: Iterable<string>;
 }
 export interface SessionQuarantine {
+    /** Scope-qualified canonical target this finding belongs to. */
+    identity: GjcBundleIdentity;
     plugin: string;
     surfaceId: string;
     code: GjcPluginLoadErrorCode;

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

@@ -218,3 +218,127 @@ export interface GjcPluginRegistry {
  * disabledSurfaceIds, and quarantine bookkeeping.
  */
 export type GjcPluginSurfaceExtensionId = string;
+/** Canonical GJC bundle identity: kind is fixed, target is (scope, name). */
+export declare const GJC_BUNDLE_KIND = "gjc-bundle";
+export interface GjcBundleIdentity {
+    kind: typeof GJC_BUNDLE_KIND;
+    scope: GjcPluginScope;
+    name: string;
+}
+/** Source descriptor exposed to CLI/Settings: never carries raw locator secrets. */
+export interface GjcBundleSafeSource {
+    kind: GjcPluginSourceKind;
+    /** Redacted display locator (host + path only; no userinfo/query/fragment). */
+    display: string;
+    /** Conservative safe git ref, omitted when the stored value is unsafe. */
+    ref?: string;
+    /** Hex-only revision identifier, omitted when the stored value is unsafe. */
+    sha?: string;
+    resolvedAt: string;
+    /** True when this source kind supports re-resolution during update. */
+    updatable: boolean;
+    /** Present only when updatable is false. */
+    unsupportedReason?: string;
+}
+export interface GjcBundleSurfaceSummary {
+    extensionId: string;
+    kind: "tool" | "hook" | "mcp" | "system-appendix" | "agent-appendix" | "subskill";
+    name: string;
+    /** Persisted user intent (registry disabledSurfaceIds). */
+    enabled: boolean;
+    /** Deterministic quarantine derived from persisted registry state only. */
+    quarantined: boolean;
+    quarantineCode?: GjcPluginLoadErrorCode;
+}
+/** Installed-bundle DTO shared by CLI and Settings. Contains no raw locators. */
+export interface GjcBundleSummary {
+    identity: GjcBundleIdentity;
+    version: string;
+    description?: string;
+    enabled: boolean;
+    source: GjcBundleSafeSource;
+    installedAt: string;
+    updatedAt: string;
+    manifestHash: string;
+    /** Deterministic fingerprint of the exact installed target. */
+    targetFingerprint: string;
+    surfaces: GjcBundleSurfaceSummary[];
+    /** True when any deterministic quarantine blocks enablement. */
+    quarantined: boolean;
+}
+/**
+ * Host-derived token binding an update preview to the exact candidate, the
+ * exact installed baseline, and the deterministic decision context. Apply is a
+ * compare-and-swap against all three fingerprints.
+ */
+export interface GjcReviewedUpdateToken {
+    identity: GjcBundleIdentity;
+    candidateFingerprint: string;
+    baselineFingerprint: string;
+    decisionContextFingerprint: string;
+    reviewedAt: string;
+}
+export type GjcLifecycleErrorCode = "already_installed_use_upgrade" | "not_installed" | "identity_mismatch" | "stale_candidate" | "stale_baseline" | "stale_decision_context" | "source_unsupported" | "source_unavailable" | "quarantined" | "surface_unknown" | "invalid_target";
+export interface GjcLifecycleError {
+    code: GjcLifecycleErrorCode;
+    /** Sanitized operator-facing message; never contains raw locators or causes. */
+    message: string;
+    /** Safe scoped recovery hint (e.g. the exact command to run instead). */
+    recovery?: string;
+}
+export type GjcLifecycleResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: GjcLifecycleError;
+};
+export interface GjcUpdatePreview {
+    identity: GjcBundleIdentity;
+    current: GjcBundleSummary;
+    candidateVersion: string;
+    candidateManifestHash: string;
+    /** Surface IDs added, removed, or retained by this candidate. */
+    addedSurfaceIds: string[];
+    removedSurfaceIds: string[];
+    retainedSurfaceIds: string[];
+    changed: boolean;
+    token: GjcReviewedUpdateToken;
+}
+export type GjcUpdateApplyStatus = "updated" | "unchanged";
+export interface GjcUpdateApplyResult {
+    status: GjcUpdateApplyStatus;
+    summary: GjcBundleSummary;
+    /** Number of filesystem remnants that could not be removed after a successful swap. */
+    remnantCount: number;
+}
+export interface GjcInstallResult {
+    status: "installed";
+    summary: GjcBundleSummary;
+}
+export interface GjcToggleResult {
+    summary: GjcBundleSummary;
+    /** False when the requested state already matched (no persisted mutation). */
+    mutated: boolean;
+}
+/**
+ * Scope-qualified runtime evidence emitted by producers. Producers never
+ * publish; the session coordinator accumulates one complete generation.
+ */
+export interface GjcRuntimeFinding {
+    identity: GjcBundleIdentity;
+    surfaceId: string;
+    code: GjcPluginLoadErrorCode;
+    message: string;
+}
+export interface GjcRuntimeSnapshot {
+    /** Monotonic activation generation this snapshot describes. */
+    generation: number;
+    findings: GjcRuntimeFinding[];
+}
+export type GjcRuntimeSnapshotState = {
+    status: "unavailable";
+} | {
+    status: "current";
+    snapshot: GjcRuntimeSnapshot;
+};

package/dist/types/gjc-runtime/launch-tmux.d.ts

@@ -87,6 +87,7 @@ export interface TmuxLaunchPlan {
     createdServerIdentity?: {
         pid: number;
         startTime: string;
+        pidProven?: boolean;
     };
     isPsmux: boolean;
     platform: NodeJS.Platform;

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

@@ -0,0 +1,114 @@
+/**
+ * Typed ralplan review conflicts and dispositions (#2902).
+ *
+ * Architect and Critic findings remain free-form in their stage markdown, but
+ * the join/revision path can record machine-checkable findings against stable
+ * plan targets. Incompatible actions on the same target produce open conflicts
+ * that block a clean join until an explicit disposition is recorded.
+ */
+export declare const RALPLAN_REVIEW_CONFLICTS_SCHEMA: "ralplan.review_conflicts.v1";
+export type ReviewAction = "add" | "remove" | "change" | "clarify";
+export type ReviewRole = "architect" | "critic";
+export type ReviewSeverity = "info" | "watch" | "block";
+export type DispositionChoice = "accept_architect" | "accept_critic" | "synthesize" | "defer_user" | "reject_both";
+export interface ReviewSourceReceipt {
+    stage: "architect" | "critic";
+    stageN: number;
+    path: string;
+    sha256: string;
+}
+export interface ReviewFinding {
+    findingId: string;
+    targetId: string;
+    action: ReviewAction;
+    severity: ReviewSeverity;
+    evidence: string;
+    sourceRole: ReviewRole;
+    sourceReceipt: ReviewSourceReceipt;
+    proposedOwner?: string;
+}
+export interface ReviewConflict {
+    conflictId: string;
+    targetId: string;
+    findingIds: [string, string];
+    actions: [ReviewAction, ReviewAction];
+    sourceRoles: [ReviewRole, ReviewRole];
+    status: "open" | "dispositioned";
+}
+export interface ConflictDisposition {
+    conflictId: string;
+    choice: DispositionChoice;
+    rationale: string;
+    decisionOwner: string;
+    affectedSections: string[];
+    dispositionedAt?: string;
+}
+export interface ReviewConflictDocument {
+    schema: typeof RALPLAN_REVIEW_CONFLICTS_SCHEMA;
+    plannerStageN: number;
+    findings: ReviewFinding[];
+    conflicts: ReviewConflict[];
+    dispositions: ConflictDisposition[];
+}
+export interface JoinGateResult {
+    ok: boolean;
+    openConflictIds: string[];
+    missingDispositionIds: string[];
+    orphanDispositionIds: string[];
+    message: string;
+}
+/** True when two actions on the same target cannot both remain. */
+export declare function actionsAreIncompatible(left: ReviewAction, right: ReviewAction): boolean;
+/**
+ * Derive open conflicts from typed findings. Only cross-role incompatible pairs
+ * on the same targetId are conflicts (Architect remove vs Critic add, etc.).
+ */
+export declare function detectReviewConflicts(findings: readonly ReviewFinding[]): ReviewConflict[];
+/** Mark conflicts dispositioned when a matching disposition exists. */
+export declare function applyDispositions(conflicts: readonly ReviewConflict[], dispositions: readonly ConflictDisposition[]): ReviewConflict[];
+/**
+ * Join gate: clean only when every derived conflict has an explicit disposition
+ * with rationale and decision owner, and no orphan dispositions reference unknown
+ * conflicts.
+ */
+export declare function evaluateReviewJoinGate(findings: readonly ReviewFinding[], dispositions: readonly ConflictDisposition[], precomputedConflicts?: readonly ReviewConflict[]): JoinGateResult;
+/** Strip optional markdown fence and parse JSON. */
+export declare function parseReviewConflictJson(raw: string): unknown;
+/**
+ * Authoritative provenance required by `gjc ralplan --write --stage disposition`.
+ *
+ * Without this, a disposition document can claim arbitrary path/hash strings and
+ * join the wrong Architect/Critic pass (#3013 adversarial review).
+ */
+export interface IndexedReviewArtifact {
+    path: string;
+    sha256: string;
+}
+export interface DispositionProvenanceContext {
+    /** CLI `--stage_n` for this disposition write; must equal `plannerStageN`. */
+    expectedStageN: number;
+    /**
+     * Persisted Architect/Critic (and other) stage artifacts from this run's
+     * `index.jsonl`, keyed by `${stage}\u0000${stageN}`.
+     */
+    indexedArtifacts: ReadonlyMap<string, IndexedReviewArtifact>;
+}
+/** Stable map key for a staged artifact identity in the run index. */
+export declare function reviewArtifactIndexKey(stage: string, stageN: number): string;
+/**
+ * Cross-check every finding's source receipt against the CLI stage number and
+ * the run's persisted Architect/Critic artifact index. Fail closed on mismatch
+ * or spoofed path/hash attestations.
+ */
+export declare function assertDispositionProvenance(doc: ReviewConflictDocument, provenance: DispositionProvenanceContext): void;
+/**
+ * Parse and validate a disposition-stage document. Re-derives conflicts from
+ * findings when omitted, then fails closed unless every conflict is dispositioned
+ * (or findings produce zero conflicts and dispositions are empty).
+ *
+ * When `provenance` is provided (CLI write path), also enforces authoritative
+ * same-pass receipt checks against the run index.
+ */
+export declare function parseReviewConflictDocument(raw: string | unknown, provenance?: DispositionProvenanceContext): ReviewConflictDocument;
+/** Canonical JSON serialization for disposition-stage artifacts. */
+export declare function serializeReviewConflictDocument(doc: ReviewConflictDocument): string;

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

@@ -14,9 +14,11 @@ import { type RalplanIndexRow } from "./ledger-event-renderer";
  * 2. **Artifact write**: `gjc ralplan --write --stage <type> --stage_n <N>
  *    (--artifact <path-or-string> | --artifact-env GJC_RALPLAN_ARTIFACT)
  *    [--run-id <id>] [--session-id <id>] [--lane-verdict <token>] [--json]` persists Planner / Architect
- *    / Critic / revision / post-interview / ADR / final markdown under `.gjc/plans/ralplan/<run-id>/`, maintains
- *    an `index.jsonl` audit log, copies `final` stages to `pending-approval.md`, and advances
- *    the HUD chip to reflect the latest persisted stage.
+ *    / Critic / disposition / revision / post-interview / ADR / final artifacts under
+ *    `.gjc/plans/ralplan/<run-id>/`, maintains an `index.jsonl` audit log, copies `final`
+ *    stages to `pending-approval.md`, and advances the HUD chip to reflect the latest
+ *    persisted stage. Disposition stage artifacts are fail-closed JSON documents that
+ *    record typed review conflicts with authoritative same-pass source receipts (#2902).
  */
 export interface RalplanCommandResult {
     status: number;
@@ -33,6 +35,13 @@ export declare const PLANNING_STUCK_MARKER = "PLANNING-STUCK";
 export declare const RALPLAN_DEFAULT_MAX_REVIEW_PASSES_PER_LANE = 1;
 /** Inclusive upper bound for `gjc.ralplan.maxReviewPassesPerLane` settings overrides. */
 export declare const RALPLAN_MAX_REVIEW_PASSES_PER_LANE_LIMIT = 10;
+export type RalplanAutoHandoffTarget = "off" | "ultragoal" | "team";
+export interface RalplanAutoHandoffResolution {
+    configuredTarget: RalplanAutoHandoffTarget;
+    effectiveTarget: RalplanAutoHandoffTarget;
+    degradationReason: string | null;
+    source: string;
+}
 export type RalplanIterationCapDecision = {
     allowed: true;
     currentIterations: number;
@@ -128,6 +137,16 @@ export declare function resolveRalplanMaxIterations(cwd: string): Promise<{
     maxIterations: number;
     source: string;
 }>;
+type RalplanAutoHandoffOptions = {
+    planningStuck?: boolean;
+    teamAvailabilityProbe?: () => {
+        available: true;
+    } | {
+        available: false;
+        reason: string;
+    };
+};
+export declare function resolveRalplanAutoHandoff(cwd: string, options?: RalplanAutoHandoffOptions): Promise<RalplanAutoHandoffResolution>;
 /** Resolve the per-lane review-pass budget with project-over-user precedence. */
 export declare function resolveRalplanMaxReviewPassesPerLane(cwd: string): Promise<{
     maxReviewPassesPerLane: number;
@@ -135,3 +154,4 @@ export declare function resolveRalplanMaxReviewPassesPerLane(cwd: string): Promi
 }>;
 export declare function isRalplanArtifactWriteInvocation(args: readonly string[]): boolean;
 export declare function runNativeRalplanCommand(args: string[], cwd?: string): Promise<RalplanCommandResult>;
+export {};

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

@@ -2,7 +2,7 @@ import type { GjcTeamConfig, GjcTeamSnapshot, GjcTeamStartOptions, GjcTeamTask,
 /** Launch-specific option wiring kept separate from runtime dispatch. */
 export declare function withTeamLaunchTransport(options: GjcTeamStartOptions, mailboxDeliveryTransport: GjcTeamStartOptions["mailboxDeliveryTransport"]): GjcTeamStartOptions;
 /** @internal Exported for unit tests. */
-export declare function buildWorkerCommand(config: GjcTeamConfig, worker: GjcTeamWorker, platform?: NodeJS.Platform, promptOverride?: string): string;
+export declare function buildWorkerCommand(config: GjcTeamConfig, worker: GjcTeamWorker, platform?: NodeJS.Platform, promptOverride?: string, env?: NodeJS.ProcessEnv): string;
 interface GjcTmuxBinary {
     command: string;
     isPsmux: boolean;

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

@@ -201,6 +201,13 @@ 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", "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[]) => {
@@ -225,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 = {
@@ -257,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>;
@@ -278,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-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/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;