@hearsay-tools/squawk 0.0.0-stage → 0.17.0-dev.5682

package/dist/contract/scheduled-tasks.d.ts

@@ -0,0 +1,188 @@
+import { z } from 'zod';
+/**
+ * The two session tools for one-time scheduled tasks (hearsay-tools/cezarion#1465):
+ * `cezar_schedule_task` creates one, `cezar_scheduled_tasks` lists and changes them. An agent
+ * reaches them through the bundled MCP adapter, which relays raw arguments over the session's
+ * private tool socket; the run and project come from the session, never from these arguments,
+ * which is why every request object is strict. A one-time schedule IS an automation
+ * (`schedule.type: 'once'`); these shapes are the agent's view of it.
+ */
+/**
+ * Request and answer sizes of the two tools: a 100 000-character prompt and a list of 50. The
+ * request cap is in bytes: one UTF-16 unit of the prompt can take six bytes on the wire (`\u0001`
+ * escaped, or a lone surrogate), so 600 000 for the prompt plus the short fields fits 1 MiB.
+ */
+export declare const SCHEDULED_TASK_LIMITS: {
+    readonly prompt: 100000;
+    readonly list: 50;
+    readonly wireBytes: 1048576;
+};
+/** `30m`, `6h`, `7d` (d = 24 h of elapsed time) as minutes. Throws on anything else. */
+export declare function parseDurationMinutes(value: string): number;
+/**
+ * `delay` after `nowMs`, as the `at` wall time (`YYYY-MM-DDTHH:MM`) in `timeZone`, rounded UP to
+ * the minute so the resolved time is never earlier than asked. The delay is elapsed time: seven
+ * days across a DST change lands one wall-clock hour away from the starting hour.
+ */
+export declare function resolveDelay(delay: string, nowMs: number, timeZone: string): string;
+/**
+ * The instant `targetMs`, rounded UP to the minute, as the `at` wall time (`YYYY-MM-DDTHH:MM`) in
+ * `timeZone`: how a UTC time from an agent is stored in the cockpit's zone.
+ */
+export declare function wallTimeAtOrAfter(targetMs: number, timeZone: string): string;
+/**
+ * The agent's form of a time: UTC to the minute, `YYYY-MM-DDTHH:MMZ`, like every other time a
+ * Cezar tool takes or answers. The stored schedule keeps a wall time in its zone for the cockpit.
+ */
+export declare const UTC_MINUTE_PATTERN: RegExp;
+export declare const utcMinute: (instantMs: number) => string;
+/** `cezar_schedule_task`. */
+export declare const scheduleTaskRequestSchema: z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    delay: z.ZodOptional<z.ZodString>;
+    latest_start: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    runner: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    prompt: z.ZodString;
+    enable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ScheduleTaskRequest = z.infer<typeof scheduleTaskRequestSchema>;
+/** `cezar_scheduled_tasks`: one action per call. */
+export declare const scheduledTasksRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    archived: z.ZodOptional<z.ZodEnum<{
+        include: "include";
+        only: "only";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"show">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    delay: z.ZodOptional<z.ZodString>;
+    latest_start: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    runner: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    action: z.ZodLiteral<"update">;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"pause">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"enable">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"cancel">;
+    id: z.ZodString;
+}, z.core.$strict>], "action">;
+export type ScheduledTasksRequest = z.infer<typeof scheduledTasksRequestSchema>;
+/** One one-time schedule as the agent sees it. */
+export declare const scheduledTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        archived: "archived";
+        failed: "failed";
+        missed: "missed";
+        paused: "paused";
+        waiting: "waiting";
+    }>;
+    due_at: z.ZodString;
+    latest_start_minutes: z.ZodOptional<z.ZodNumber>;
+    run_id: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ScheduledTask = z.infer<typeof scheduledTaskSchema>;
+export declare const scheduledTaskRefusalCodeSchema: z.ZodEnum<{
+    automations_off: "automations_off";
+    conflict: "conflict";
+    invalid_request: "invalid_request";
+    not_found: "not_found";
+    unavailable: "unavailable";
+}>;
+export type ScheduledTaskRefusalCode = z.infer<typeof scheduledTaskRefusalCodeSchema>;
+/** The note every create answer carries: Cezarion has no daemon, so it must be running. */
+export declare const SCHEDULED_TASK_NOTE = "Cezarion must be running at the due time, or start again before the latest start, for this task to launch.";
+export declare const scheduleTaskAnswerSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            archived: "archived";
+            failed: "failed";
+            missed: "missed";
+            paused: "paused";
+            waiting: "waiting";
+        }>;
+        due_at: z.ZodString;
+        latest_start_minutes: z.ZodOptional<z.ZodNumber>;
+        run_id: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    note: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodEnum<{
+        automations_off: "automations_off";
+        conflict: "conflict";
+        invalid_request: "invalid_request";
+        not_found: "not_found";
+        unavailable: "unavailable";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>]>;
+export type ScheduleTaskAnswer = z.infer<typeof scheduleTaskAnswerSchema>;
+export declare const scheduledTasksAnswerSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            archived: "archived";
+            failed: "failed";
+            missed: "missed";
+            paused: "paused";
+            waiting: "waiting";
+        }>;
+        due_at: z.ZodString;
+        latest_start_minutes: z.ZodOptional<z.ZodNumber>;
+        run_id: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            archived: "archived";
+            failed: "failed";
+            missed: "missed";
+            paused: "paused";
+            waiting: "waiting";
+        }>;
+        due_at: z.ZodString;
+        latest_start_minutes: z.ZodOptional<z.ZodNumber>;
+        run_id: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodEnum<{
+        automations_off: "automations_off";
+        conflict: "conflict";
+        invalid_request: "invalid_request";
+        not_found: "not_found";
+        unavailable: "unavailable";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>]>;
+export type ScheduledTasksAnswer = z.infer<typeof scheduledTasksAnswerSchema>;

