@sayknow-cli/coding-agent 0.4.6 → 0.5.0

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

@@ -1,3 +1,4 @@
+import { type RalplanIndexRow } from "./ledger-event-renderer";
 /**
  * Native implementation of `skc ralplan`.
  *
@@ -12,7 +13,7 @@
  *
  * 2. **Artifact write**: `skc ralplan --write --stage <type> --stage_n <N>
  *    (--artifact <path-or-string> | --artifact-env SKC_RALPLAN_ARTIFACT)
- *    [--run-id <id>] [--session-id <id>] [--json]` persists Planner / Architect
+ *    [--run-id <id>] [--session-id <id>] [--lane-verdict <token>] [--json]` persists Planner / Architect
  *    / Critic / revision / post-interview / ADR / final markdown under `.skc/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.
@@ -22,5 +23,115 @@ export interface RalplanCommandResult {
     stdout?: string;
     stderr?: string;
 }
+/** Default consensus iterations (planner + revision openers) per run. Matches SKILL.md re-review cap. */
+export declare const RALPLAN_DEFAULT_MAX_ITERATIONS = 5;
+/** Inclusive upper bound for `skc.ralplan.maxIterations` settings overrides. */
+export declare const RALPLAN_MAX_ITERATIONS_LIMIT = 20;
+/** Operator-visible stuck signal for headless/CI orchestration (#3165). */
+export declare const PLANNING_STUCK_MARKER = "PLANNING-STUCK";
+/** Default architect/critic review passes per consensus iteration. */
+export declare const RALPLAN_DEFAULT_MAX_REVIEW_PASSES_PER_LANE = 1;
+/** Inclusive upper bound for `skc.ralplan.maxReviewPassesPerLane` settings overrides. */
+export declare const RALPLAN_MAX_REVIEW_PASSES_PER_LANE_LIMIT = 10;
+export type RalplanIterationCapDecision = {
+    allowed: true;
+    currentIterations: number;
+    projectedIterations: number;
+    maxIterations: number;
+} | {
+    allowed: false;
+    currentIterations: number;
+    projectedIterations: number;
+    maxIterations: number;
+    reason: string;
+};
+/**
+ * Pure consensus-iteration budget gate (#3165).
+ *
+ * A `planner` or `revision` write opens a new iteration (same definition as
+ * `summarizeRalplanIndex`). Other stages never open iterations and are always
+ * allowed by this gate — including `final` after the cap is already reached.
+ *
+ * `iterationFloor` raises the observed opener count when on-disk evidence or a
+ * recovered ledger is higher than the parsed index (fail-closed vs wipe/truncate).
+ */
+export declare function evaluateRalplanIterationCap(input: {
+    rows: readonly RalplanIndexRow[];
+    stage: string;
+    maxIterations?: number;
+    /** Minimum opener count (e.g. on-disk stage-*-{planner,revision}.md). */
+    iterationFloor?: number;
+}): RalplanIterationCapDecision;
+export type RalplanReviewLane = "architect" | "critic";
+export type RalplanReviewLaneBudgetDecision = {
+    allowed: true;
+    lane?: RalplanReviewLane;
+    currentPasses: number;
+    projectedPasses: number;
+    maxReviewPassesPerLane: number;
+    finalSlot: boolean;
+    ledgerNote?: string;
+} | {
+    allowed: false;
+    lane: RalplanReviewLane;
+    currentPasses: number;
+    projectedPasses: number;
+    maxReviewPassesPerLane: number;
+    finalSlot: false;
+    ledgerNote?: string;
+    reason: string;
+};
+/**
+ * Pure per-lane review-pass budget gate. Architect and critic passes are limited
+ * within the current consensus iteration; all other stages remain unconditionally
+ * available as escalation paths.
+ */
+export declare function evaluateRalplanReviewLaneBudget(input: {
+    rows: readonly RalplanIndexRow[];
+    stage: string;
+    maxReviewPassesPerLane?: unknown;
+    onDiskLaneCounts?: {
+        architect: number;
+        critic: number;
+    };
+}): RalplanReviewLaneBudgetDecision;
+/**
+ * Count on-disk planner/revision stage artifacts for a run. Used as a floor when
+ * `index.jsonl` is missing, empty, truncated, or otherwise under-counts openers.
+ */
+export declare function countRalplanOnDiskOpeners(cwd: string, sessionId: string, runId: string): Promise<number>;
+/**
+ * Count on-disk Architect/Critic stage artifacts for a run. This is the
+ * fail-closed floor for a missing, truncated, or malformed `index.jsonl`.
+ */
+export declare function countRalplanOnDiskLaneArtifacts(cwd: string, sessionId: string, runId: string): Promise<{
+    architect: number;
+    critic: number;
+}>;
+/**
+ * Load index rows for cap enforcement. Unlike HUD reads, returns structural
+ * signals so callers can fail closed when the ledger is empty/malformed while
+ * opener artifacts already exist on disk.
+ */
+export declare function loadRalplanIndexForCap(cwd: string, sessionId: string, runId: string): Promise<{
+    rows: RalplanIndexRow[];
+    indexPresent: boolean;
+    parseableLines: number;
+    rawLineCount: number;
+    rawText?: string;
+}>;
+/**
+ * Resolve ralplan consensus iteration cap. Project `./.skc/settings.json` overrides
+ * user settings, else default 5.
+ */
+export declare function resolveRalplanMaxIterations(cwd: string): Promise<{
+    maxIterations: number;
+    source: string;
+}>;
+/** Resolve the per-lane review-pass budget with project-over-user precedence. */
+export declare function resolveRalplanMaxReviewPassesPerLane(cwd: string): Promise<{
+    maxReviewPassesPerLane: number;
+    source: string;
+}>;
 export declare function isRalplanArtifactWriteInvocation(args: readonly string[]): boolean;
 export declare function runNativeRalplanCommand(args: string[], cwd?: string): Promise<RalplanCommandResult>;

