@gajae-code/coding-agent 0.2.4 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-06-03
+
+### Added
+
+- Added runtime-enforced Ultragoal executor QA/red-team evidence matrices for completion checkpoints, with plan-first contract coverage, user-surface evidence, adversarial cases, artifact references, scoped Executor red-team guidance, and focused rejection tests for shallow or contradictory QA evidence.
+### Fixed
+
+- Clarified that `gjc team` requires an existing tmux-backed leader session from `gjc --tmux`, with actionable help, docs, and failure text.
+- Kept deep-interview ask options visible for long prompts by adding an opt-in scrollable selector title panel with selector-local `PageUp`/`PageDown` prompt scrolling, while leaving normal ask dialogs and global keybinding configuration unchanged.
+
+## [0.2.5] - 2026-06-02
+
+### Added
+
+- Added Claude Code parity `monitor` plus `CronCreate`, `CronList`, and `CronDelete` tools with frozen upstream schema fixtures, inline scheduling, background output monitoring, and ACP permission coverage.
+
+### Changed
+
+- Pruned bundled built-in themes to `red-claw` and `blue-crab`, with `blue-crab` now the default light-appearance theme.
+- Clarified ralplan role-agent handoff guidance so Planner/Architect/Critic return compact artifact receipts after `gjc ralplan --write --json` instead of duplicating full persisted verdict markdown into the parent context.
+- Made `web_search` permissionless by default with a keyless DuckDuckGo fallback, active-model-gated native provider selection, and explicit-only legacy provider selection so custom providers no longer auto-hit stray OpenAI/Codex OAuth credentials.
+
+### Fixed
+
+- Fixed the skill HUD rail showing already-handed-off planning workflows so it renders only the currently-active stage. Handoffs now supersede every same-session-scope row of the caller and callee skills (not just the exact `skill::session_id` key), the visible-state read collapses duplicate same-skill rows to the most-recent one (so a handoff demotion drops a stale `active:true` row and on-disk state self-heals), and the HUD renderer collapses the `deep-interview → ralplan → ultragoal` pipeline to its most-recent stage. Activating a later stage (e.g. `gjc ultragoal` after ralplan) now supersedes the earlier one even when the activation path does not run the `handoff` verb, while `team` still coexists with ultragoal.
+
 ## [0.2.4] - 2026-06-02
 
 ### Added
@@ -40,6 +66,7 @@
 ### Fixed
 
 - Enforced the deep-interview phase boundary so active interviews block mutation tools until a handoff/spec is produced.
+- Allowed read-only `architect`, `planner`, and `critic` role agents to persist ralplan/state workflow receipts through a restricted `bash` allowlist while blocking general shell and product-file mutations.
 - Made settings theme browsing confirm-only so arrowing through themes no longer changes the rendered theme before the displayed/persisted theme name changes.
 - Made startup CHANGELOG display deterministic by embedding `packages/coding-agent/CHANGELOG.md` into the binary so post-update launches show the shipped history regardless of cwd or `GJC_PACKAGE_DIR`/`PI_PACKAGE_DIR` overrides.
 - Registered `gjc update` as a public root subcommand so it invokes the bundled updater instead of routing into the interactive launcher.

package/README.md

@@ -34,4 +34,4 @@ Switching backends mid-session is honoured on the next system-prompt rebuild and
 
 ## Red-claw TUI theme
 
-The interactive TUI defaults to the bundled `red-claw` crustacean theme for dark terminals, with matching welcome/icon assets. Explicit user theme settings still win; set `theme.dark: red-claw` in `~/.gjc/agent/config.yml` to pin it.
+The interactive TUI defaults to the bundled `red-claw` crustacean theme for dark terminals and the bundled `blue-crab` theme for light-appearance terminals, with matching welcome/icon assets. Explicit user theme settings still win; set `theme.dark: red-claw` and `theme.light: blue-crab` in `~/.gjc/agent/config.yml` to pin them.

package/dist/types/async/job-manager.d.ts

