@sayknow-cli/coding-agent 0.3.11 → 0.3.13

package/dist/types/setup/model-onboarding-guidance.d.ts

@@ -1,9 +0,0 @@
-export declare const MODEL_ONBOARDING_API_PROVIDER_COMMAND = "/provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>";
-export declare const MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND = "/provider add --preset <minimax|minimax-cn|glm>";
-export declare const MODEL_ONBOARDING_SETUP_COMMAND = "skc setup provider";
-export declare const MODEL_ONBOARDING_OAUTH_COMMAND = "/provider login [provider-id] or /login [provider-id]";
-export declare function formatModelOnboardingGuidance(): string;
-export declare function formatModelOnboardingInlineHint(): string;
-export declare function formatNoModelOnboardingError(): string;
-export declare function formatNoCredentialOnboardingError(providerId: string): string;
-export declare function formatNoModelsAvailableFallback(): string;

package/dist/types/setup/provider-onboarding.d.ts

@@ -1,52 +0,0 @@
-import { type ModelsConfig } from "../config/models-config-schema";
-export type ProviderCompatibility = "openai" | "anthropic";
-export type ProviderSetupApi = "openai-responses" | "openai-completions" | "anthropic-messages";
-export interface ProviderSetupInput {
-    compatibility?: ProviderCompatibility;
-    preset?: string;
-    providerId?: string;
-    baseUrl?: string;
-    apiKey?: string;
-    apiKeyEnv?: string;
-    models?: string[];
-    modelsPath?: string;
-    force?: boolean;
-}
-export interface ProviderSetupResult {
-    providerId: string;
-    compatibility: ProviderCompatibility;
-    api: ProviderSetupApi;
-    baseUrl: string;
-    modelIds: string[];
-    modelsPath: string;
-    redactedApiKey: string;
-    credentialSource: "literal" | "env";
-    preset?: string;
-    presetName?: string;
-}
-type ProviderConfig = NonNullable<NonNullable<ModelsConfig["providers"]>[string]>;
-type ProviderCompatConfig = NonNullable<ProviderConfig["compat"]>;
-interface ProviderPreset {
-    id: string;
-    aliases: readonly string[];
-    name: string;
-    description: string;
-    compatibility: ProviderCompatibility;
-    api: ProviderSetupApi;
-    providerId: string;
-    baseUrl: string;
-    apiKeyEnv: string;
-    models: readonly string[];
-    compat?: ProviderCompatConfig;
-}
-export declare const PROVIDER_PRESETS: readonly ProviderPreset[];
-export declare function getDefaultModelsPath(): string;
-export declare function normalizeProviderId(providerId: string): string;
-export declare function parseProviderCompatibility(value: string): ProviderCompatibility;
-export declare function findProviderPreset(value: string | undefined): ProviderPreset | undefined;
-export declare function formatProviderPresetList(): string;
-export declare function parseModelList(values: readonly string[]): string[];
-export declare function redactSecret(secret: string): string;
-export declare function addApiCompatibleProvider(input: ProviderSetupInput): Promise<ProviderSetupResult>;
-export declare function formatProviderSetupResult(result: ProviderSetupResult): string;
-export {};

package/dist/types/skc-runtime/cli-write-receipt.d.ts

@@ -1,24 +0,0 @@
-/**
- * CLI write/mutation receipt shaping (Workstream B, v4).
- *
- * `CliWriteReceipt` is the compact **stdout presentation** returned by a SKC
- * mutation command. It carries only routing/audit fields a caller needs; it
- * NEVER echoes the persisted body (full `state` envelope, ultragoal `plan`,
- * team task body, ralplan `task`, etc.) — echoing those back is a redundant
- * token leak because the caller already has the content it just wrote.
- *
- * This is intentionally a *separate* concept from the persisted
- * `WorkflowStateReceipt` (the on-disk envelope `receipt` integrity field).
- * Do NOT use `CliWriteReceipt` as a persistence schema or validate persisted
- * envelopes against it.
- */
-export interface CliWriteReceipt {
-    ok: boolean;
-    [field: string]: unknown;
-}
-/**
- * Serialize a write/mutation receipt to compact stdout JSON.
- * `undefined` fields are dropped so optional routing fields stay absent
- * rather than serialized as `null`.
- */
-export declare function renderCliWriteReceipt(receipt: Record<string, unknown>): string;