package/dist/contract/self-update.d.ts

@@ -0,0 +1,255 @@
+import { z } from 'zod';
+/**
+ * Self-update (`/api/v1/workspace/self-update`, PoC — spec to follow): the cockpit's own
+ * "update cezar" surface. cezar can only replace ITSELF when it runs from the managed layout
+ * (`~/.cezar/versions/<id>`, activated through the `current` link and launched by
+ * `~/.cezar/bin/cezar`); every other install kind is reported so the dialog can explain how to
+ * get there instead of failing a download nobody can use.
+ */
+/** Release channels map onto npm dist-tags: `stable` → `latest`, `nightly` → `nightly`.
+ *  `development` follows no tag: nothing is ever offered as an update, and the dialog picks a
+ *  cezar worktree or an open pull request's preview build by hand instead. */
+export declare const updateChannelSchema: z.ZodEnum<{
+    development: "development";
+    nightly: "nightly";
+    stable: "stable";
+}>;
+export type UpdateChannel = z.infer<typeof updateChannelSchema>;
+/** How the running process was installed — decides whether a self-update is possible. */
+export declare const installKindSchema: z.ZodEnum<{
+    checkout: "checkout";
+    "global-npm": "global-npm";
+    managed: "managed";
+    npx: "npx";
+    unknown: "unknown";
+}>;
+export type InstallKind = z.infer<typeof installKindSchema>;
+/** One entry under `~/.cezar/versions/`. `id` is the directory name; a local build carries a
+ *  `+local` suffix so it never collides with the registry version it was built from, and a
+ *  linked checkout (`link`, `cezar link`) a `+<branch>` one. */
+export declare const installedVersionSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    source: z.ZodEnum<{
+        link: "link";
+        local: "local";
+        registry: "registry";
+    }>;
+    installedAt: z.ZodString;
+    active: z.ZodBoolean;
+    branch: z.ZodOptional<z.ZodString>;
+    checkout: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type InstalledVersion = z.infer<typeof installedVersionSchema>;
+/** One registry version the picker can install. `channel` is the dist-tag family it belongs to:
+ *  a plain semver is `stable`, `-nightly.` a nightly, anything else (`-develop.`, `-pr123.`) a
+ *  `preview`. `publishedAt` comes from the registry's `time` map, null when it is missing. */
+export declare const availableVersionSchema: z.ZodObject<{
+    version: z.ZodString;
+    channel: z.ZodEnum<{
+        nightly: "nightly";
+        preview: "preview";
+        stable: "stable";
+    }>;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    installed: z.ZodBoolean;
+}, z.core.$strip>;
+export type AvailableVersion = z.infer<typeof availableVersionSchema>;
+export declare const selfUpdateJobStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    restarting: "restarting";
+    running: "running";
+}>;
+/** The one in-flight or last-finished install job. `log` is npm's own output, line by line,
+ *  capped server-side. `restarting` means the new version is activated and the process is about
+ *  to exit — the cockpit polls health until a different `version` answers. */
+export declare const selfUpdateJobSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        failed: "failed";
+        restarting: "restarting";
+        running: "running";
+    }>;
+    target: z.ZodString;
+    startedAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    log: z.ZodArray<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SelfUpdateJob = z.infer<typeof selfUpdateJobSchema>;
+/** `GET /api/v1/workspace/self-update` (and every mutation on the family). */
+export declare const selfUpdateStatusSchema: z.ZodObject<{
+    version: z.ZodString;
+    installKind: z.ZodEnum<{
+        checkout: "checkout";
+        "global-npm": "global-npm";
+        managed: "managed";
+        npx: "npx";
+        unknown: "unknown";
+    }>;
+    entry: z.ZodString;
+    canSelfUpdate: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    channel: z.ZodEnum<{
+        development: "development";
+        nightly: "nightly";
+        stable: "stable";
+    }>;
+    restartMode: z.ZodEnum<{
+        reexec: "reexec";
+        supervisor: "supervisor";
+    }>;
+    latest: z.ZodObject<{
+        stable: z.ZodNullable<z.ZodString>;
+        nightly: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    updateAvailable: z.ZodNullable<z.ZodString>;
+    checkedAt: z.ZodNullable<z.ZodString>;
+    installed: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        source: z.ZodEnum<{
+            link: "link";
+            local: "local";
+            registry: "registry";
+        }>;
+        installedAt: z.ZodString;
+        active: z.ZodBoolean;
+        branch: z.ZodOptional<z.ZodString>;
+        checkout: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    available: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        channel: z.ZodEnum<{
+            nightly: "nightly";
+            preview: "preview";
+            stable: "stable";
+        }>;
+        publishedAt: z.ZodNullable<z.ZodString>;
+        installed: z.ZodBoolean;
+    }, z.core.$strip>>;
+    job: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            failed: "failed";
+            restarting: "restarting";
+            running: "running";
+        }>;
+        target: z.ZodString;
+        startedAt: z.ZodString;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        log: z.ZodArray<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    activeRuns: z.ZodNumber;
+}, z.core.$strip>;
+export type SelfUpdateStatus = z.infer<typeof selfUpdateStatusSchema>;
+/** `POST /api/v1/workspace/self-update/apply` — a version string, never a URL or a path. */
+export declare const selfUpdateApplyRequestSchema: z.ZodObject<{
+    version: z.ZodString;
+}, z.core.$strict>;
+export type SelfUpdateApplyRequest = z.infer<typeof selfUpdateApplyRequestSchema>;
+/** `PUT /api/v1/workspace/self-update/channel`. */
+export declare const selfUpdateChannelRequestSchema: z.ZodObject<{
+    channel: z.ZodEnum<{
+        development: "development";
+        nightly: "nightly";
+        stable: "stable";
+    }>;
+}, z.core.$strict>;
+export type SelfUpdateChannelRequest = z.infer<typeof selfUpdateChannelRequestSchema>;
+/** The cezar task that owns a worktree (`.ai/cezar/worktrees/<runId>` in the repo's run index). */
+export declare const checkoutTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+export type CheckoutTask = z.infer<typeof checkoutTaskSchema>;
+/** A cezar checkout (a worktree of a registered cezar repo) the cockpit can switch to by
+ *  applying its `id` — linked on the spot, no copy, no publish. Only built ones can be applied.
+ *  Everything past `linked` is there to tell forty task branches apart: what the task was, what
+ *  was last committed and when, and whether the build needs refreshing. */
+export declare const cezarCheckoutSchema: z.ZodObject<{
+    id: z.ZodString;
+    branch: z.ZodString;
+    version: z.ZodString;
+    worktree: z.ZodString;
+    built: z.ZodBoolean;
+    linked: z.ZodBoolean;
+    commit: z.ZodNullable<z.ZodObject<{
+        sha: z.ZodString;
+        subject: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+    builtAt: z.ZodNullable<z.ZodString>;
+    stale: z.ZodBoolean;
+    task: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+    }, z.core.$strip>>;
+    pr: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type CezarCheckout = z.infer<typeof cezarCheckoutSchema>;
+/** An open pull request of cezar's own repository, with the preview build CI published for it
+ *  (the `pr-<N>` npm dist-tag, spec 2026-07-18-npm-preview-publish). `version` is null when the
+ *  PR has no build (a fork, CI not green yet): listed, never installable. */
+export declare const pullBuildSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    title: z.ZodString;
+    author: z.ZodNullable<z.ZodString>;
+    branch: z.ZodString;
+    draft: z.ZodBoolean;
+    updatedAt: z.ZodString;
+    url: z.ZodString;
+    version: z.ZodNullable<z.ZodString>;
+    publishedAt: z.ZodNullable<z.ZodString>;
+    installed: z.ZodBoolean;
+}, z.core.$strip>;
+export type PullBuild = z.infer<typeof pullBuildSchema>;
+/** `GET /api/v1/workspace/self-update/development?refresh=1` — `refresh` skips the caches. */
+export declare const selfUpdateDevelopmentQuerySchema: z.ZodObject<{
+    refresh: z.ZodOptional<z.ZodLiteral<"1">>;
+}, z.core.$strict>;
+export type SelfUpdateDevelopmentQuery = z.infer<typeof selfUpdateDevelopmentQuerySchema>;
+/** `GET /api/v1/workspace/self-update/development` — what the development channel picks from.
+ *  Kept off the status route: it costs a git call per worktree and a GitHub round trip. */
+export declare const selfUpdateDevelopmentSchema: z.ZodObject<{
+    checkouts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        branch: z.ZodString;
+        version: z.ZodString;
+        worktree: z.ZodString;
+        built: z.ZodBoolean;
+        linked: z.ZodBoolean;
+        commit: z.ZodNullable<z.ZodObject<{
+            sha: z.ZodString;
+            subject: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strip>>;
+        builtAt: z.ZodNullable<z.ZodString>;
+        stale: z.ZodBoolean;
+        task: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            status: z.ZodString;
+        }, z.core.$strip>>;
+        pr: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    pulls: z.ZodObject<{
+        available: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+        repo: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            number: z.ZodNumber;
+            title: z.ZodString;
+            author: z.ZodNullable<z.ZodString>;
+            branch: z.ZodString;
+            draft: z.ZodBoolean;
+            updatedAt: z.ZodString;
+            url: z.ZodString;
+            version: z.ZodNullable<z.ZodString>;
+            publishedAt: z.ZodNullable<z.ZodString>;
+            installed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SelfUpdateDevelopment = z.infer<typeof selfUpdateDevelopmentSchema>;

package/dist/contract/skill-sources.d.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+/** The source shapes cezar accepts, as the cockpit and every refusal name them. */
+export declare const SKILLS_REPO_FORMATS = "owner/name, an https, ssh or git URL, git@host:path, or a local or file:// path";
+/**
+ * The kind of a `skillsRepos` `repo` value, or null when cezar refuses it. One rule for the
+ * request schema, the cockpit's Add form and the server's git remote (`safeRemoteFor`).
+ *
+ * Refused: an empty value, a leading `-` (git would read an option), `::` (remote-helper
+ * transports run commands) and URL schemes outside https, http, ssh, git and file. Local paths
+ * are matched before the `owner/name` shorthand, because `./rel` fits the shorthand charset.
+ */
+export declare function skillsRepoKind(repo: string): 'home' | 'local' | 'github' | 'url' | 'scp' | null;
+/**
+ * A ref safe to pass to `git` as a positional revision (hearsay-tools/cezarion#428): a branch, tag or commit SHA. It
+ * refuses a leading `-`, `..` and anything outside the git ref-name charset.
+ */
+export declare function isSafeSkillsRef(ref: string): boolean;
+/**
+ * One configured source by its identity, exactly as `skillsRepos` spells it. Two refs of one repo
+ * are two sources. Not shape-checked: a source in a refused format must still be removable.
+ */
+export declare const teamSkillSourceRefSchema: z.ZodObject<{
+    repo: z.ZodString;
+    ref: z.ZodString;
+}, z.core.$strict>;
+export type TeamSkillSourceRef = z.infer<typeof teamSkillSourceRefSchema>;
+/** `POST /skills/sources`: the ref defaults to `main`, as in `skillsRepos`. */
+export declare const addTeamSkillSourceSchema: z.ZodObject<{
+    repo: z.ZodString;
+    ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AddTeamSkillSource = z.infer<typeof addTeamSkillSourceSchema>;
+/** `PATCH /skills/sources`. */
+export declare const setTeamSkillSourceEnabledSchema: z.ZodObject<{
+    repo: z.ZodString;
+    ref: z.ZodString;
+    enabled: z.ZodBoolean;
+}, z.core.$strict>;
+export type SetTeamSkillSourceEnabled = z.infer<typeof setTeamSkillSourceEnabledSchema>;
+/** Why a source has no fresh skill list. */
+export declare const TEAM_SOURCE_FAILURE_CAUSES: readonly ['refused-format', 'fetch-failed', 'ref-not-found'];
+export declare const teamSourceFailureCauseSchema: z.ZodEnum<{
+    "fetch-failed": "fetch-failed";
+    "ref-not-found": "ref-not-found";
+    "refused-format": "refused-format";
+}>;
+export type TeamSourceFailureCause = z.infer<typeof teamSourceFailureCauseSchema>;
+/**
+ * One source's state. `idle` is a disabled source, or one no load has reached yet. A failed
+ * source keeps the skills an older clone still lists, so `skillCount` can be above 0.
+ */
+export declare const teamSourceStatusSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"idle">;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodLiteral<"loading">;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodLiteral<"ok">;
+    skillCount: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodLiteral<"error">;
+    cause: z.ZodEnum<{
+        "fetch-failed": "fetch-failed";
+        "ref-not-found": "ref-not-found";
+        "refused-format": "refused-format";
+    }>;
+    detail: z.ZodString;
+    skillCount: z.ZodNumber;
+}, z.core.$strip>], "state">;
+export type TeamSourceStatus = z.infer<typeof teamSourceStatusSchema>;
+/** A `skillsRepos` entry as the Skills page shows it. `repo` is kept exactly as configured. */
+export declare const teamSkillSourceSchema: z.ZodObject<{
+    repo: z.ZodString;
+    ref: z.ZodString;
+    enabled: z.ZodBoolean;
+    status: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"idle">;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodLiteral<"loading">;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodLiteral<"ok">;
+        skillCount: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodLiteral<"error">;
+        cause: z.ZodEnum<{
+            "fetch-failed": "fetch-failed";
+            "ref-not-found": "ref-not-found";
+            "refused-format": "refused-format";
+        }>;
+        detail: z.ZodString;
+        skillCount: z.ZodNumber;
+    }, z.core.$strip>], "state">;
+}, z.core.$strip>;
+export type TeamSkillSource = z.infer<typeof teamSkillSourceSchema>;
+/**
+ * `GET /skills/sources` and every write's answer. `editable` is false on a cockpit whose
+ * settings are admin-only. `configIssue` names why `.ai/cezar/config.json` cannot be read; while
+ * it is set, every write is refused and `sources` is empty.
+ */
+export declare const teamSkillSourcesResponseSchema: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        ref: z.ZodString;
+        enabled: z.ZodBoolean;
+        status: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"idle">;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"loading">;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"ok">;
+            skillCount: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"error">;
+            cause: z.ZodEnum<{
+                "fetch-failed": "fetch-failed";
+                "ref-not-found": "ref-not-found";
+                "refused-format": "refused-format";
+            }>;
+            detail: z.ZodString;
+            skillCount: z.ZodNumber;
+        }, z.core.$strip>], "state">;
+    }, z.core.$strip>>;
+    editable: z.ZodBoolean;
+    configIssue: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type TeamSkillSourcesResponse = z.infer<typeof teamSkillSourcesResponseSchema>;