@@ -2,7 +2,7 @@ import type { AgentSource } from "../task/types";
 export interface AsyncJob {
     id: string;
     type: "bash" | "task";
-    status: "running" | "completed" | "failed" | "cancelled";
+    status: "running" | "completed" | "failed" | "cancelled" | "paused";
     startTime: number;
     label: string;
     abortController: AbortController;
@@ -27,6 +27,61 @@ export interface AsyncJobMetadata {
         assignment?: string;
     };
 }
+/**
+ * Typed outcome a subagent task run may produce. A `paused` outcome is
+ * non-terminal and non-delivering: the run suspended at a safe boundary and the
+ * subagent can be resumed from its persisted sessionFile. `completed` always
+ * wins a race with a late pause because the run returns it once it has actually
+ * finished.
+ */
+export type SubagentRunOutcome = {
+    kind: "completed";
+    text: string;
+} | {
+    kind: "paused";
+    note?: string;
+};
+/** Canonical lifecycle of a subagent across pause/resume cycles. */
+export type SubagentLifecycle = "running" | "paused" | "queued" | "completed" | "failed" | "cancelled";
+/**
+ * Live, executor-owned control handle for a RUNNING subagent. Registered when a
+ * subagent run starts and removed on pause/terminal so a paused subagent retains
+ * no live `AgentSession` reference (leak-free).
+ */
+export interface SubagentLiveHandle {
+    /** Request a cooperative safe-boundary pause (never aborts the in-flight tool). */
+    requestPause(): void;
+    /** Inject a steering message into the live session. */
+    injectMessage(content: string, deliverAs: "steer" | "followUp" | "nextTurn"): Promise<void>;
+}
+/**
+ * Canonical, stable-id-keyed record for a subagent. Survives `AsyncJob`
+ * eviction so resume stays addressable by subagent id, and is the single source
+ * of truth for control-plane status and identity.
+ */
+export interface SubagentRecord {
+    subagentId: string;
+    ownerId?: string;
+    /** Current live/last AsyncJob id; null while queued with no active job. */
+    currentJobId: string | null;
+    historicalJobIds: string[];
+    status: SubagentLifecycle;
+    sessionFile: string | null;
+    /** False for ephemeral sessions (no persistent artifacts dir). */
+    resumable: boolean;
+    queued?: {
+        ownerId?: string;
+        seq: number;
+        message?: string;
+        createdAt: number;
+    };
+}
+/** Lightweight, manager-owned resume payload. The async layer treats `data` as opaque. */
+export interface ResumeDescriptor {
+    subagentId: string;
+    ownerId?: string;
+    data: unknown;
+}
 export interface AsyncJobManagerOptions {
     onJobComplete: (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
     maxRunningJobs?: number;
@@ -54,6 +109,27 @@ export interface AsyncJobRegisterOptions {
 export interface AsyncJobFilter {
     ownerId?: string;
 }
+/**
+ * A slice of process-stream output for a background job, as recorded by
+ * `appendOutput` / read by `readOutputSince`.
+ *
+ * The cursor model is monotonic UTF-8 byte offsets. `nextOffset` is the offset
+ * to pass to the next read to receive only fresh bytes; `startOffset` is the
+ * first byte the manager still retains for this job. When the requested offset
+ * is older than `startOffset`, the manager returns the retained tail and sets
+ * `truncated: true`.
+ */
+export interface AsyncJobOutputSlice {
+    jobId: string;
+    status: AsyncJob["status"];
+    text: string;
+    startOffset: number;
+    nextOffset: number;
+    truncated: boolean;
+}
+/** Default retention cap for per-job captured output. ~512 KiB matches the
+ *  bash tail-buffer order of magnitude without dominating session memory. */
+export declare const DEFAULT_JOB_OUTPUT_RETENTION_BYTES: number;
 export declare class AsyncJobManager {
     #private;
     /** Process-global instance shared by internal URL protocol handlers and tools. */
@@ -67,17 +143,84 @@ export declare class AsyncJobManager {
         jobId: string;
         signal: AbortSignal;
         reportProgress: (text: string, details?: Record<string, unknown>) => Promise<void>;
-    }) => Promise<string>, options?: AsyncJobRegisterOptions): string;
+    }) => Promise<string | SubagentRunOutcome>, options?: AsyncJobRegisterOptions): string;
     /**
      * Cancel a single job by id. When `filter.ownerId` is set and does not
      * match the job's owner, the call is treated as not-found (returns false)
      * so cross-agent cancellation is rejected at the manager level.
      */
     cancel(id: string, filter?: AsyncJobFilter): boolean;
