@gajae-code/coding-agent 0.13.3 → 0.14.0

package/dist/types/crash/index-store.d.ts

@@ -0,0 +1,87 @@
+import { type CrashEvent } from "@gajae-code/utils";
+export declare const CRASH_INDEX_VERSION = 1;
+/** Per-entry message preview cap. */
+export declare const CRASH_INDEX_MESSAGE_MAX_BYTES = 512;
+/** Per-entry serialized cap. */
+export declare const CRASH_INDEX_ENTRY_MAX_BYTES = 1024;
+/** Whole-index serialized cap. */
+export declare const CRASH_INDEX_MAX_BYTES: number;
+/** Entry-count cap; with the per-entry cap this keeps the file under the byte cap. */
+export declare const CRASH_INDEX_MAX_SIGNATURES = 128;
+/** How many `.corrupt-*` siblings are kept before the oldest are deleted. */
+export declare const CRASH_INDEX_MAX_QUARANTINE = 3;
+export interface CrashSignatureEntry {
+    fpv: number;
+    errorName: string;
+    messageClass: string;
+    /** Occurrences ever journaled for this signature. Never decreases. */
+    lifetimeCount: number;
+    /** Occurrences whose record is still present in the current crash log. */
+    retainedCount: number;
+    firstSeen: number;
+    lastSeen: number;
+    lastRecordId: string;
+    reportedAt?: number;
+    reportedIssueUrl?: string;
+    acknowledgedAt?: number;
+    /** Issues this install already "+1"ed, so re-invocations cannot spam comments. */
+    commentedIssues?: string[];
+}
+export interface CrashIndex {
+    version: number;
+    updatedAt: number;
+    /** Epoch ms of the last startup nudge, or 0. */
+    lastNudgedAt: number;
+    /** True when a new signature could not be stored because nothing was evictable. */
+    overflow: boolean;
+    recentEventIds: string[];
+    recentJournalDigests: string[];
+    /** Log-recovered occurrence ids awaiting a possibly delayed journal event. */
+    recoveredRecordIds: string[];
+    /** Reported or acknowledged signatures evicted from the index; never recovered from the log. */
+    retiredFingerprints: string[];
+    signatures: Record<string, CrashSignatureEntry>;
+}
+export interface CrashStatePaths {
+    index: string;
+    events: string;
+    crashLog: string;
+}
+export declare function resolveCrashStatePaths(agentDir?: string): CrashStatePaths;
+export declare function emptyCrashIndex(): CrashIndex;
+/**
+ * Strict index parse. Any deviation — unknown key, wrong alphabet, control
+ * character, out-of-range timestamp, count overflow — rejects the whole file so
+ * it is quarantined and rebuilt from the journal rather than trusted.
+ */
+export declare function parseCrashIndex(raw: string, now?: number): CrashIndex | undefined;
+/** Apply one journal event to the in-memory index. Returns whether it changed anything. */
+export declare function applyCrashEvent(index: CrashIndex, event: CrashEvent, now: number): boolean;
+export interface CompactCrashIndexOptions {
+    paths?: CrashStatePaths;
+    now?: number;
+}
+/**
+ * Merge journal events into the index under the cross-process file lock.
+ *
+ * Bounded and idempotent: the journal is rotated aside before it is read (so a
+ * concurrent fatal append lands in a fresh file rather than being lost to a
+ * truncate), occurrence ids are deduped, and a crashed compaction's leftover
+ * file is picked up by the next run.
+ */
+export declare function compactCrashIndex(options?: CompactCrashIndexOptions): Promise<CrashIndex>;
+/** Read the index without compacting. Missing or invalid files read as empty. */
+export declare function readCrashIndex(paths?: CrashStatePaths): Promise<CrashIndex>;
+/**
+ * Record a state change through the journal, then compact.
+ *
+ * Writing through the journal (rather than editing the index directly) is what
+ * makes concurrent writers safe: two processes stamping `reportedAt` at the
+ * same moment both land an event, and the compactor merges them.
+ */
+export declare function recordCrashStateEvent(event: CrashEvent, options?: CompactCrashIndexOptions): Promise<CrashIndex>;
+export interface CrashSignatureView extends CrashSignatureEntry {
+    fingerprint: string;
+}
+/** Signatures newest-first, which is the order both the CLI and the nudge use. */
+export declare function listCrashSignatures(index: CrashIndex): CrashSignatureView[];