package/dist/types/skc-runtime/deep-interview-ambiguity.d.ts

@@ -1,39 +0,0 @@
-import { type DeepInterviewStateEnvelope } from "./deep-interview-state";
-export interface AmbiguityFloorBreakdown {
-    floor: number;
-    disputed_fact_count: number;
-    unscored_active_component_count: number;
-    auto_answer_ratio: number;
-}
-export interface AmbiguityClampResult {
-    effective: number;
-    clamped: boolean;
-}
-/** Compute the deterministic floor from the inner deep-interview `state` object. */
-export declare function computeAmbiguityFloor(inner: unknown): AmbiguityFloorBreakdown;
-/** Clamp an LLM-reported ambiguity to the deterministic floor: `max(reported, floor)`. */
-export declare function clampReportedAmbiguity(reported: number, floor: number): AmbiguityClampResult;
-/**
- * Mark every established fact recorded in `retractedRound` as disputed. This is the
- * mechanical contradiction signal for answer retraction: when the user replaces an
- * already-scored answer (A -> B pivot), the facts that answer established can no
- * longer be trusted, so they raise the floor until re-confirmed or superseded.
- * Returns new arrays/objects; never mutates the input.
- */
-export declare function disputeFactsFromRetractedRound(facts: readonly unknown[], retractedRound: number): {
-    facts: Record<string, unknown>[];
-    disputedIds: string[];
-};
-export interface AppliedAmbiguityFloor {
-    envelope: DeepInterviewStateEnvelope;
-    breakdown: AmbiguityFloorBreakdown;
-    clamped: boolean;
-}
-/**
- * Enforce the floor invariant on a full deep-interview envelope: recompute the floor
- * from persisted evidence, clamp `state.current_ambiguity`, and clamp the latest
- * scored round (preserving the original value as `reported_ambiguity` for audit).
- * Historical rounds are never rewritten. Idempotent and non-mutating; every writer
- * (state CLI write/reconcile, recorder) applies this immediately before persisting.
- */
-export declare function applyAmbiguityFloorToEnvelope(value: unknown): AppliedAmbiguityFloor;

package/dist/types/skc-runtime/deep-interview-recorder.d.ts