+    /** Register or replace the canonical record for a subagent. */
+    registerSubagentRecord(record: SubagentRecord): void;
+    getSubagentRecord(subagentId: string, filter?: AsyncJobFilter): SubagentRecord | undefined;
+    getSubagentRecords(filter?: AsyncJobFilter): SubagentRecord[];
+    registerLiveHandle(subagentId: string, handle: SubagentLiveHandle): void;
+    getLiveHandle(subagentId: string): SubagentLiveHandle | undefined;
+    removeLiveHandle(subagentId: string): void;
+    /** Install the TaskTool-owned resume runner. Returns the new job id, or undefined on failure. */
+    setResumeRunner(runner: (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined): void;
+    registerResumeDescriptor(descriptor: ResumeDescriptor): void;
+    getResumeDescriptor(subagentId: string, filter?: AsyncJobFilter): ResumeDescriptor | undefined;
+    /** Request a graceful safe-boundary pause of a running subagent. */
+    pauseSubagent(subagentId: string, filter?: AsyncJobFilter): {
+        ok: boolean;
+        status?: SubagentLifecycle;
+        reason?: string;
+    };
+    /** Resume a non-running subagent from its sessionFile, optionally injecting a message first. */
+    resumeSubagent(subagentId: string, filter?: AsyncJobFilter, message?: string): {
+        ok: boolean;
+        status?: SubagentLifecycle;
+        jobId?: string;
+        queued?: boolean;
+        reason?: string;
+    };
+    /** Cancel a subagent by stable id across running/paused/queued states (keeps the session file). */
+    cancelSubagent(subagentId: string, filter?: AsyncJobFilter): boolean;
     getJob(id: string): AsyncJob | undefined;
     getRunningJobs(filter?: AsyncJobFilter): AsyncJob[];
     getRecentJobs(limit?: number, filter?: AsyncJobFilter): AsyncJob[];
     getAllJobs(filter?: AsyncJobFilter): AsyncJob[];
+    /**
+     * Append a sanitized process-stream chunk for a background job. Called from
+     * the unthrottled bash-executor capture hook (`onRawChunk`) so monitor sees
+     * every chunk even when preview/progress callbacks are throttled.
+     *
+     * Offsets are in UTF-8 bytes. Storing chunk metadata avoids unsafe byte
+     * slicing across multibyte characters at read time. The retention window is
+     * a per-job rolling cap (`DEFAULT_JOB_OUTPUT_RETENTION_BYTES`); when it
+     * overflows, oldest whole chunks are evicted and `startOffset` advances —
+     * subsequent reads from a stale offset get `truncated: true`.
+     */
+    appendOutput(jobId: string, chunk: string): void;
+    /**
+     * Read fresh process-stream output for a job since `offset` (in UTF-8
+     * bytes). Returns `undefined` when the job does not exist or when an
+     * `ownerId` filter is set and the job belongs to a different owner — this
+     * mirrors the manager-level "not found" pattern used by `cancel`.
+     *
+     * - `offset < startOffset` returns the retained tail with `truncated: true`.
+     * - `offset > nextOffset` clamps to `nextOffset` and returns an empty text
+     *   slice with `truncated: false`.
+     * - Assembled text slices the leading retained chunk at a UTF-8 codepoint
+     *   boundary when needed, so multibyte characters cannot be split.
+     */
+    readOutputSince(jobId: string, offset: number, filter?: AsyncJobFilter): AsyncJobOutputSlice | undefined;
+    /**
+     * Register an owner-scoped cleanup callback. Returns an unregister function.
+     *
+     * Used by Cron* tools to clear session-scoped timers when the owning agent
+     * is torn down. Invoked by `runOwnerCleanups({ ownerId })` before
+     * `cancelAll({ ownerId })` so timers cannot register new jobs during
+     * teardown.
+     */
+    registerOwnerCleanup(ownerId: string, cleanup: () => void): () => void;
+    /**
+     * Run and clear every registered cleanup for the given filter. Idempotent
+     * and error-isolated: a throwing cleanup does not prevent siblings from
+     * running and never escalates to the caller.
+     */
+    runOwnerCleanups(filter?: AsyncJobFilter): void;
     getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState;
     hasPendingDeliveries(filter?: AsyncJobFilter): boolean;
     watchJobs(jobIds: string[]): number;

package/dist/types/commands/harness.d.ts

@@ -0,0 +1,37 @@
+import { Command } from "@gajae-code/utils/cli";
+export default class Harness extends Command {
+    #private;
+    static description: string;
+    static strict: boolean;
+    static args: {
+        verb: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: true;
+        };
+    };
+    static flags: {
+        input: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            default: string;
+        };
+        session: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+        };
+        cursor: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            default: string;
+        };
+        follow: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/types/config/settings-schema.d.ts