package/dist/types/skc-runtime/repository-binding.d.ts

@@ -0,0 +1,63 @@
+import { type GitRepository } from "../utils/git";
+export declare const REPOSITORY_BINDING_SCHEMA: "skc.repository_binding.v1";
+export interface RepositoryBinding {
+    schema: typeof REPOSITORY_BINDING_SCHEMA;
+    /** Canonical realpath of the git worktree root (or resolved cwd root). */
+    worktreeRoot: string;
+    /** Git common dir realpath when available; null outside a git checkout. */
+    commonDir: string | null;
+    /** Optional repo-relative subdirectory the lane should operate under. */
+    relativeSubdir?: string;
+    /** Optional display path (may be non-canonical); never used for authority. */
+    displayPath?: string;
+    /** Optional baseline HEAD at capture time. */
+    head?: string;
+    /** Optional branch name at capture time (when not detached). */
+    branch?: string;
+}
+export type RepositoryBindingErrorCode = "not_a_repository" | "identity_mismatch" | "path_outside_root" | "invalid_binding";
+export declare class RepositoryBindingError extends Error {
+    readonly code: RepositoryBindingErrorCode;
+    constructor(code: RepositoryBindingErrorCode, message: string);
+}
+/** Capture a durable binding from the active cwd/worktree. */
+export declare function captureRepositoryBinding(cwd: string, options?: {
+    relativeSubdir?: string;
+    displayPath?: string;
+}): Promise<RepositoryBinding>;
+/** Parse a binding from JSON/plan payload; fail closed on malformed shapes. */
+export declare function parseRepositoryBinding(value: unknown): RepositoryBinding;
+/** True when two bindings refer to the same repository identity (linked worktrees ok). */
+export declare function repositoryBindingsMatch(left: RepositoryBinding, right: RepositoryBinding): boolean;
+/**
+ * Ensure `cwd` is inside the bound repository (or the same linked worktree family).
+ * Fails closed on sibling-repo drift.
+ */
+export declare function assertCwdMatchesRepositoryBinding(cwd: string, binding: RepositoryBinding): Promise<RepositoryBinding>;
+/** Ensure a declared target path resolves under the bound worktree root. */
+export declare function assertPathUnderRepositoryBinding(binding: RepositoryBinding, targetPath: string): string;
+/**
+ * Public identity snapshot for receipts/handoffs (no display-only fields required).
+ * Always includes the schema + durable roots so downstream lanes can re-verify.
+ */
+export declare function publicRepositoryBinding(binding: RepositoryBinding): RepositoryBinding;
+/**
+ * Resolve the authoritative binding for a delegated task before discovery/spawn.
+ *
+ * - Missing declaration → stamp from session cwd (never leave authority implicit).
+ * - Declared binding → parse + fail closed unless it matches the active session worktree.
+ * - relativeSubdir (when present) must resolve under the bound root.
+ */
+export declare function resolveTaskRepositoryBinding(sessionCwd: string, declared: unknown | undefined): Promise<RepositoryBinding>;
+/**
+ * Ensure an execution/isolation root (cwd or worktree) still matches the bound identity.
+ * Used after isolation workspace creation so linked worktrees keep the source repository.
+ */
+export declare function assertExecutionRootMatchesRepositoryBinding(executionRoot: string, binding: RepositoryBinding): Promise<RepositoryBinding>;
+/** Optional helper for tests and diagnostics. */
+export declare function bindingFromGitRepository(repository: GitRepository, options?: {
+    relativeSubdir?: string;
+    displayPath?: string;
+    head?: string;
+    branch?: string;
+}): RepositoryBinding;

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