package/dist/types/crash/nudge.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Startup crash nudge.
+ *
+ * One rate-limited status line saying unreported crash signatures exist.
+ * **Nothing is ever transmitted by this piece** — it reads local state only and
+ * points at `gjc crash report`, which has its own consent flow.
+ *
+ * Honest default statement: this is on by default and it *does* change startup
+ * output by design (one bounded line, at most once per 24h per agent dir).
+ * `crashReport.nudge: false` disables it.
+ */
+import { type CrashIndex, type CrashStatePaths } from "./index-store";
+export declare const CRASH_NUDGE_INTERVAL_MS: number;
+export interface CrashNudgeGateInput {
+    /** The `crashReport.nudge` setting. */
+    enabled: boolean;
+    /** True only for a real interactive TUI launch. */
+    interactive: boolean;
+    /** The `startup.quiet` setting. */
+    quiet: boolean;
+}
+/**
+ * Pure gate for the launch wiring. Print mode, SDK/ACP hosts, workers, daemons
+ * and `--version`/`--help` never reach interactive launch, so gating on the
+ * interactive surface is what suppresses them.
+ */
+export declare function crashNudgeGate(input: CrashNudgeGateInput): boolean;
+export interface CrashNudgeDecision {
+    show: boolean;
+    message?: string;
+}
+/**
+ * Decide whether to nudge from the compacted index alone.
+ *
+ * Fires when an unreported, unacknowledged signature gained records since
+ * `lastNudgedAt`, at most once per 24h. Acknowledgement is explicit (the
+ * dismiss action in `gjc crash report`); an ignored line never counts as one.
+ */
+export declare function decideCrashNudge(index: CrashIndex, now: number): CrashNudgeDecision;
+export interface CrashNudgeDeps {
+    paths: CrashStatePaths;
+    index: CrashIndex;
+    now?: () => Date;
+}
+/**
+ * Emit the nudge through the caller's status surface and persist the rate-limit
+ * stamp through the journal, so a rebuilt index cannot reset it within the
+ * journal window. Never throws.
+ */
+export declare function maybeShowCrashNudge(showStatus: (message: string) => void, deps: CrashNudgeDeps): Promise<boolean>;

package/dist/types/crash/record-loader.d.ts

@@ -0,0 +1,17 @@
+export interface LoadedCrashRecord {
+    readonly fingerprint: string;
+    readonly fpv: number;
+    readonly recordId: string;
+    readonly at: number;
+    readonly errorName: string;
+    readonly messageClass: string;
+    /** Record body without the header line and without the identity line. */
+    readonly body: string;
+    /** The `Name: message` part of the header line. */
+    readonly headline: string;
+}
+export declare function parseCrashRecords(contents: string): LoadedCrashRecord[];
+/** Complete v1 records whose marker fingerprint is recomputed from their diagnostic text. */
+export declare function parseRecoverableCrashRecords(contents: string): LoadedCrashRecord[];
+/** Newest identity-bearing record for a fingerprint, or `undefined` when unmatchable. */
+export declare function findLatestRecord(contents: string, fingerprint: string): LoadedCrashRecord | undefined;

package/dist/types/crash/report.d.ts