@@ -74,6 +74,7 @@ interface StringDef {
 interface NumberDef {
     type: "number";
     default: number;
+    validate?: (value: number) => boolean;
     ui?: UiNumber;
 }
 interface EnumDef<T extends readonly string[]> {
@@ -200,6 +201,11 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "array";
         readonly default: string[];
     };
+    readonly "gjc.deepInterview.ambiguityThreshold": {
+        readonly type: "number";
+        readonly default: 0.05;
+        readonly validate: (value: number) => boolean;
+    };
     readonly "theme.dark": {
         readonly type: "string";
         readonly default: "red-claw";
@@ -212,7 +218,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "theme.light": {
         readonly type: "string";
-        readonly default: "light";
+        readonly default: "blue-crab";
         readonly ui: {
             readonly tab: "appearance";
             readonly label: "Light Theme";
@@ -2917,7 +2923,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "providers.webSearch": {
         readonly type: "enum";
-        readonly values: readonly ["auto", "exa", "brave", "jina", "kimi", "zai", "perplexity", "anthropic", "gemini", "codex", "tavily", "kagi", "synthetic", "parallel", "searxng"];
+        readonly values: readonly ["auto", "duckduckgo", "exa", "brave", "jina", "kimi", "zai", "perplexity", "anthropic", "gemini", "codex", "tavily", "kagi", "synthetic", "parallel", "searxng"];
         readonly default: "auto";
         readonly ui: {
             readonly tab: "providers";
@@ -2926,7 +2932,11 @@ export declare const SETTINGS_SCHEMA: {
             readonly options: readonly [{
                 readonly value: "auto";
                 readonly label: "Auto";
-                readonly description: "Preferred web-search provider";
+                readonly description: "Active model's native search if its creds exist, else keyless DuckDuckGo";
+            }, {
+                readonly value: "duckduckgo";
+                readonly label: "DuckDuckGo";
+                readonly description: "Keyless default \u2014 no API key or OAuth required";
             }, {
                 readonly value: "exa";
                 readonly label: "Exa";

package/dist/types/config/settings.d.ts

@@ -5,7 +5,7 @@
  *   import { settings } from "./settings";
  *
  *   const enabled = settings.get("compaction.enabled");  // sync read
- *   settings.set("theme.dark", "titanium");               // sync write, saves in background
+ *   settings.set("theme.dark", "red-claw");              // sync write, saves in background
  *
  * For tests:
  *   const isolated = Settings.isolated({ "compaction.enabled": false });
@@ -54,6 +54,8 @@ export declare class Settings {
      * Returns the merged value from global + project + overrides, or the default.
      */
     get<P extends SettingPath>(path: P): SettingValue<P>;
+    /** Check whether a setting is present in loaded settings/overrides rather than coming from schema defaults. */
+    has(path: SettingPath): boolean;
     /**
      * Set a setting value (sync).
      * Updates global settings and queues a background save.

package/dist/types/deep-interview/render-middleware.d.ts

@@ -0,0 +1,5 @@
+import { type Component } from "@gajae-code/tui";
+import { type Theme } from "../modes/theme/theme";
+export declare function renderDeepInterviewAssistantText(text: string, uiTheme: Theme): Component | null;
+export declare function renderDeepInterviewAskQuestion(question: string, uiTheme: Theme): Component | null;
+export declare function formatDeepInterviewSelectorPrompt(question: string): string | null;

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

@@ -106,6 +106,7 @@ export interface ParsedAgentFields {
     blocking?: boolean;
     hide?: boolean;
     forkContext?: ForkContextPolicy;
+    bashAllowedPrefixes?: string[];
 }
 /**
  * Parse agent fields from frontmatter.

package/dist/types/exec/bash-executor.d.ts

@@ -2,8 +2,15 @@ import { type MinimizerOptions } from "@gajae-code/natives";
 import { type ShellMinimizerSettings } from "../config/settings";
 export interface BashExecutorOptions {
     cwd?: string;
-    timeout?: number;
+    timeout?: number | null;
     onChunk?: (chunk: string) => void;
+    /**
+     * Unthrottled per-chunk callback that fires for every sanitized stdout/stderr
+     * chunk *before* preview throttling. Background-job substrate uses this to
+     * record the complete process stream for the Monitor tool while keeping
+     * `onChunk` cheap for UI/progress rendering.
+     */
+    onRawChunk?: (chunk: string) => void;
     signal?: AbortSignal;
     /** Session key suffix to isolate shell sessions per agent */
     sessionKey?: string;

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -98,6 +98,7 @@ export type CustomToolSessionEvent = {
     maxAttempts: number;
     delayMs: number;
     errorMessage: string;
+    unbounded?: boolean;
 } | {
     reason: "auto_retry_end";
     success: boolean;

package/dist/types/extensibility/extensions/types.d.ts

@@ -56,6 +56,12 @@ export interface ExtensionUIDialogOptions {
      * hint; non-TUI bridges (RPC, ACP) drop it and do not serialize it.
      */
     wrapFocused?: boolean;
+    /**
+     * For interactive TUI select dialogs, cap the title/prompt area to this
+     * many rows and let PageUp/PageDown scroll that prompt locally. This is a
+     * select-only rendering hint; non-TUI bridges drop it and do not serialize it.
+     */
+    scrollTitleRows?: number;
 }
 /** Raw terminal input listener for extensions. */
 export type TerminalInputHandler = (data: string) => {

package/dist/types/extensibility/shared-events.d.ts

@@ -180,6 +180,7 @@ export interface AutoRetryStartEvent {
     maxAttempts: number;
     delayMs: number;
     errorMessage: string;
+    unbounded?: boolean;
 }
 /** Fired when auto-retry ends */
 export interface AutoRetryEndEvent {

package/dist/types/gjc-runtime/restricted-role-agent-bash.d.ts

@@ -0,0 +1,2 @@
+export declare const GJC_RESTRICTED_ROLE_AGENT_BASH_ENV = "GJC_RESTRICTED_ROLE_AGENT_BASH";
+export declare function isRestrictedRoleAgentBash(): boolean;

package/dist/types/gjc-runtime/state-graph.d.ts

@@ -0,0 +1,4 @@
+import type { CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
+export type StateGraphSkill = CanonicalGjcWorkflowSkill | "all";
+export type StateGraphFormat = "ascii" | "mermaid" | "dot";
+export declare function renderStateGraph(skill: StateGraphSkill, format?: string): string;

package/dist/types/gjc-runtime/state-migrations.d.ts

@@ -0,0 +1,24 @@
+export interface NormalizeLegacyStateResult {
+    state: Record<string, unknown>;
+    changed: boolean;
+}
+export interface MigrateAndPersistLegacyStateArgs {
+    cwd: string;
+    skill: string;
+    statePath: string;
+    sessionId?: string;
+}
+export interface MigrateAndPersistLegacyStateResult {
+    migrated: boolean;
+    path: string;
+}
+/**
+ * Pure legacy state normalizer for background/internal readers.
+ *
+ * Readers that need compatibility with old on-disk workflow state shapes must call
+ * this in-memory helper and must never call `migrateAndPersistLegacyState`. The
+ * persist variant is reserved for explicit state migration commands because it is
+ * the only path allowed to write normalized upgrades back to `.gjc/state/**`.
+ */
+export declare function normalizeLegacyState(raw: Record<string, unknown>, skill: string): NormalizeLegacyStateResult;
+export declare function migrateAndPersistLegacyState(args: MigrateAndPersistLegacyStateArgs): Promise<MigrateAndPersistLegacyStateResult>;

package/dist/types/gjc-runtime/state-renderer.d.ts

@@ -0,0 +1,65 @@
+import type { CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
+import type { SkillManifest } from "./workflow-manifest";
+export declare const STATE_FIELD_ALLOWLIST: readonly ["skill", "phase", "current_phase", "next", "active", "status", "fresh", "fresh_until", "receipt", "artifact_path", "plan_path", "spec_path", "run_id", "stage", "stage_n", "session_id", "updated_at", "handoff_to", "handoff_from", "counts", "hud"];
+export type StateProjectionField = (typeof STATE_FIELD_ALLOWLIST)[number];
+export interface StateStatusSummary {
+    skill: CanonicalGjcWorkflowSkill;
+    phase: string;
+    active: boolean;
+    fresh: boolean;
+    fresh_until?: string;
+    next: string[];
+    receipt_status: string;
+    storage_path: string;
+}
+export declare function compactProjectStateJson(skill: CanonicalGjcWorkflowSkill, stateJson: Record<string, unknown>, manifest: SkillManifest): Record<string, unknown>;
+export declare function projectStateFields(skill: CanonicalGjcWorkflowSkill, stateJson: Record<string, unknown>, manifest: SkillManifest, fields: readonly StateProjectionField[]): Record<string, unknown>;
+export declare function buildStateStatusSummary(skill: CanonicalGjcWorkflowSkill, stateJson: Record<string, unknown>, manifest: SkillManifest, storagePath: string): StateStatusSummary;
+export declare function renderStateStatusLine(summary: StateStatusSummary): string;
+export declare function renderContractMarkdown(skill: CanonicalGjcWorkflowSkill, contract: unknown): string;
+export declare function renderHistoryMarkdown(history: {
+    entries: unknown[];
+    limit: number;
+    since?: string;
+    truncated: boolean;
+}): string;
+export declare function renderUltragoalStatusMarkdown(summary: {
+    exists: boolean;
+    status: string;
+    paths: {
+        goalsPath: string;
+        ledgerPath?: string;
+    };
+    gjcObjective?: string;
+    currentGoal?: {
+        id: string;
+        status: string;
+        title?: string;
+        objective?: string;
+    };
+    counts: Record<string, number>;
+    goals: unknown[];
+}): string;
+export declare function renderTeamStatusMarkdown(snapshot: {
+    team_name: string;
+    phase: string;
+    tmux_target?: string;
+    tmux_session?: string;
+    state_dir: string;
+    task_total: number;
+    task_counts: Record<string, number>;
+    workers: Array<{
+        id: string;
+        status: string;
+    }>;
+    notification_summary?: {
+        total: number;
+        replay_eligible: number;
+        by_state: Record<string, number>;
+    };
+    integration_by_worker?: Record<string, {
+        status?: string;
+        conflict_files?: string[];
+    }>;
+}): string;
+export declare function renderStateMarkdown(skill: CanonicalGjcWorkflowSkill, stateJson: Record<string, unknown>, manifest: SkillManifest): string;

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

@@ -1,3 +1,4 @@
+import { type CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
 /**
  * Native implementation of the `gjc state read|write|clear` command surface.
  *
@@ -10,4 +11,5 @@ export interface StateCommandResult {
     stdout?: string;
     stderr?: string;
 }
+export declare function readWorkflowStateJson(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string): Promise<Record<string, unknown>>;
 export declare function runNativeStateCommand(args: string[], cwd?: string): Promise<StateCommandResult>;

package/dist/types/gjc-runtime/state-validation.d.ts

@@ -0,0 +1,6 @@
+import type { CanonicalGjcWorkflowSkill } from "../skill-state/active-state";
+export interface StateValidationResult {
+    valid: boolean;
+    error?: string;
+}
+export declare function validateWorkflowStateEnvelope(skill: CanonicalGjcWorkflowSkill, state: unknown): StateValidationResult;