@@ -1,114 +0,0 @@
-import { type DeepInterviewEstablishedFact, type DeepInterviewRoundRecord, type DeepInterviewStateEnvelope, type DeepInterviewTriggerMetadata } from "./deep-interview-state";
-export * from "./deep-interview-ambiguity";
-export * from "./deep-interview-state";
-/**
- * Runtime-owned deep-interview round recorder (conflict-aware scoring support).
- *
- * Ownership boundary (per the approved consensus plan): this module owns durable
- * round-record semantics — stable identity, append-or-merge, lifecycle, compact
- * reads, replay detection, and the pure scored-transition validator. Callers such
- * as the `ask` tool only resolve an answer and invoke these helpers; they never
- * compute state paths, merge records, or write `.skc` files directly. All writes
- * go through the sanctioned state-writer (`writeWorkflowEnvelopeAtomic`).
- */
-export interface DeepInterviewAnswerInput {
-    interviewId?: string;
-    round: number;
-    round_id?: string;
-    questionId?: string;
-    questionText: string;
-    component?: string;
-    dimension?: string;
-    ambiguity?: number;
-    selectedOptions?: string[];
-    customInput?: string;
-}
-export interface DeepInterviewScoringInput {
-    interviewId?: string;
-    round: number;
-    round_id?: string;
-    questionId?: string;
-    scores: Record<string, number>;
-    ambiguity: number;
-    triggers?: DeepInterviewTriggerMetadata[];
-}
-export type AppendOrMergeAction = "created" | "noop" | "replaced";
-export interface AppendOrMergeResult {
-    rounds: DeepInterviewRoundRecord[];
-    action: AppendOrMergeAction;
-    record: DeepInterviewRoundRecord;
-}
-export interface DeepInterviewCompactState {
-    threshold?: number;
-    threshold_source?: string;
-    current_ambiguity?: number;
-    topology_summary?: {
-        active: number;
-        deferred: number;
-        components: string[];
-    };
-    established_facts: DeepInterviewEstablishedFact[];
-    unresolved_triggers: DeepInterviewTriggerMetadata[];
-    recent_scored_rounds: DeepInterviewRoundRecord[];
-    pending_shells: DeepInterviewRoundRecord[];
-}
-export interface TransitionValidationResult {
-    ok: boolean;
-    violations: string[];
-}
-export declare function buildAnswerShell(input: DeepInterviewAnswerInput, now?: string): DeepInterviewRoundRecord;
-/**
- * Append-or-merge by `round_key`. Exactly one record per key:
- * - no existing record -> append (`created`);
- * - identical question_hash + answer_hash -> deterministic no-op (`noop`);
- * - same key, different hashes -> deterministic replacement of the prior shell
- *   (`replaced`); the prior answer for that key is superseded and lifecycle resets.
- */
-export declare function appendOrMergeRound(rounds: readonly DeepInterviewRoundRecord[], shell: DeepInterviewRoundRecord): AppendOrMergeResult;
-/**
- * Merge scoring output into the existing record for the derived key, transitioning
- * it to `scored`. Never appends a second record for the same key; if no shell exists
- * yet (scoring without a prior ask), a scored record is created so data is not lost.
- */
-export declare function enrichRoundWithScoring(rounds: readonly DeepInterviewRoundRecord[], input: DeepInterviewScoringInput, now?: string): {
-    rounds: DeepInterviewRoundRecord[];
-    record: DeepInterviewRoundRecord;
-};
-/**
- * Bidirectional invariant: if `next` carries an `active` trigger, the affected
- * dimension must not improve and overall ambiguity must rise vs the prior scored
- * round. `disputed`/`unresolved` triggers are exempt but must carry a rationale.
- */
-export declare function validateDeepInterviewScoredTransition(prior: DeepInterviewRoundRecord | undefined, next: DeepInterviewRoundRecord): TransitionValidationResult;
-/** Back-compat wrapper: normalize a deep-interview envelope to its canonical nested shape. */
-export declare function ensureDeepInterviewStateShape(value: unknown): DeepInterviewStateEnvelope;
-export declare function projectCompactState(value: unknown, options?: {
-    lastN?: number;
-}): DeepInterviewCompactState;
-/** Refresh the best-effort HUD cache from persisted deep-interview state. */
-export declare function syncDeepInterviewRecorderHud(cwd: string, statePath: string, sessionId: string | undefined): Promise<void>;
-/**
- * Record an `answered` shell for one round (append-or-merge by durable key).
- *
- * Retraction dynamics: replacing an already-`scored` answer is a mechanical
- * contradiction signal (the user pivoted). The facts that round established are
- * marked disputed, which raises the deterministic ambiguity floor immediately —
- * without waiting for the LLM scorer to self-report a trigger.
- */
-export declare function appendOrMergeDeepInterviewRound(cwd: string, statePath: string, input: DeepInterviewAnswerInput, options?: {
-    sessionId?: string;
-}): Promise<{
-    action: AppendOrMergeAction;
-    record: DeepInterviewRoundRecord;
-    disputedFactIds?: string[];
-}>;
-/** Merge scoring output into the same round record, transitioning to `scored`. */
-export declare function enrichDeepInterviewRoundScoring(cwd: string, statePath: string, input: DeepInterviewScoringInput, options?: {
-    sessionId?: string;
-}): Promise<{
-    record: DeepInterviewRoundRecord;
-}>;
-/** Compact projection so callers read a slice instead of the full transcript. */
-export declare function readDeepInterviewStateCompact(statePath: string, options?: {
-    lastN?: number;
-}): Promise<DeepInterviewCompactState>;