package/dist/contract/skills.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+/**
+ * One discovered skill: repo (`.ai/skills`, `.ai/cezar/skills`), `npx skills` install dirs
+ * (project + global), or a configured team skills repo (spec 005).
+ */
+export declare const skillSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    interactive: z.ZodOptional<z.ZodLiteral<true>>;
+    body: z.ZodString;
+    path: z.ZodString;
+    source: z.ZodEnum<{
+        agents: "agents";
+        ai: "ai";
+        builtin: "builtin";
+        cezar: "cezar";
+        global: "global";
+        team: "team";
+    }>;
+    team: z.ZodOptional<z.ZodObject<{
+        repo: z.ZodString;
+        ref: z.ZodString;
+        path: z.ZodString;
+        dir: z.ZodBoolean;
+        commit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Skill = z.infer<typeof skillSchema>;
+export { teamSkillRefSchema, type TeamSkillRef } from './team-skill-ref.ts';
+/**
+ * A team skill from `GET /skills/importable`, whether or not the project switched it off. The
+ * full definition lets the Skills catalog preview it before it is switched on.
+ */
+export declare const importableSkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    interactive: z.ZodOptional<z.ZodLiteral<true>>;
+    body: z.ZodString;
+    path: z.ZodString;
+    source: z.ZodEnum<{
+        agents: "agents";
+        ai: "ai";
+        builtin: "builtin";
+        cezar: "cezar";
+        global: "global";
+        team: "team";
+    }>;
+    team: z.ZodOptional<z.ZodObject<{
+        repo: z.ZodString;
+        ref: z.ZodString;
+        path: z.ZodString;
+        dir: z.ZodBoolean;
+        commit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ImportableSkill = z.infer<typeof importableSkillSchema>;

package/dist/contract/task-options.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+/** Opt-in completion controls on a run and its start, patch and automation inputs. Missing values are off. */
+export declare const completionControlsShape: {
+    archiveWhenDone: z.ZodOptional<z.ZodBoolean>;
+    autoMergePr: z.ZodOptional<z.ZodBoolean>;
+};
+/** Task access (hearsay-tools/cezarion#2784): may the task's agents start and resume Cezar workers,
+ *  and message peer tasks. New runs store an explicit value; a missing value is on. */
+export declare const taskAccessShape: {
+    allowWorkers: z.ZodOptional<z.ZodBoolean>;
+    allowMessaging: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const workersAllowed: (run: {
+    allowWorkers?: boolean | undefined;
+}) => boolean;
+export declare const messagingAllowed: (run: {
+    allowMessaging?: boolean | undefined;
+}) => boolean;

package/dist/contract/team-skill-ref.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/**
+ * One team skill the project switched off, identified by its source repo and name so the same
+ * name from another source stays on. Strict: an entry with a stray key is a bad write.
+ */
+export declare const teamSkillRefSchema: z.ZodObject<{
+    repo: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type TeamSkillRef = z.infer<typeof teamSkillRefSchema>;

package/dist/contract/tool-display.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tool display model for backend names and raw input. Pure and total over malformed or partial
+ * wire values.
+ *
+ * Known names covered (matched case-insensitively so claude's `Bash` and
+ * opencode's `bash` share one row):
+ *  - claude:   Bash, Edit, Write, NotebookEdit, Read, Glob, Grep, WebFetch,
+ *              WebSearch, Task, Agent, Skill, TodoWrite, TaskCreate,
+ *              TaskUpdate, TaskList, mcp__server__tool
+ *  - codex:    commandExecution, contextCompaction, fileChange, imageView,
+ *              mcpToolCall, webSearch, plan
+ *              (codex's checklist arrives as the `turn/plan/updated`
+ *              notification, not as a tool call — `todoList` is kept below only
+ *              as tolerance for its non-app-server transports)
+ *  - opencode: bash, edit, write, read, grep, glob, webfetch, task, todowrite
+ */
+export type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'task' | 'plan' | 'other';
+export interface ToolDisplay {
+    toolKind: ToolKind;
+    /** Human line for the card trigger, e.g. "Ran npm test". */
+    title: string;
+    /** Secondary detail, e.g. the claude Bash `description`. */
+    subtitle?: string | undefined;
+}
+export declare function toolDisplay(name: string, input?: unknown): ToolDisplay;