@wjarka/cezarion 0.16.0 → 0.17.0

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/{core → contract}/tool-display.d.ts

@@ -1,12 +1,6 @@
 /**
- * Tool display model — turns a backend tool name + raw input into the
- * `{toolKind, title, subtitle?}` a tool card renders. Computed ONCE here in
- * the protocol layer (paseo's pattern), never in components, so the thread,
- * activity groups and notifications all say the same thing.
- *
- * Pure function over untrusted input: tool inputs come off the wire and may
- * be null, partial (streamed incrementally) or arbitrarily malformed —
- * `toolDisplay` must never throw.
+ * 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):
@@ -20,12 +14,12 @@
  *              as tolerance for its non-app-server transports)
  *  - opencode: bash, edit, write, read, grep, glob, webfetch, task, todowrite
  */
-import type { ToolKind } from './ui-events.ts';
+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;
+    subtitle?: string | undefined;
 }
 export declare function toolDisplay(name: string, input?: unknown): ToolDisplay;

package/dist/contract/ui-state-requests.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const uiStateBody: z.ZodObject<{
+    sidebarLimits: z.ZodOptional<z.ZodObject<{
+        overall: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        needsYou: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        finished: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        working: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    lastWorktree: z.ZodOptional<z.ZodBoolean>;
+    lastAutonomous: z.ZodOptional<z.ZodBoolean>;
+    disabledTeamSkills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>>;
+    runsView: z.ZodOptional<z.ZodEnum<{
+        list: "list";
+        table: "table";
+    }>>;
+    githubView: z.ZodOptional<z.ZodEnum<{
+        issues: "issues";
+        prs: "prs";
+    }>>;
+    appearance: z.ZodOptional<z.ZodObject<{
+        accent: z.ZodOptional<z.ZodEnum<{
+            cezarion: "cezarion";
+            lime: "lime";
+            violet: "violet";
+        }>>;
+        density: z.ZodOptional<z.ZodEnum<{
+            comfortable: "comfortable";
+            compact: "compact";
+            ultra: "ultra";
+        }>>;
+        width: z.ZodOptional<z.ZodEnum<{
+            narrow: "narrow";
+            wide: "wide";
+        }>>;
+    }, z.core.$strip>>;
+    lastTask: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        source: z.ZodEnum<{
+            skill: "skill";
+            workflow: "workflow";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strip>>>;
+    recentSources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            skill: "skill";
+            workflow: "workflow";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strip>>>;
+    skillUsage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    promptTemplates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        text: z.ZodString;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$loose>;

package/dist/contract/version.d.ts

@@ -0,0 +1,3 @@
+/** Plain numeric semver compare (`1.2.10` > `1.2.9`); pre-release tags and
+ *  anything unparseable compare as 0 — good enough for release-only publishes. */
+export declare function isNewerVersion(candidate: string, current: string): boolean;

package/dist/contract/voice.d.ts

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+/**
+ * Voice mode v1 (spec 2026-10-21-voice-mode): the ⌘K palette understands sentences. The server
+ * asks Jev (TypeSafe) to turn one sentence into one decision; the cockpit executes it. Everything
+ * here is Node-free; the server and the cockpit read the same definitions.
+ */
+/** Longest sentence the palette sends, after trimming. */
+export declare const VOICE_TEXT_MAX = 500;
+/** The sidebar statuses a sentence may name, in the vocabulary the cockpit already shows. */
+export declare const VOICE_STATUS_IDS: readonly ['needs-you', 'working', 'finished', 'archived', 'needs-review', 'needs-permission', 'failed', 'running', 'waiting-for-ci', 'monitoring', 'waiting-for-capacity', 'queued', 'scheduled', 'waiting-on-workers', 'done', 'cancelled', 'unread'];
+export declare const voiceStatusSchema: z.ZodEnum<{
+    archived: "archived";
+    cancelled: "cancelled";
+    done: "done";
+    failed: "failed";
+    finished: "finished";
+    monitoring: "monitoring";
+    "needs-permission": "needs-permission";
+    "needs-review": "needs-review";
+    "needs-you": "needs-you";
+    queued: "queued";
+    running: "running";
+    scheduled: "scheduled";
+    unread: "unread";
+    "waiting-for-capacity": "waiting-for-capacity";
+    "waiting-for-ci": "waiting-for-ci";
+    "waiting-on-workers": "waiting-on-workers";
+    working: "working";
+}>;
+export type VoiceStatus = z.infer<typeof voiceStatusSchema>;
+/** One plain line per status, written for the engine that picks one. */
+export declare const VOICE_STATUS_DESCRIPTIONS: Record<VoiceStatus, string>;
+/** Which task in the list a sentence points at. */
+export declare const voicePositionSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    last: "last";
+    next: "next";
+    previous: "previous";
+}>, z.ZodNumber]>;
+export type VoicePosition = z.infer<typeof voicePositionSchema>;
+export declare const voiceSidebarViewSchema: z.ZodEnum<{
+    active: "active";
+    automations: "automations";
+}>;
+/** The kind of page the user is on when they speak (hearsay-tools/cezarion#1463). */
+export declare const VOICE_VIEWS: readonly ['task', 'new-task', 'github', 'git', 'automations', 'inbox', 'settings', 'other'];
+export declare const voiceViewSchema: z.ZodEnum<{
+    automations: "automations";
+    git: "git";
+    github: "github";
+    inbox: "inbox";
+    "new-task": "new-task";
+    other: "other";
+    settings: "settings";
+    task: "task";
+}>;
+export type VoiceView = z.infer<typeof voiceViewSchema>;
+export declare const voiceDecideRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+    sidebarView: z.ZodEnum<{
+        active: "active";
+        automations: "automations";
+    }>;
+    openRunId: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodEnum<{
+        automations: "automations";
+        git: "git";
+        github: "github";
+        inbox: "inbox";
+        "new-task": "new-task";
+        other: "other";
+        settings: "settings";
+        task: "task";
+    }>>;
+    askRequestId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    proposal: z.ZodOptional<z.ZodObject<{
+        decisionId: z.ZodUUID;
+        action: z.ZodEnum<{
+            answer: "answer";
+            tell: "tell";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type VoiceDecideRequest = z.infer<typeof voiceDecideRequestSchema>;
+/** One answer to one question of an ask: a listed option, or free text. */
+export declare const voiceAnswerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    question: z.ZodNumber;
+    kind: z.ZodLiteral<"option">;
+    labels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    question: z.ZodNumber;
+    kind: z.ZodLiteral<"other">;
+    text: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type VoiceAnswer = z.infer<typeof voiceAnswerSchema>;
+export declare const voiceDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"open">;
+    decisionId: z.ZodUUID;
+    status: z.ZodEnum<{
+        archived: "archived";
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        finished: "finished";
+        monitoring: "monitoring";
+        "needs-permission": "needs-permission";
+        "needs-review": "needs-review";
+        "needs-you": "needs-you";
+        queued: "queued";
+        running: "running";
+        scheduled: "scheduled";
+        unread: "unread";
+        "waiting-for-capacity": "waiting-for-capacity";
+        "waiting-for-ci": "waiting-for-ci";
+        "waiting-on-workers": "waiting-on-workers";
+        working: "working";
+    }>;
+    position: z.ZodUnion<readonly [z.ZodEnum<{
+        last: "last";
+        next: "next";
+        previous: "previous";
+    }>, z.ZodNumber]>;
+    confidence: z.ZodNumber;
+    alternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            archived: "archived";
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            finished: "finished";
+            monitoring: "monitoring";
+            "needs-permission": "needs-permission";
+            "needs-review": "needs-review";
+            "needs-you": "needs-you";
+            queued: "queued";
+            running: "running";
+            scheduled: "scheduled";
+            unread: "unread";
+            "waiting-for-capacity": "waiting-for-capacity";
+            "waiting-for-ci": "waiting-for-ci";
+            "waiting-on-workers": "waiting-on-workers";
+            working: "working";
+        }>;
+        position: z.ZodUnion<readonly [z.ZodEnum<{
+            last: "last";
+            next: "next";
+            previous: "previous";
+        }>, z.ZodNumber]>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"answer">;
+    decisionId: z.ZodUUID;
+    runId: z.ZodString;
+    askRequestId: z.ZodString;
+    answers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        question: z.ZodNumber;
+        kind: z.ZodLiteral<"option">;
+        labels: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        question: z.ZodNumber;
+        kind: z.ZodLiteral<"other">;
+        text: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"tell">;
+    decisionId: z.ZodUUID;
+    runId: z.ZodString;
+    text: z.ZodString;
+    confidence: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"confirm">;
+    decisionId: z.ZodUUID;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"cancel">;
+    decisionId: z.ZodUUID;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"none">;
+    decisionId: z.ZodUUID;
+    reason: z.ZodEnum<{
+        ambiguous: "ambiguous";
+        "no-open-question": "no-open-question";
+        "no-open-task": "no-open-task";
+        "not-a-command": "not-a-command";
+        "stale-context": "stale-context";
+        unclear: "unclear";
+        unsupported: "unsupported";
+    }>;
+}, z.core.$strip>], "action">;
+export type VoiceDecision = z.infer<typeof voiceDecisionSchema>;
+/** What became of a decision, reported back so the server can learn which ones were wrong. */
+export declare const voiceOutcomeSchema: z.ZodEnum<{
+    abandoned: "abandoned";
+    cancelled: "cancelled";
+    confirmed: "confirmed";
+    executed: "executed";
+    replaced: "replaced";
+}>;
+export type VoiceOutcome = z.infer<typeof voiceOutcomeSchema>;
+export declare const voiceOutcomeRequestSchema: z.ZodObject<{
+    decisionId: z.ZodUUID;
+    outcome: z.ZodEnum<{
+        abandoned: "abandoned";
+        cancelled: "cancelled";
+        confirmed: "confirmed";
+        executed: "executed";
+        replaced: "replaced";
+    }>;
+}, z.core.$strict>;
+export type VoiceOutcomeRequest = z.infer<typeof voiceOutcomeRequestSchema>;
+export declare const voiceOutcomeResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type VoiceOutcomeResponse = z.infer<typeof voiceOutcomeResponseSchema>;