package/dist/types/skc-runtime/deep-interview-runtime.d.ts

@@ -1,36 +0,0 @@
-export * from "./deep-interview-recorder";
-/**
- * Native implementation of `skc deep-interview`.
- *
- * The CLI itself does not run the Socratic interview; that lives inside the `/skill:deep-interview`
- * skill executed by the agent. This handler validates the documented argument-hint surface
- * (`[--quick|--standard|--deep] <idea>`), seeds `.skc/state/deep-interview-state.json`, and
- * updates the shared HUD rail via `syncSkillActiveState` so the active interview is visible to
- * the TUI.
- */
-export interface DeepInterviewCommandResult {
-    status: number;
-    stdout?: string;
-    stderr?: string;
-}
-export declare function deepInterviewStatePath(cwd: string, sessionId?: string): string;
-export interface ResolvedDeepInterviewSpecWriteArgs {
-    stage: "final";
-    slug: string;
-    spec: string;
-    sessionId: string;
-    json: boolean;
-    deliberate: boolean;
-    handoff?: "ralplan";
-    force: boolean;
-}
-export interface PersistedDeepInterviewSpec {
-    slug: string;
-    path: string;
-    stage: "final";
-    sha256: string;
-    createdAt: string;
-    statePath: string;
-}
-export declare function persistDeepInterviewSpec(cwd: string, resolved: ResolvedDeepInterviewSpecWriteArgs): Promise<PersistedDeepInterviewSpec>;
-export declare function runNativeDeepInterviewCommand(args: string[], cwd?: string): Promise<DeepInterviewCommandResult>;

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