@@ -0,0 +1,134 @@
+import type { RunGh } from "../utils/gh";
+import { type CrashSignatureView, type CrashStatePaths } from "./index-store";
+import { type LoadedCrashRecord } from "./record-loader";
+import { type SanitizeVerdict } from "./sanitize";
+/** The one repository this command may ever target. */
+export declare const CRASH_REPORT_REPO = "Yeachan-Heo/gajae-code";
+export declare const CRASH_REPORT_ISSUE_PREFIX = "https://github.com/Yeachan-Heo/gajae-code/issues/";
+export interface CrashReportEnvironment {
+    platform: string;
+    gjcVersion: string;
+    bunVersion: string;
+}
+export interface CrashReportAnswers {
+    steps: string;
+    expected: string;
+    provider: string;
+    area: string;
+    additional: string;
+}
+export declare function defaultCrashReportEnvironment(): CrashReportEnvironment;
+/** Generic title built from normalized inputs only — never from raw crash text. */
+export declare function buildCrashReportTitle(signature: CrashSignatureView, record: LoadedCrashRecord): string;
+export interface BuildCrashReportBodyInput {
+    signature: CrashSignatureView;
+    record: LoadedCrashRecord;
+    answers: CrashReportAnswers;
+    environment: CrashReportEnvironment;
+}
+/**
+ * Render the full issue body. Every `bug_report.yml` required field is present:
+ * crash-derived fields prefilled, non-derivable fields carried through from the
+ * interactive answers (or an explicit "not captured" prompt).
+ *
+ * All crash-derived text lives inside fenced blocks with backticks neutralized
+ * and `@` de-fanged; the machine marker is emitted outside those blocks so a
+ * forged marker inside crash text cannot impersonate one.
+ */
+export declare function buildCrashReportBody(input: BuildCrashReportBodyInput): SanitizeVerdict;
+export interface CrashReportSnapshot {
+    path: string;
+    digest: string;
+    byteLength: number;
+    title: string;
+    body: string;
+}
+/**
+ * Freeze the exact bytes that may be submitted into a 0600 file.
+ *
+ * `wx` refuses to follow or clobber an existing path, so a planted symlink
+ * cannot redirect the snapshot, and the digest shown to the user is verified
+ * again immediately before submission.
+ */
+export declare function writeCrashReportSnapshot(dir: string, title: string, body: string): Promise<CrashReportSnapshot>;
+/**
+ * Prefilled issue URL for installs without `gh`.
+ *
+ * Built with `URL`/`URLSearchParams` against a fixed allowlisted origin and
+ * carrying only bounded-grammar fields — never message or stack content. Never
+ * auto-opened.
+ */
+export declare function buildPrefillUrl(title: string, fingerprint: string, version: string): string | undefined;
+export interface DuplicateCandidate {
+    url: string;
+    title: string;
+    author: string;
+}
+export type DuplicateCheck = {
+    status: "none";
+} | {
+    status: "candidate";
+    candidate: DuplicateCandidate;
+} | {
+    status: "uncertain";
+    reason: string;
+};
+/** Validate that a `gh`-returned URL really points at the canonical repository. */
+export declare function isCanonicalIssueUrl(value: string): boolean;
+/**
+ * Read-only duplicate search, always `--repo` pinned. Any timeout, auth failure
+ * or unparseable result is `uncertain`, which refuses creation unless the user
+ * explicitly overrides.
+ */
+export declare function checkForDuplicateIssue(runGh: RunGh, fingerprint: string): Promise<DuplicateCheck>;
+export interface CrashReportIo {
+    print(text: string): void;
+    /** Returns the chosen index, or undefined when cancelled. */
+    select(prompt: string, options: string[]): Promise<number | undefined>;
+    input(prompt: string): Promise<string>;
+    confirm(prompt: string): Promise<boolean>;
+}
+export interface CrashReportDeps {
+    io: CrashReportIo;
+    paths: CrashStatePaths;
+    snapshotDir: string;
+    runGh: RunGh;
+    interactive: boolean;
+    environment?: CrashReportEnvironment;
+    now?: () => Date;
+}
+export type CrashReportOutcome = {
+    status: "no-signatures";
+} | {
+    status: "non-interactive";
+    snapshotPath?: string;
+} | {
+    status: "cancelled";
+} | {
+    status: "acknowledged";
+    fingerprint: string;
+} | {
+    status: "refused";
+    reason: string;
+} | {
+    status: "unmatchable";
+    fingerprint: string;
+} | {
+    status: "manual";
+    snapshotPath: string;
+    prefillUrl?: string;
+} | {
+    status: "duplicate";
+    url: string;
+} | {
+    status: "commented";
+    url: string;
+} | {
+    status: "created";
+    url: string;
+};
+/**
+ * The whole flow. Steps 1–4 are strictly local; `deps.runGh` is first reachable
+ * at step 5, after the digest-confirmed consent gate.
+ */
+export declare function runCrashReportFlow(deps: CrashReportDeps): Promise<CrashReportOutcome>;

package/dist/types/crash/sanitize.d.ts