@@ -11,6 +11,7 @@ export interface StateCommandResult {
     stdout?: string;
     stderr?: string;
 }
+type StateWarningSink = (warning: string) => void;
 /**
  * Reconcile a workflow skill's mode-state + active-state/HUD from a caller-derived
  * payload. Unlike `skc state write`, this is a derived repair: callers reconcile from
@@ -34,5 +35,6 @@ export declare function reconcileWorkflowSkillState(options: {
 }): Promise<{
     stateFile: string;
 }>;
-export declare function readWorkflowStateJson(cwd: string, skill: CanonicalSkcWorkflowSkill, sessionId?: string): Promise<Record<string, unknown>>;
+export declare function readWorkflowStateJson(cwd: string, skill: CanonicalSkcWorkflowSkill, sessionId?: string, onWarning?: StateWarningSink): Promise<Record<string, unknown>>;
 export declare function runNativeStateCommand(args: string[], cwd?: string): Promise<StateCommandResult>;
+export {};

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

@@ -62,7 +62,6 @@ export interface GuardedStateWriterOptions extends StateWriterOptions {
     policy: StateWritePolicy;
     expectedRevision?: number;
     sourceRevision?: number;
-    lockHeld?: boolean;
 }
 export type GuardedWriteResult = {
     path: string;
@@ -86,6 +85,11 @@ export interface StateWriterOptions {
      * `withFileLock` defaults.
      */
     lock?: FileLockOptions;