@@ -1,127 +0,0 @@
-/**
- * Pure, dependency-free foundation for deep-interview state shape.
- *
- * Ownership boundary (per the approved consensus plan): this leaf module owns the
- * canonical persisted shape (interview data nested under `state`), durable round
- * identity/hashing, lossless legacy normalization, and the deep-interview-specific
- * envelope/round merge used by every writer (`deep-interview-recorder`,
- * `state-runtime` write/reconcile, seed, and handoff). It MUST NOT import the
- * active-state, state-writer, CLI runtime, or filesystem so it stays cycle-free and
- * trivially testable.
- */
-export type DeepInterviewRoundLifecycle = "answered" | "pending_scoring" | "scored";
-export type DeepInterviewTriggerKind = "A" | "B" | "C" | "D";
-/** `active` triggers must satisfy the bidirectional invariant; disputed/unresolved are exempt with rationale. */
-export type DeepInterviewTriggerStatus = "active" | "disputed" | "unresolved";
-export interface DeepInterviewEstablishedFact {
-    id: string;
-    statement: string;
-    round: number;
-    component?: string;
-    dimension?: string;
-    evidence?: string;
-    disputed: boolean;
-    /**
-     * Resolution pointer for a disputed fact: the id of the fact that replaced it
-     * after the user confirmed a pivot. A disputed fact without `superseded_by`
-     * keeps the deterministic ambiguity floor elevated; setting it releases the
-     * pressure while preserving the contradicted fact for audit.
-     */
-    superseded_by?: string;
-}
-export interface DeepInterviewTriggerMetadata {
-    kind: DeepInterviewTriggerKind;
-    name: string;
-    status: DeepInterviewTriggerStatus;
-    component: string;
-    dimension: string;
-    priorDimensionScore?: number;
-    newDimensionScore?: number;
-    priorAmbiguity?: number;
-    newAmbiguity?: number;
-    evidence?: string;
-    contradictedFactId?: string;
-    /** Required when status is `disputed` or `unresolved` to exempt the invariant. */
-    rationale?: string;
-}
-export interface DeepInterviewRoundRecord {
-    round_key: string;
-    round_id?: string;
-    round: number;
-    question_id?: string;
-    question_text?: string;
-    question_hash: string;
-    answer_hash: string;
-    selected_options?: string[];
-    custom_input?: string;
-    component?: string;
-    dimension?: string;
-    ambiguity_at_ask?: number;
-    lifecycle: DeepInterviewRoundLifecycle;
-    answered_at: string;
-    scored_at?: string;
-    scores?: Record<string, number>;
-    /** Effective ambiguity after the deterministic floor clamp (`max(reported, floor)`). */
-    ambiguity?: number;
-    /** Original LLM-reported ambiguity, preserved for audit when the floor clamped it. */
-    reported_ambiguity?: number;
-    /** Deterministic floor in effect when this round was scored, when it clamped. */
-    ambiguity_floor?: number;
-    triggers?: DeepInterviewTriggerMetadata[];
-}
-export interface DeepInterviewStateEnvelope {
-    threshold?: number;
-    threshold_source?: string;
-    state?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export declare function hashContent(value: string): string;
-export declare function questionHash(questionText: string): string;
-export declare function answerHash(selectedOptions: string[] | undefined, customInput: string | undefined): string;
-/**
- * Durable round identity. Prefer `interview_id + round_id`; fall back to
- * `interview_id + round + question.id` when no caller-supplied `round_id` exists.
- */
-export declare function deriveRoundKey(interviewId: string | undefined, input: {
-    round_id?: string;
-    round: number;
-    questionId?: string;
-}): string;
-/**
- * Canonicalize a deep-interview envelope: interview data nested under `state`,
- * legacy flattened fields hoisted in losslessly, transcript duplicates removed
- * from the top level, and `rounds`/`established_facts` guaranteed to be arrays.
- *
- * Idempotent: a canonical envelope is returned unchanged in shape. Preserves all
- * unknown envelope and nested fields except the envelope-reserved keys that leak
- * into `state` (see `ENVELOPE_RESERVED_STATE_KEYS`), which are stripped so a
- * malformed envelope-in-state write cannot permanently nest state. Never mutates
- * the input.
- */
-export declare function normalizeDeepInterviewEnvelope(value: unknown): DeepInterviewStateEnvelope;
-/**
- * Lossless, idempotent merge of two round arrays.
- *
- * - Records sharing a durable key (`round_key`, or synthesized from
- *   `round_id`/`question_id`) merge into one, preferring scored over answered.
- * - Records without any durable identity are preserved verbatim; an exact
- *   duplicate is skipped so repeated writes stay idempotent, but distinct records
- *   are never collapsed.
- *
- * Deliberate refinement of the approved plan: rather than mutating opaque legacy
- * records with synthetic `legacy:<index>` keys, they are preserved verbatim with
- * exact-duplicate dedupe. This satisfies the plan's intent (lossless, idempotent,
- * never collapse distinct rounds) without rewriting user-supplied round objects,
- * and keeps free-form extension preservation intact. Recorder-produced records
- * always carry a `round_key`, so the synthetic path is unnecessary in practice.
- */
-export declare function mergeDeepInterviewRounds(existing: readonly Record<string, unknown>[], incoming: readonly Record<string, unknown>[]): Record<string, unknown>[];
-/**
- * Deep-interview-specific envelope merge. Unlike the generic shallow null-delete
- * merge, this keeps interview data nested under `state`, never deletes `state`,
- * and merges `rounds` losslessly by durable key so a partial write (e.g. a
- * scoring update) cannot drop recorder-written transcript history.
- */
-export declare function mergeDeepInterviewEnvelope(existing: unknown, incoming: unknown, options?: {
-    replace?: boolean;
-}): DeepInterviewStateEnvelope;

package/dist/types/skc-runtime/gc-render.d.ts

@@ -1,6 +0,0 @@
-/**
- * Text rendering for `skc gc` reports. JSON output is produced directly in
- * `gc-runtime.ts`; this module owns the human-readable grouped report.
- */
-import type { GcReport } from "./gc-runtime";
-export declare function buildGcReportText(report: GcReport): string;

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

@@ -1,134 +0,0 @@
-/**
- * `skc gc` runtime — a global, liveness-only, dry-run-by-default garbage
- * collector for stale SKC session/PID records.
- *
- * Design (see .skc/plans/ralplan/2026-06-13-1347-954f/pending-approval.md):
- * - This module is an ORCHESTRATOR only. It owns the shared PID probe, the
- *   report/exit-code policy, and text/JSON rendering. It must NOT parse private
- *   store layouts directly; every store is reached through an injectable
- *   `GcStoreAdapter` that lives next to its store owner.
- * - Liveness-only and fail-closed: only `ESRCH` (no such process) is `dead`
- *   (removable). `process.kill(pid, 0)` success, `EPERM`, and any unknown probe
- *   error all mean KEEP — a live process is never signalled or killed.
- * - Dry-run by default: nothing is deleted unless `--prune`/`--force`.
- */
-export type GcStore = "harness_leases" | "team_workers" | "file_locks" | "tmux_sessions" | "registry_entries";
-export declare const GC_STORES: readonly GcStore[];
-/** Why a probed pid is kept instead of treated as dead. */
-export type GcPidKeepReason = "alive" | "eperm" | "unknown";
-export interface GcPidProbeResult {
-    /** `dead` only on ESRCH; `keep` for alive/eperm/unknown (fail-closed). */
-    status: "dead" | "keep";
-    reason?: GcPidKeepReason;
-    error?: string;
-}
-/** Single shared liveness contract threaded through every classifier + prune path. */
-export type GcPidProbe = (pid: number) => GcPidProbeResult;
-export type GcPidStatus = "dead" | "alive" | "eperm" | "unknown" | "none";
-export type GcAction = "none" | "would_remove" | "removed" | "remove_failed" | "skipped";
-export interface GcRecord {
-    store: GcStore;
-    /** Stable identifier: session id, lock dir path, worker id, tmux name, registry session id. */
-    id: string;
-    path?: string;
-    root?: string;
-    pid?: number;
-    pid_status?: GcPidStatus;
-    /** Store-specific classification label (e.g. "dead", "live", "unclassified", "terminal_lifecycle"). */
-    status: string;
-    stale: boolean;
-    removable: boolean;
-    action: GcAction;
-    reason: string;
-    detail?: string;
-    error?: string;
-    removed?: boolean;
-}
-export interface GcError {
-    store: GcStore;
-    scope: string;
-    message: string;
-}
-export interface GcCollectResult {
-    records: GcRecord[];
-    errors: GcError[];
-}
-export interface GcPruneOutcome {
-    removed: boolean;
-    error?: string;
-    /** Set when a removable record was skipped at prune time (e.g. TOCTOU became live). */
-    skipped?: string;
-}
-export interface GcContext {
-    probe: GcPidProbe;
-    force: boolean;
-    env: NodeJS.ProcessEnv;
-    cwd: string;
-}
-/**
- * A store-owned GC adapter. `collect` discovers + classifies (using the shared
- * probe) without mutating anything. `prune` removes a single record, and MUST
- * re-validate / re-probe immediately before any destructive action.
- */
-export interface GcStoreAdapter {
-    store: GcStore;
-    collect(ctx: GcContext): Promise<GcCollectResult>;
-    prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome>;
-}
-export interface GcCounts {
-    discovered: number;
-    stale: number;
-    alive: number;
-    eperm: number;
-    unknown: number;
-    terminal_lifecycle: number;
-    unclassified: number;
-    would_remove: number;
-    removed: number;
-    failed: number;
-    errors: number;
-    by_store: Record<GcStore, {
-        discovered: number;
-        stale: number;
-        would_remove: number;
-        removed: number;
-        failed: number;
-    }>;
-}
-export interface GcReport {
-    dry_run: boolean;
-    stores: Record<GcStore, GcRecord[]>;
-    counts: GcCounts;
-    errors: GcError[];
-}
-export interface GcRunResult {
-    stdout: string;
-    stderr: string;
-    status: number;
-}
-/**
- * The shared, fail-closed PID probe. ESRCH => dead/removable; success => alive;
- * EPERM => kept (owned by another user); any other error => kept as unknown.
- */
-export declare const gcPidProbe: GcPidProbe;
-/** Map a `GcPidProbe` onto the harness lease probe shape (`"alive"|"dead"|"eperm"`). */
-export declare function gcProbeToLeasePidStatus(probe: GcPidProbe): (pid: number) => "alive" | "dead" | "eperm";
-/** Translate a probe result into a record-friendly pid status label. */
-export declare function gcPidStatusLabel(result: GcPidProbeResult): Exclude<GcPidStatus, "none">;
-/**
- * Collect every store's records (catching hard discovery errors per adapter),
- * then optionally prune removable records with per-record revalidation.
- */
-export declare function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext, prune: boolean): Promise<GcReport>;
-/**
- * Exit-code policy:
- * - usage/parse error => 2
- * - hard discovery errors => 1 (both modes)
- * - prune mode with a failed intended removal => 1
- * - otherwise => 0
- */
-export declare function computeExitCode(report: GcReport): number;
-export declare function runSkcGcCommand(argv: string[], cwd?: string, env?: NodeJS.ProcessEnv, adapters?: GcStoreAdapter[]): Promise<GcRunResult>;
-export declare function gcHelpText(): string;
-/** Lazily assemble the real store adapters (kept lazy to avoid import cycles). */
-export declare function defaultGcAdapters(): Promise<GcStoreAdapter[]>;