@@ -0,0 +1,25 @@
+/** Whole-body cap for a generated issue body. */
+export declare const CRASH_BODY_MAX_BYTES: number;
+/** Per-field cap for crash-derived text. */
+export declare const CRASH_FIELD_MAX_BYTES: number;
+export type SanitizeVerdict = {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Sanitize one crash-derived field. Returns a verdict: `ok:false` means the
+ * residual scanner still found something it cannot vouch for, and the caller
+ * must refuse to submit.
+ */
+export declare function sanitizeExternalCrashV1(text: string, maxBytes?: number): SanitizeVerdict;
+/**
+ * Wrap already-sanitized crash-derived text for a fenced Markdown block:
+ * backticks are neutralized so the fence cannot be escaped, and `@` is de-fanged
+ * so a crash message can never notify a GitHub user or team.
+ */
+export declare function fenceCrashText(value: string): string;
+/** Sanitize a label (field name / heading) with the same rules as a value. */
+export declare function sanitizeLabel(label: string): SanitizeVerdict;

package/dist/types/cursor.d.ts

@@ -1,10 +1,21 @@
-import type { AgentEvent, AgentTool, AgentToolContext } from "@gajae-code/agent-core";
+import { type AgentEvent, type AgentTool, type AgentToolContext } from "@gajae-code/agent-core";
 import type { CursorMcpCall, CursorShellStreamCallbacks, CursorExecHandlers as ICursorExecHandlers, ToolResultMessage } from "@gajae-code/ai/core";
+/**
+ * Emitter for events this bridge produces.
+ *
+ * `dispatchedTool` is the tool object the bridge SELECTED and is about to execute — passed
+ * alongside the event, never inside it, so the object never reaches an AgentEvent field, a
+ * serialized payload, or any wire envelope. The handler binds it as provenance (object
+ * identity only) at this producer boundary, because it is the only place that knows which
+ * object actually ran: a consumer re-resolving `toolName` later reads a mutable registry.
+ * Synthetic operations that execute no AgentTool pass nothing and stay unbound.
+ */
+type CursorExecEventEmitter = (event: AgentEvent, dispatchedTool?: AgentTool) => void;
 interface CursorExecBridgeOptions {
     cwd: string;
     tools: Map<string, AgentTool>;
     getToolContext?: () => AgentToolContext | undefined;
-    emitEvent?: (event: AgentEvent) => void;
+    emitEvent?: CursorExecEventEmitter;
     createEventEmitter?: () => ((event: AgentEvent) => void) | undefined;
 }
 export declare class CursorExecHandlers implements ICursorExecHandlers {

package/dist/types/customization/import.d.ts

@@ -0,0 +1,37 @@
+import type { ImportCollisionPolicy, ImportPlan, ImportProduct, ImportResult, ImportSourceScope } from "./types";
+export interface BuildImportPreviewOptions {
+    product: ImportProduct;
+    sourceScope: ImportSourceScope;
+    destinationScope: "project" | "global";
+    surfaces?: readonly ("skills" | "hooks" | "mcps")[];
+    collisionPolicy: ImportCollisionPolicy;
+    cwd: string;
+    homeDir: string;
+}
+/**
+ * Read the selected source product/scope, normalize every candidate through
+ * the sibling contracts, and produce a redacted preview plus an opaque apply
+ * plan. Pure reads only — nothing is written until `applyImport`.
+ */
+export declare function buildImportPreview(options: BuildImportPreviewOptions): Promise<ImportPlan>;
+/**
+ * Apply a confirmed plan. The transaction contract:
+ *
+ * 1. Pre-validation — every destination path is derived from validated plan
+ *    identities (never raw payload names), containment-checked beneath the
+ *    canonical scope directories, and walked for symlinked ancestors; the
+ *    destination MCP config shape is validated; add/rename destinations are
+ *    revalidated against the preview decision (stale previews fail closed).
+ *    Any problem aborts the whole apply before a single write.
+ * 2. Publication — each skill/hook file is written to a same-directory temp
+ *    file (0600) and atomically renamed into place; MCP entries merge into one
+ *    in-memory config written once via the canonical atomic writer. Only
+ *    files this transaction actually publishes enter the rollback journal.
+ * 3. Verification — persisted state is re-read inside the transaction; a
+ *    verification mismatch rolls back exactly like a write failure.
+ * 4. Rollback — restores journal snapshots (or removes created files) and
+ *    reports every restore failure honestly instead of claiming success.
+ */
+export declare function applyImport(plan: ImportPlan, options: {
+    cwd: string;
+}): Promise<ImportResult>;

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

@@ -0,0 +1,4 @@
+export * from "./import";
+export * from "./inventory";
+export * from "./mutations";
+export * from "./types";

package/dist/types/customization/inventory.d.ts

@@ -0,0 +1,25 @@
+import { type SkillManagementPolicy } from "../extensibility/skill-management";
+import type { CustomizationSurface, GjcScope, InventoryRow } from "./types";
+/** Frontmatter key written by the import flow to record provenance. */
+export declare const IMPORTED_FROM_FRONTMATTER_KEY = "x-gjc-imported-from";
+export interface LoadCustomizationInventoryOptions {
+    cwd: string;
+    /** Runtime home override (tests); defaults to the process home. */
+    home?: string;
+    /** Skill management policy snapshot (trust, include/ignore, disabledExtensions). */
+    policy?: SkillManagementPolicy;
+    /** Disabled extension ids (`skill:<name>` / `mcp:<name>`) from settings. */
+    disabledExtensions?: string[];
+}
+export interface CustomizationInventory {
+    rows: InventoryRow[];
+    warnings: string[];
+}
+/** Stable row identity used for selection and mutations. */
+export declare function inventoryRowId(surface: CustomizationSurface, scope: GjcScope, rowPath: string): string;
+/**
+ * Load the full Skills/Hooks/MCPs inventory for the `/extensions` dashboard.
+ * Reads only the canonical `.gjc` scopes; foreign Claude/Codex layouts are
+ * import sources handled by the explicit import flow, never managed entries.
+ */
+export declare function loadCustomizationInventory(options: LoadCustomizationInventoryOptions): Promise<CustomizationInventory>;

package/dist/types/customization/mutations.d.ts

@@ -0,0 +1,32 @@
+export type MutationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Toggle a native skill through the authoritative policy contract. Returns
+ * the updated `disabledExtensions` list; the caller persists it via Settings.
+ * Bundled workflow skill names cannot be disabled.
+ */
+export declare function setSkillEnabled(name: string, enabled: boolean, disabledExtensions: string[]): MutationResult & {
+    disabledExtensions?: string[];
+};
+/**
+ * Remove a native skill by its exact discovered SKILL.md path identity.
+ * Fails when the discovered file is absent, refuses symlinked directories or
+ * files, and never removes protected bundled workflow skill names.
+ */
+export declare function removeSkill(record: {
+    name: string;
+    path: string;
+}): Promise<MutationResult>;
+/** Toggle a server through the canonical disabledServers denylist. */
+export declare function setMcpServerEnabled(mcpConfigPath: string, name: string, enabled: boolean, disabledExtensions?: string[]): Promise<MutationResult>;
+/** Remove a server via the canonical config writer. */
+export declare function removeMcpServerEntry(mcpConfigPath: string, name: string): Promise<MutationResult>;
+/**
+ * Remove a hook by its exact discovered path. Refuses symlinks, non-files,
+ * and paths that do not exist (no silent success).
+ */
+export declare function removeHookFile(hookPath: string): Promise<MutationResult>;

package/dist/types/customization/types.d.ts

@@ -0,0 +1,115 @@
+import type { MigrateSource } from "../migrate/types";
+import type { MCPServerConfig } from "../runtime-mcp/types";
+export type GjcScope = "project" | "global";
+export interface GjcScopePaths {
+    scope: GjcScope;
+    /** Root directory: `<project>/.gjc` or `~/.gjc/agent` */
+    root: string;
+    /** MCP config: `<root>/mcp.json` */
+    mcpConfigPath: string;
+    /** Skills directory: `<root>/skills/` */
+    skillsDir: string;
+    /** Hooks directory: `<root>/hooks/` */
+    hooksDir: string;
+}
+export declare function resolveScopePaths(scope: GjcScope, projectCwd: string): GjcScopePaths;
+export declare function scopeLabel(scope: GjcScope): string;
+export type CustomizationSurface = "skills" | "hooks" | "mcps";
+export declare const CUSTOMIZATION_SURFACES: readonly CustomizationSurface[];
+export declare function surfaceLabel(surface: CustomizationSurface): string;
+export type ImportProduct = Exclude<MigrateSource, "opencode">;
+export type ImportSourceScope = "project" | "user";
+export declare const IMPORT_PRODUCTS: readonly ImportProduct[];
+export declare const IMPORT_SOURCE_SCOPES: readonly ImportSourceScope[];
+export declare function productLabel(product: ImportProduct): string;
+export declare function sourceScopeLabel(scope: ImportSourceScope): string;
+export declare function sourceConfigDir(product: ImportProduct, sourceScope: ImportSourceScope, projectCwd: string, homeDir: string): string;
+export type InventoryStatus = "enabled" | "disabled" | "invalid" | "shadowed" | "quarantined" | "imported" | "restart-required";
+export interface InventoryRow {
+    /** Stable row identity: `<surface>:<scope>:<path>` */
+    id: string;
+    /** Surface kind */
+    surface: CustomizationSurface;
+    /** Entry name */
+    name: string;
+    /** Display name */
+    displayName: string;
+    /** Effective status */
+    status: InventoryStatus;
+    /** Provenance — which scope/convention discovered it */
+    provenance: string;
+    /** Absolute discovered path — the exact identity mutations act on */
+    path: string;
+    /** Scope that persists this row (project `.gjc` or global `.gjc`) */
+    scope: GjcScope;
+    /** Short description (no secrets) */
+    description?: string;
+    /** Diagnostics/remediation detail for invalid/conflicted rows */
+    diagnostics?: string[];
+    /** Redacted inspector payload (never contains secret values) */
+    raw: unknown;
+}
+export type ImportCollisionPolicy = "skip" | "rename" | "overwrite";
+export type ImportEntryStatus = "add" | "conflict" | "unsupported" | "redacted" | "overwrite";
+export interface ImportPreviewEntry {
+    surface: CustomizationSurface;
+    /** Source name in the foreign layout */
+    sourceName: string;
+    /** Destination name in `.gjc` (may differ under rename policy) */
+    destinationName: string;
+    status: ImportEntryStatus;
+    /** Source path category (file, section, etc.) */
+    sourceCategory: string;
+    /** Redacted description for the preview UI */
+    description: string;
+    /** Reason for conflict/unsupported/redaction if applicable */
+    reason?: string;
+}
+export interface NormalizedPayload {
+    mcp?: {
+        name: string;
+        config: MCPServerConfig;
+    };
+    skill?: {
+        slug: string;
+        content: string;
+    };
+    hook?: {
+        phase: "pre" | "post";
+        fileName: string;
+        content: string;
+    };
+}
+export interface ImportPreview {
+    product: ImportProduct;
+    sourceScope: ImportSourceScope;
+    destinationScope: GjcScope;
+    surfaces: CustomizationSurface[];
+    entries: ImportPreviewEntry[];
+    /** Aggregate warnings across all entries */
+    warnings: string[];
+}
+/**
+ * Validated apply plan produced alongside the redacted preview. `payloads` is
+ * parallel to `preview.entries` (undefined for entries that carry no write).
+ * It is deliberately separate from the preview DTO: the preview is safe to
+ * serialize and display, while the plan holds full file contents and MCP
+ * secret values and is only consumed by the apply transaction.
+ */
+export interface ImportPlan {
+    preview: ImportPreview;
+    payloads: readonly (NormalizedPayload | undefined)[];
+}
+export type ImportOutcome = "imported" | "skipped" | "renamed" | "overwritten" | "failed";
+export interface ImportResultEntry {
+    surface: CustomizationSurface;
+    sourceName: string;
+    destinationName: string;
+    outcome: ImportOutcome;
+    reason?: string;
+}
+export interface ImportResult {
+    entries: ImportResultEntry[];
+    /** True if all entries succeeded (imported/skipped/renamed/overwritten) */
+    ok: boolean;
+}

package/dist/types/daemon/control-types.d.ts

@@ -6,7 +6,8 @@
  * a richer registry is intentionally deferred until a second kind exists.
  */
 export type DaemonKind = "telegram" | "discord" | "slack";
-export type DaemonAction = "list" | "status" | "stop" | "reload";
+/** `reload` remains the controller result verb; `restart` is the CLI canonical action. */
+export type DaemonAction = "list" | "status" | "stop" | "restart" | "reload";
 export type DaemonHealth = "not_configured" | "stopped" | "running" | "stale" | "stopping" | "error";
 export interface DaemonRuntimeInfo {
     /** `source` when respawn goes through bun/node + the entry script; `compiled` for a single-file binary. */
@@ -39,6 +40,12 @@ export interface DaemonOperationOptions {
     force?: boolean;
     /** For reload: spawn a fresh owner even when none is currently running. */
     spawnIfStopped?: boolean;
+    /**
+     * A post-update recovery has already force-stopped every selected daemon.
+     * When global delivery is disabled, acknowledge its canonical restart stage
+     * without spawning a transport that would resume delivery.
+     */
+    allowDisabledNoop?: boolean;
 }
 export interface DaemonRecovery {
     /** Machine-readable recovery category for automation branching. */

package/dist/types/daemon/operator-contract.d.ts

@@ -3,7 +3,7 @@
  *
  * One source of truth for the beginner-safe operational vocabulary so the
  * guided human surface and the machine-readable JSON never drift:
- * - the terse action verbs plus operator aliases (e.g. `restart` -> `reload`),
+ * - the terse action verbs plus the retired `reload` operator alias,
  * - process exit codes,
  * - concise vs. `--verbose` human rendering of statuses and results, and
  * - actionable recovery guidance for a token/chat ownership mismatch.
@@ -15,9 +15,9 @@ import type { DaemonAction, DaemonOperationResult, DaemonRecovery, DaemonStatus
 /** Canonical daemon actions accepted as the leading verb. */
 export declare const DAEMON_CANONICAL_ACTIONS: readonly DaemonAction[];
 /**
- * Operator-friendly aliases resolved to a canonical action. `restart` is the
- * routine "reload if running, otherwise start" verb; it maps onto `reload`,
- * whose default already spawns a fresh owner when none is running.
+ * `restart` is the routine "reload if running, otherwise start" verb. Keep
+ * `reload` only as an input compatibility token; internal callers must use
+ * the canonical restart action.
  */
 export declare const DAEMON_ACTION_ALIASES: Readonly<Record<string, DaemonAction>>;
 /** Every token accepted in the leading action position (canonical + aliases). */

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

@@ -1 +1,39 @@
-export {};
+import type { ExtensionModule } from "../capability/extension-module";
+import type { Hook } from "../capability/hook";
+import type { MCPServer } from "../capability/mcp";
+import type { Skill } from "../capability/skill";
+import type { SlashCommand } from "../capability/slash-command";
+import type { CustomTool } from "../capability/tool";
+import type { LoadContext, LoadResult } from "../capability/types";
+export declare const CLAUDE_PROVIDER_ID = "claude";
+export declare const CLAUDE_DISPLAY_NAME = "Claude Code";
+export declare const CLAUDE_CONFIG_DIR = ".claude";
+/**
+ * Enumerate `.claude/skills` from every ancestor of `cwd` up to the repo root
+ * (closest first) — the Claude Code project convention.
+ */
+export declare function scanClaudeProjectSkills(ctx: LoadContext): Promise<LoadResult<Skill>>;
+/**
+ * Enumerate the user-global `~/.claude/skills` layout. This is an explicit
+ * import candidate only; GJC never loads it without an explicit import action.
+ */
+export declare function scanClaudeUserSkills(ctx: LoadContext): Promise<LoadResult<Skill>>;
+export declare function claudeSkillSourceMeta(filePath: string, level: "user" | "project"): import(".").SourceMeta;
+export interface ClaudeConventionInspection {
+    mcps: LoadResult<MCPServer>;
+    skills: LoadResult<Skill>;
+    hooks: LoadResult<Hook>;
+    tools: LoadResult<CustomTool>;
+    extensions: LoadResult<ExtensionModule>;
+    commands: LoadResult<SlashCommand>;
+}
+/**
+ * Inspect what the Claude Code project convention (.claude/) would surface.
+ *
+ * Reuses the shared discovery scan helpers without registering any provider,
+ * so diagnostics can report the convention's files while keeping the runtime
+ * load path exactly as configured (none of these surfaces are registered for
+ * session loading; hooks are covered by the separate registered claude-hooks
+ * provider).
+ */
+export declare function inspectClaudeConvention(ctx: LoadContext): Promise<ClaudeConventionInspection>;