+    /**
+     * Caller already holds the workflow state lock for this target path (via
+     * `withWorkflowStateLock`). Skip re-acquisition to avoid self-deadlock.
+     */
+    lockHeld?: boolean;
 }
 export declare class StateWriteConflictError extends Error {
     readonly path: string;

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

@@ -2,7 +2,7 @@ import type { SkcTeamConfig, SkcTeamSnapshot, SkcTeamStartOptions, SkcTeamTask,
 /** Launch-specific option wiring kept separate from runtime dispatch. */
 export declare function withTeamLaunchTransport(options: SkcTeamStartOptions, mailboxDeliveryTransport: SkcTeamStartOptions["mailboxDeliveryTransport"]): SkcTeamStartOptions;
 /** @internal Exported for unit tests. */
-export declare function buildWorkerCommand(config: SkcTeamConfig, worker: SkcTeamWorker, platform?: NodeJS.Platform): string;
+export declare function buildWorkerCommand(config: SkcTeamConfig, worker: SkcTeamWorker, platform?: NodeJS.Platform, promptOverride?: string): string;
 interface SkcTmuxBinary {
     command: string;
     isPsmux: boolean;

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

@@ -267,16 +267,23 @@ export interface WorkerHeartbeatFile {
     last_turn_at: string;
     turn_count: number;
     alive: boolean;
+    /** Linux process start time, so a recycled PID cannot impersonate this worker. */
+    process_start_time?: string;
 }
 export interface SkcWorkerIntegrationAttemptRequestResult {
     requested: boolean;
-    reason: "requested" | "not_worker" | "missing_worktree" | "no_changes" | "deduped" | "git_error";
+    reason: "requested" | "not_worker" | "missing_worktree" | "no_changes" | "deduped" | "git_error" | "cancelled";
     worker?: string;
     team_name?: string;
     fingerprint?: string;
     head?: string | null;
     status?: SkcWorkerCheckpointClassification["kind"];
 }
+/** Caller-supplied controls for a worker integration attempt. */
+export interface SkcWorkerIntegrationAttemptOptions {
+    /** Abort the attempt between its blocking git probes. */
+    signal?: AbortSignal;
+}
 export declare const SKC_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 function resolveSkcTeamStateRoot(cwd?: string, env?: NodeJS.ProcessEnv): string;
 /** @internal */
@@ -314,7 +321,7 @@ export declare function classifyWorkerCheckpointStatus(cwd: string): SkcWorkerCh
 export declare function startSkcTeam(options: SkcTeamStartOptions): Promise<SkcTeamSnapshot>;
 export declare function readSkcTeamSnapshot(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv, options?: SkcTeamSnapshotOptions): Promise<SkcTeamSnapshot>;
 export declare function monitorSkcTeamSnapshot(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<SkcTeamSnapshot>;
-export declare function requestSkcWorkerIntegrationAttempt(cwd?: string, env?: NodeJS.ProcessEnv): Promise<SkcWorkerIntegrationAttemptRequestResult>;
+export declare function requestSkcWorkerIntegrationAttempt(cwd?: string, env?: NodeJS.ProcessEnv, options?: SkcWorkerIntegrationAttemptOptions): Promise<SkcWorkerIntegrationAttemptRequestResult>;
 export declare function buildTeamHudSummary(snapshot: SkcTeamSnapshot, latestEvent?: SkcTeamEvent, latestMessage?: SkcTeamMailboxMessage): Promise<WorkflowHudSummary>;
 export declare function monitorSkcTeam(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<SkcTeamSnapshot>;
 export declare function listSkcTeams(cwd?: string, env?: NodeJS.ProcessEnv): Promise<SkcTeamSnapshot[]>;

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

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

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

@@ -0,0 +1,92 @@
+import { type StateWriterOptions } from "./state-writer";
+export type SkcTeamWorkerMemoryGuardState = "idle" | "advisory" | "retrying" | "checkpointed" | "replaced" | "blocked";
+export type SkcTeamWorkerMemoryGuardCheckpointKind = "clean" | "eligible" | "protected_only" | "conflicted" | "git_error";
+export type SkcTeamWorkerMemoryGuardPidProbe = {
+    kind: "live";
+    start_time: string;
+} | {
+    kind: "absent";
+} | {
+    kind: "unverifiable";
+    reason: string;
+};
+export interface SkcTeamWorkerMemoryGuardCheckpoint {
+    kind: SkcTeamWorkerMemoryGuardCheckpointKind;
+    files: string[];
+    head?: string | null;
+    commit?: string | null;
+    recorded_at: string;
+}
+export interface SkcTeamWorkerMemoryGuardReplacement {
+    old_pane_id?: string;
+    new_pane_id?: string;
+    recorded_at: string;
+}
+export interface SkcTeamWorkerMemoryGuardLedger {
+    schema_version: 1;
+    worker_id: string;
+    platform: string;
+    state: SkcTeamWorkerMemoryGuardState;
+    automatic_action_allowed: boolean;
+    retry_count: number;
+    retry_limit: number;
+    current_task_id?: string;
+    last_incident_id?: string;
+    last_reason?: string;
+    last_pid_probe?: SkcTeamWorkerMemoryGuardPidProbe;
+    last_checkpoint?: SkcTeamWorkerMemoryGuardCheckpoint;
+    last_replacement?: SkcTeamWorkerMemoryGuardReplacement;
+    updated_at: string;
+}
+export interface SkcTeamWorkerMemoryGuardSelectionCandidate {
+    worker_id: string;
+    platform: string;
+    excess_bytes: number;
+    retry_count: number;
+    retry_limit: number;
+    blocked?: boolean;
+    current_task_id?: string;
+}
+export interface SkcTeamWorkerMemoryGuardSelection {
+    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 normalizeSkcTeamWorkerMemoryGuardPidProbe(value: unknown): SkcTeamWorkerMemoryGuardPidProbe | undefined;
+export declare function isCanonicalSkcTeamWorkerMemoryGuardCheckpoint(value: unknown): value is SkcTeamWorkerMemoryGuardCheckpoint;
+export declare function isCanonicalSkcTeamWorkerMemoryGuardReplacement(value: unknown): value is SkcTeamWorkerMemoryGuardReplacement;
+export declare function isCanonicalSkcTeamWorkerMemoryGuardPidProbe(value: unknown): value is SkcTeamWorkerMemoryGuardPidProbe;
+export declare function isCanonicalSkcTeamWorkerMemoryGuardLedger(value: unknown): value is SkcTeamWorkerMemoryGuardLedger;
+export declare function createInitialSkcTeamWorkerMemoryGuardLedger(input: {
+    workerId: string;
+    platform: string;
+    now: string;
+    retryLimit?: number;
+}): SkcTeamWorkerMemoryGuardLedger;
+export declare function selectSkcTeamWorkerMemoryGuardCandidate(candidates: readonly SkcTeamWorkerMemoryGuardSelectionCandidate[]): SkcTeamWorkerMemoryGuardSelection | 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/skc-runtime/tmux-owner-isolation.d.ts

@@ -267,6 +267,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/skc-runtime/ultragoal-guard.d.ts

@@ -1,5 +1,5 @@
 import { type UltragoalGoal, type UltragoalLedgerEvent, type UltragoalNudgeSurface, type UltragoalPlan, type UltragoalReceiptKind } from "./ultragoal-runtime";
-export type UltragoalGuardState = "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
+export type UltragoalGuardState = "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "active_missing_critic_verdict" | "unreadable_fail_closed";
 export interface UltragoalGuardDiagnostic {
     state: UltragoalGuardState;
     message: string;
@@ -25,6 +25,7 @@ export interface CurrentGoalLike {
         source: "user";
     };
 }
+export declare function isKnownUltragoalObjective(currentObjective: string): boolean;
 export declare function validateCompletionReceipt(input: {
     plan: UltragoalPlan;
     ledger: readonly UltragoalLedgerEvent[];
@@ -78,10 +79,10 @@ export interface UltragoalPauseBlockDiagnostic {
 }
 /**
  * While an Ultragoal run is active, `goal({"op":"pause"})` is only allowed when the
- * current durable Ultragoal state is readable and the latest durable ledger event
- * classifies the current blocker as `human_blocked`. Resolvable blockers must be
- * worked, not parked. Reads fail closed so unreadable durable state or ledger data
- * blocks pause rather than silently allowing a give-up.
+ * current durable Ultragoal state is readable, the latest `blocker_classified`
+ * event is `human_blocked`, and a later fresh clean pause terminal critic verdict is bound to
+ * that exact classification. Reads fail closed so unreadable durable state or
+ * ledger data blocks pause rather than silently allowing a give-up.
  */
 export declare function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPauseBlockDiagnostic>;
 export declare function assertUltragoalPauseAllowed(cwd: string): Promise<void>;

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

@@ -1,10 +1,30 @@
 import type { UltragoalCompletionVerification, UltragoalGoal, UltragoalGoalStatus, UltragoalLedgerEvent, UltragoalPlan, UltragoalReceiptKind } from "./ultragoal-runtime";
+export declare const CRITIC_VERDICT_EVENT = "critic_verdict";
+export declare const CRITIC_GATE_HARD_STOP_EVENT = "critic_gate_hard_stop";
+export declare const CRITIC_GATE_OVERRIDE_EVENT = "critic_gate_override";
+export declare const TERMINAL_CRITIC_CEILING = 5;
+export type CriticVerdict = "OKAY" | "ITERATE" | "REJECT";
 export type UltragoalReceiptFreshnessDiagnostic = {
     state: "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
     message: string;
     goalId?: string;
 };
 export declare function requiredUltragoalGoals(plan: UltragoalPlan): UltragoalGoal[];
+/** Hash the current required-goal set for terminal critic verdict freshness. */
+export declare function computeCriticVerdictPlanGeneration(plan: UltragoalPlan): string;
+export declare function isCleanPauseCriticVerdictShape(candidate: UltragoalLedgerEvent, planGeneration: string, classificationEventId: string): boolean;
+export declare function isCleanPauseCriticVerdict(event: UltragoalLedgerEvent, opts: {
+    planGeneration: string;
+    classificationEventId: string;
+}): boolean;
+export declare function findCleanPauseCriticVerdict(plan: UltragoalPlan, ledger: readonly UltragoalLedgerEvent[], classificationEventId: string): UltragoalLedgerEvent | null;
+/** Pure: count all ledger `critic_verdict` rows for an exact plan generation. */
+export declare function countTerminalCriticVerdicts(ledger: readonly UltragoalLedgerEvent[], planGeneration: string): number;
+/** Pure: count every non-OKAY terminal critic verdict recorded for this run. */
+export declare function countNonOkayTerminalCriticVerdicts(ledger: readonly UltragoalLedgerEvent[], _legacyPlanGeneration?: string): number;
+export declare function terminalCriticHardStopReached(ledger: readonly UltragoalLedgerEvent[], _legacyPlanGeneration?: string): boolean;
+export declare function terminalCriticGateOverridden(ledger: readonly UltragoalLedgerEvent[]): boolean;
+export declare function terminalCriticCeilingReached(ledger: readonly UltragoalLedgerEvent[], _legacyPlanGeneration?: string): boolean;
 export declare function receiptRelevantGoals(plan: UltragoalPlan, goal: UltragoalGoal, receiptKind: UltragoalReceiptKind): UltragoalGoal[];
 export declare function computeUltragoalPlanGeneration(input: {
     plan: UltragoalPlan;
@@ -19,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/skc-runtime/ultragoal-runtime.d.ts

@@ -1,5 +1,7 @@
 import type { WorkflowHudSummary } from "../skill-state/active-state";
-export { computeUltragoalPlanGeneration, receiptRelevantGoals } from "./ultragoal-receipt-freshness";
+import { type RepositoryBinding } from "./repository-binding";
+import { type CriticVerdict } from "./ultragoal-receipt-freshness";
+export { CRITIC_GATE_HARD_STOP_EVENT, CRITIC_GATE_OVERRIDE_EVENT, CRITIC_VERDICT_EVENT, type CriticVerdict, computeUltragoalPlanGeneration, countTerminalCriticVerdicts, receiptRelevantGoals, TERMINAL_CRITIC_CEILING, terminalCriticCeilingReached, terminalCriticGateOverridden, } from "./ultragoal-receipt-freshness";
 export { captureUltragoalRecoverySnapshot, parseStrictTerminalTranscript, persistUltragoalRecoveryDecision, planUltragoalOwnerLossRecovery, type UltragoalOwnerLossReceipt, type UltragoalRecoveryBinding, type UltragoalRecoveryDecision, type UltragoalRecoverySnapshot, validateOwnerLossBinding, validateRawUltragoalEvidence, validateRecoveryAdmission, validateRecoveryPath, } from "./ultragoal-owner-loss-recovery";
 export type UltragoalSkcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus = "pending" | "active" | "complete" | "failed" | "blocked" | "review_blocked" | "superseded";
@@ -95,6 +97,8 @@ export interface UltragoalPlan {
     skcObjective: string;
     skcObjectiveAliases?: string[];
     goals: UltragoalGoal[];
+    /** Authoritative repository identity for multi-repo fail-closed spawn (#2901). */
+    repositoryBinding?: RepositoryBinding;
     createdAt: string;
     updatedAt: string;
     [key: string]: unknown;
@@ -307,6 +311,26 @@ export { joinUltragoalPipelineOverlap, rebaselineUltragoalPipelineOverlap, start
 export declare function getUltragoalRunCompletionState(plan: UltragoalPlan, options?: {
     retryFailed?: boolean;
 }): UltragoalRunCompletionState;
+/**
+ * Discriminated next-action for `complete-goals` handoff (#2903).
+ * `none` is reserved for genuine completion; `execute-goal` always carries a goal.
+ */
+export type UltragoalCompleteNextActionKind = "none" | "execute-goal" | "retry-failed" | "resolve-blockers" | "final-aggregate-receipt";
+export type UltragoalCompleteNextAction = {
+    kind: UltragoalCompleteNextActionKind;
+    goal?: UltragoalGoal;
+    blockedGoals?: UltragoalGoal[];
+    failedGoals?: UltragoalGoal[];
+};
+/**
+ * Resolve the actionable next step after scheduling / complete-goals.
+ * Blocked and review_blocked goals remain unschedulable; they surface as
+ * `resolve-blockers` instead of a contradictory `execute-goal` without goal_id.
+ */
+export declare function resolveUltragoalCompleteNextAction(plan: UltragoalPlan, options?: {
+    retryFailed?: boolean;
+    selectedGoal?: UltragoalGoal;
+}): UltragoalCompleteNextAction;
 export declare function startNextUltragoalGoal(input: {
     cwd: string;
     retryFailed?: boolean;
@@ -315,6 +339,7 @@ export declare function startNextUltragoalGoal(input: {
     plan: UltragoalPlan;
     goal?: UltragoalGoal;
     allComplete: boolean;
+    nextAction: UltragoalCompleteNextAction;
 }>;
 export declare function qualityGateObject(value: unknown): JsonObject | null;
 export declare function nonEmptyStringArray(value: unknown): string[] | null;
@@ -401,10 +426,10 @@ export declare function recordUltragoalReviewBlockers(input: {
 }): Promise<UltragoalPlan>;
 export type UltragoalBlockerClassification = "human_blocked" | "resolvable";
 /**
- * Record an audited blocker triage classification in the durable ledger. A
- * `human_blocked` classification is the only thing that authorizes
- * `goal({"op":"pause"})` while an Ultragoal run is active; `resolvable` is an
- * audit note and never unblocks pause.
+ * Record an audited blocker triage classification in the durable ledger. Pause
+ * requires the latest `blocker_classified` event to be `human_blocked` and a
+ * later clean pause terminal critic verdict bound to that classification; `resolvable`
+ * is an audit note and never unblocks pause.
  */
 export declare function recordUltragoalBlockerClassification(input: {
     cwd: string;
@@ -412,6 +437,19 @@ export declare function recordUltragoalBlockerClassification(input: {
     evidence: string;
     goalId?: string;
 }): Promise<UltragoalLedgerEvent>;
+export declare function recordUltragoalCriticVerdict(input: {
+    cwd: string;
+    terminus: "completion" | "pause";
+    verdict: CriticVerdict;
+    evidence: string;
+    blockers?: string[];
+    goalId?: string;
+    classificationEventId?: string;
+}): Promise<UltragoalLedgerEvent>;
+export declare function recordUltragoalCriticGateOverride(input: {
+    cwd: string;
+    evidence: string;
+}): Promise<UltragoalLedgerEvent>;
 type UltragoalReviewContractStrength = "strong" | "thin-derived";
 interface UltragoalReviewFinding extends JsonObject {
     severity: "blocker";

package/dist/types/skill-state/workflow-hud.d.ts

@@ -20,6 +20,9 @@ interface RalplanHudState extends WorkflowGateHudState {
     iteration?: number;
     iterationFromIndex?: number;
     stages?: string;
+    architectPasses?: number;
+    criticPasses?: number;
+    reviewPassBudget?: number;
     verdict?: string;
     latestSummary?: string;
     pendingApproval?: boolean;

package/dist/types/ssh/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function sanitizeHostName(name: string): string;
+export declare function validateSshDestination(username: string | undefined, host: string): string | undefined;
 export declare function buildSshTarget(username: string | undefined, host: string): string;

package/dist/types/task/discovery.d.ts

@@ -1,3 +1,4 @@
+import type { Settings } from "../config/settings";
 import type { AgentDefinition } from "./types";
 /** Result of agent discovery */
 export interface DiscoveryResult {
@@ -11,8 +12,9 @@ export declare function filterVisibleAgents(agents: readonly AgentDefinition[]):
  * Precedence (highest wins): .skc project, .skc user, SKC plugins, then bundled
  *
  * @param cwd - Current working directory for project agent discovery
+ * @param activeSettings - Settings used to resolve enabled providers.
  */
-export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;
+export declare function discoverAgents(cwd: string, home?: string, activeSettings?: Settings): Promise<DiscoveryResult>;
 /**
  * Get an agent by name from discovered agents.
  */

package/dist/types/task/executor.d.ts

@@ -20,6 +20,7 @@ import type { ContextFileEntry } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
 import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+import { type ExecutorExecutionMode } from "./ultragoal-redteam-activation";
 export declare function trimForkContextSeedForModel(seed: ForkContextSeed, model: Model | undefined): ForkContextSeed;
 /** Options for subagent execution */
 export interface ExecutorOptions {
@@ -28,6 +29,11 @@ export interface ExecutorOptions {
     agent: AgentDefinition;
     task: string;
     assignment?: string;
+    /**
+     * Typed executor execution mode. When set, overrides assignment-text heuristics
+     * for ultragoal red-team prompt injection (#2698 / #2456).
+     */
+    executionMode?: ExecutorExecutionMode;
     context?: string;
     description?: string;
     index: number;

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

@@ -36,7 +36,9 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
     get description(): string;
     private constructor();
     /**
-     * Create a TaskTool instance with async agent discovery.
+     * Create a TaskTool instance.
+     * Repository authority is captured from session cwd *before* agent discovery so
+     * multi-repo workspaces fail closed prior to context/discovery (#2901).
      */
     static create(session: ToolSession): Promise<TaskTool>;
     execute(_toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;

package/dist/types/task/provider-retry-status.d.ts

@@ -0,0 +1,13 @@
+import type { AgentProgress, TaskToolDetails } from "./types";
+export type ProviderRetryKind = NonNullable<AgentProgress["retryState"]>["kind"];
+export declare function classifyProviderRetry(errorMessage: string): ProviderRetryKind;
+export declare function providerNameFromModel(model: string | undefined): string | undefined;
+export declare function providerRetryPhaseLabel(kind: ProviderRetryKind): string;
+export declare function providerProgressAgeLabel(retryState: NonNullable<AgentProgress["retryState"]>, nowMs: number): string;
+export declare function hasActiveProviderRetryInTaskDetails(details: TaskToolDetails, seen?: WeakSet<object>): boolean;
+export declare function hasActiveProviderRetryInProgress(progress: AgentProgress, seen?: WeakSet<object>): boolean;
+export interface ProviderDegradationGroup {
+    provider: string;
+    count: number;
+}
+export declare function collectProviderDegradationGroups(progress: readonly AgentProgress[]): ProviderDegradationGroup[];