package/dist/types/skc-runtime/goal-mode-request.d.ts

@@ -1,53 +0,0 @@
-import { type Goal } from "../goals/state";
-export declare const SKC_SESSION_FILE_ENV = "SKC_SESSION_FILE";
-export declare const SKC_SESSION_ID_ENV = "SKC_SESSION_ID";
-export declare const SKC_SESSION_CWD_ENV = "SKC_SESSION_CWD";
-declare const REQUEST_VERSION = 1;
-export declare const DEFAULT_ULTRAGOAL_OBJECTIVE = "Complete the durable ultragoal plan in .skc/ultragoal/goals.json, including later accepted/appended stories, under the original brief constraints; use .skc/ultragoal/ledger.jsonl as the audit trail.";
-export interface PendingGoalModeRequest {
-    version: typeof REQUEST_VERSION;
-    kind: "goal_mode_request";
-    source: "ultragoal";
-    objective: string;
-    createdAt: string;
-    goalsPath?: string;
-    /**
-     * Session id that produced this request (from SKC_SESSION_ID). When present,
-     * only the originating session may consume it, so concurrent sessions sharing
-     * the same `.skc` project state never auto-run each other's ultragoal.
-     */
-    sessionId?: string;
-}
-export type CurrentSessionGoalModeWriteResult = {
-    status: "unavailable";
-    reason: "missing_session_file" | "empty_session_file";
-} | {
-    status: "existing_goal";
-    goal: Goal;
-} | {
-    status: "updated";
-    goal: Goal;
-    sessionFile: string;
-};
-export declare function isUltragoalCreateGoalsInvocation(args: readonly string[]): boolean;
-export declare function readUltragoalSkcObjective(cwd: string, sessionId?: string | null): Promise<{
-    objective: string;
-    goalsPath: string;
-}>;
-export declare function writePendingGoalModeRequest(input: {
-    cwd: string;
-    objective: string;
-    goalsPath?: string;
-    sessionId?: string | null;
-}): Promise<PendingGoalModeRequest>;
-export declare function writeCurrentSessionGoalModeState(input: {
-    sessionFile?: string | null;
-    objective: string;
-}): Promise<CurrentSessionGoalModeWriteResult>;
-export declare function consumePendingGoalModeRequest(cwd: string, currentSessionId?: string | null): Promise<PendingGoalModeRequest | null>;
-export declare function buildSkcRuntimeSessionEnv(input: {
-    sessionFile?: string | null;
-    sessionId?: string | null;
-    cwd?: string | null;
-}): Record<string, string>;
-export {};