brainfile 0.21.2 → 0.22.1

package/dist/mcp/schemas.d.ts

@@ -1,5 +1,5 @@
 /**
- * Output schemas for the 11 consolidated MCP tools.
+ * Output schemas for the consolidated MCP tools.
  *
  * Each tool declares one of these as `outputSchema`, and every non-error
  * success path returns the matching object as `structuredContent` alongside
@@ -38,6 +38,9 @@ import { z } from 'zod';
 export declare const listTasksOutputSchema: z.ZodObject<{
     tasks: z.ZodArray<z.ZodObject<{
         column: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
         id: z.ZodString;
         title: z.ZodString;
         priority: z.ZodOptional<z.ZodString>;
@@ -45,6 +48,36 @@ export declare const listTasksOutputSchema: z.ZodObject<{
         assignee: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     count: z.ZodNumber;
+    tree: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        type: z.ZodString;
+        column: z.ZodString;
+        depth: z.ZodNumber;
+        parentId: z.ZodOptional<z.ZodString>;
+        children: z.ZodArray<z.ZodString>;
+        offPattern: z.ZodOptional<z.ZodBoolean>;
+        detachedFrom: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        alias: z.ZodString;
+        path: z.ZodString;
+        status: z.ZodString;
+        note: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        tasks: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            column: z.ZodString;
+            neededBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            id: z.ZodString;
+            title: z.ZodString;
+            priority: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            assignee: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        notFound: z.ZodArray<z.ZodString>;
+        neededBy: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 /**
  * `get_task` spreads the raw `Task`, whose TypeScript type carries an open
@@ -82,6 +115,29 @@ export declare const getTaskOutputSchema: z.ZodObject<{
     completedAt: z.ZodOptional<z.ZodString>;
     position: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodOptional<z.ZodBoolean>;
+    /** Set when the task was read from a related board (`alias:id`). */
+    board: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+    /** `dependsOn`, resolved: `open`, `completed`, `not-found`, `missing`, `no-board`, … */
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        state: z.ZodString;
+        done: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    /** True while a dependency on a related board is not completed. */
+    blocked: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Its place in the graph (spec-12): canonical type and role, parent (with
+     * offPattern when it does not fit), children, the decisions it rests on,
+     * restsOnSuperseded, and for a decision the work resting on it.
+     */
+    graph: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        role: z.ZodString;
+        glyph: z.ZodString;
+        restsOnSuperseded: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 /**
  * Three genuinely different payloads selected by which input was supplied.
@@ -108,6 +164,19 @@ export declare const searchOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
         column: z.ZodOptional<z.ZodString>;
         score: z.ZodNumber;
         isLog: z.ZodOptional<z.ZodBoolean>;
+        lane: z.ZodOptional<z.ZodEnum<{
+            current: "current";
+            history: "history";
+        }>>;
+        source: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        startLine: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        snippet: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        claimKey: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
         id: z.ZodString;
         title: z.ZodString;
         priority: z.ZodOptional<z.ZodString>;
@@ -115,11 +184,17 @@ export declare const searchOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
         assignee: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     count: z.ZodNumber;
+    mode: z.ZodOptional<z.ZodEnum<{
+        index: "index";
+        scan: "scan";
+    }>>;
 }, z.core.$strip>]>;
 /** New payload: `task_add` previously returned only a prose confirmation. */
 export declare const taskAddOutputSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 /**
  * Both tools branch their TEXT on single-vs-batch, but the structured payload
@@ -146,6 +221,7 @@ export declare const taskPatchOutputSchema: z.ZodObject<{
         taskId: z.ZodString;
         success: z.ZodBoolean;
         error: z.ZodOptional<z.ZodString>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** New payload: `task_delete` previously returned only a prose confirmation. */
@@ -266,14 +342,6 @@ export declare const taskCompleteOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     issueId: z.ZodOptional<z.ZodString>;
     issueUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "destination">;
-/**
- * `brief` — per-agent attention digest.
- *
- * Object root (not a bare array of lanes) so both protocol eras hand clients
- * identical bytes, per note 3 above. `lastBriefAt` is nullable rather than
- * optional: "this agent has never briefed" is a meaningful state a client must
- * be able to distinguish from an omitted field.
- */
 export declare const briefOutputSchema: z.ZodObject<{
     agent: z.ZodString;
     mode: z.ZodEnum<{
@@ -293,5 +361,528 @@ export declare const briefOutputSchema: z.ZodObject<{
             at: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+            why: z.ZodString;
+            at: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    text: z.ZodOptional<z.ZodString>;
+    maxChars: z.ZodOptional<z.ZodNumber>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const decideOutputSchema: z.ZodObject<{
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        claimKey: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        stance: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodArray<z.ZodString>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    duplicate: z.ZodBoolean;
+    superseded: z.ZodArray<z.ZodString>;
+    familyWasEmpty: z.ZodBoolean;
+    related: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        claimKey: z.ZodString;
+        title: z.ZodString;
+        reason: z.ZodString;
+        coverage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    linked: z.ZodArray<z.ZodString>;
+    notFound: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** One family's verdict, or (with claimKeyPrefix) every family's and the worst. */
+export declare const checkOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    claimKey: z.ZodOptional<z.ZodString>;
+    verdict: z.ZodEnum<{
+        use: "use";
+        review: "review";
+        use_replacement: "use_replacement";
+        no_decision: "no_decision";
+    }>;
+    recommendation: z.ZodString;
+    reason: z.ZodString;
+    predicateStatus: z.ZodString;
+    predicates: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        status: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$loose>>;
+    recheck: z.ZodOptional<z.ZodString>;
+    advisory: z.ZodOptional<z.ZodString>;
+    stance: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    requestedAction: z.ZodOptional<z.ZodString>;
+    matched: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        claimKey: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        stance: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodArray<z.ZodString>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    current: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        claimKey: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        stance: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodArray<z.ZodString>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    replacement: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        claimKey: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        stance: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodArray<z.ZodString>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    family: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        claimKey: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        stance: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodArray<z.ZodString>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    matchedBy: z.ZodString;
+    exitCode: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    claimKeyPrefix: z.ZodString;
+    verdict: z.ZodEnum<{
+        use: "use";
+        review: "review";
+        use_replacement: "use_replacement";
+        no_decision: "no_decision";
+    }>;
+    recommendation: z.ZodString;
+    reason: z.ZodString;
+    decidingClaimKey: z.ZodOptional<z.ZodString>;
+    familyCount: z.ZodNumber;
+    families: z.ZodArray<z.ZodObject<{
+        query: z.ZodOptional<z.ZodString>;
+        claimKey: z.ZodOptional<z.ZodString>;
+        verdict: z.ZodEnum<{
+            use: "use";
+            review: "review";
+            use_replacement: "use_replacement";
+            no_decision: "no_decision";
+        }>;
+        recommendation: z.ZodString;
+        reason: z.ZodString;
+        predicateStatus: z.ZodString;
+        predicates: z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            status: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$loose>>;
+        recheck: z.ZodOptional<z.ZodString>;
+        advisory: z.ZodOptional<z.ZodString>;
+        stance: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        requestedAction: z.ZodOptional<z.ZodString>;
+        matched: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            status: z.ZodString;
+            claimKey: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            stance: z.ZodOptional<z.ZodString>;
+            subject: z.ZodOptional<z.ZodString>;
+            supersedes: z.ZodArray<z.ZodString>;
+            supersededBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        current: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            status: z.ZodString;
+            claimKey: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            stance: z.ZodOptional<z.ZodString>;
+            subject: z.ZodOptional<z.ZodString>;
+            supersedes: z.ZodArray<z.ZodString>;
+            supersededBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        replacement: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            status: z.ZodString;
+            claimKey: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            stance: z.ZodOptional<z.ZodString>;
+            subject: z.ZodOptional<z.ZodString>;
+            supersedes: z.ZodArray<z.ZodString>;
+            supersededBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        family: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            status: z.ZodString;
+            claimKey: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            stance: z.ZodOptional<z.ZodString>;
+            subject: z.ZodOptional<z.ZodString>;
+            supersedes: z.ZodArray<z.ZodString>;
+            supersededBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
+    exitCode: z.ZodNumber;
+}, z.core.$strip>]>;
+/** `note`: the line appended to a task's log. */
+export declare const noteOutputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    entry: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    isLog: z.ZodBoolean;
+}, z.core.$strip>;
+/** `log`: one task's log, a search of completed work, or the most recent. */
+export declare const logOutputSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        task: "task";
+        search: "search";
+        recent: "recent";
+    }>;
+    task: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completedAt: z.ZodOptional<z.ZodString>;
+        isLog: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+        log: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    query: z.ZodOptional<z.ZodString>;
+    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completedAt: z.ZodOptional<z.ZodString>;
+        match: z.ZodOptional<z.ZodString>;
+        ledgerOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** `columns`: the columns after the action, in order, with task counts. */
+export declare const columnsOutputSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        add: "add";
+        remove: "remove";
+        list: "list";
+        rename: "rename";
+        reorder: "reorder";
+    }>;
+    columns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completionColumn: z.ZodOptional<z.ZodBoolean>;
+        order: z.ZodOptional<z.ZodNumber>;
+        taskCount: z.ZodNumber;
+    }, z.core.$loose>>;
+    column: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completionColumn: z.ZodOptional<z.ZodBoolean>;
+        order: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    moved: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    movedTo: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completionColumn: z.ZodOptional<z.ZodBoolean>;
+        order: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+/** `board`: the board's own settings, after any change. */
+export declare const boardOutputSchema: z.ZodObject<{
+    title: z.ZodString;
+    instructions: z.ZodArray<z.ZodString>;
+    related: z.ZodArray<z.ZodObject<{
+        alias: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+    columns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completionColumn: z.ZodOptional<z.ZodBoolean>;
+        order: z.ZodOptional<z.ZodNumber>;
+        taskCount: z.ZodNumber;
+    }, z.core.$loose>>;
+    strict: z.ZodBoolean;
+    changed: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** `types`: every type and its place in the graph (spec-12). */
+export declare const typesOutputSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        add: "add";
+        list: "list";
+    }>;
+    strict: z.ZodBoolean;
+    types: z.ZodRecord<z.ZodString, z.ZodObject<{
+        idPrefix: z.ZodString;
+        completable: z.ZodOptional<z.ZodBoolean>;
+        schema: z.ZodOptional<z.ZodString>;
+        like: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    graph: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodString;
+        builtIn: z.ZodBoolean;
+        configured: z.ZodBoolean;
+        like: z.ZodOptional<z.ZodString>;
+        idPrefix: z.ZodString;
+        completable: z.ZodBoolean;
+        glyph: z.ZodString;
+        parents: z.ZodArray<z.ZodString>;
+        children: z.ZodArray<z.ZodString>;
+        work: z.ZodBoolean;
+        aliases: z.ZodArray<z.ZodString>;
+        summary: z.ZodString;
+        schema: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    aliasEntries: z.ZodArray<z.ZodString>;
+    added: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        entry: z.ZodObject<{
+            idPrefix: z.ZodString;
+            completable: z.ZodOptional<z.ZodBoolean>;
+            schema: z.ZodOptional<z.ZodString>;
+            like: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** `template`: the templates, or the task made from one. */
+export declare const templateOutputSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        use: "use";
+        list: "list";
+    }>;
+    templates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        priority: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        subtasks: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    task: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        template: z.ZodString;
+        column: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** `lint`: what it found and what fix changed. */
+export declare const lintOutputSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    issues: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            warning: "warning";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+        fixable: z.ZodOptional<z.ZodBoolean>;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    errorCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    fixableCount: z.ZodNumber;
+    fixed: z.ZodBoolean;
+    fixedCount: z.ZodNumber;
+    remaining: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            warning: "warning";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+        fixable: z.ZodOptional<z.ZodBoolean>;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** `sync`: fetch, merge and push a shared board (spec-9). */
+export declare const syncOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    skipped: z.ZodOptional<z.ZodEnum<{
+        "not-tracked": "not-tracked";
+        "no-remote": "no-remote";
+    }>>;
+    remote: z.ZodNullable<z.ZodString>;
+    remoteRef: z.ZodNullable<z.ZodString>;
+    pulled: z.ZodNumber;
+    pushed: z.ZodNumber;
+    conflicts: z.ZodArray<z.ZodString>;
+    warning: z.ZodOptional<z.ZodString>;
+    failure: z.ZodOptional<z.ZodString>;
+    movedFromBranch: z.ZodOptional<z.ZodString>;
+    autosync: z.ZodNullable<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const whereOutputSchema: z.ZodObject<{
+    path: z.ZodString;
+    storage: z.ZodEnum<{
+        plain: "plain";
+        branch: "branch";
+        repository: "repository";
+    }>;
+    branch: z.ZodNullable<z.ZodString>;
+    repository: z.ZodNullable<z.ZodString>;
+    remote: z.ZodNullable<z.ZodString>;
+    remoteUrl: z.ZodNullable<z.ZodString>;
+    remoteRef: z.ZodNullable<z.ZodString>;
+    webUrl: z.ZodNullable<z.ZodString>;
+    autosync: z.ZodNullable<z.ZodEnum<{
+        push: "push";
+        off: "off";
+        full: "full";
+    }>>;
+    lastSyncSecondsAgo: z.ZodNullable<z.ZodNumber>;
+    lastSyncOk: z.ZodNullable<z.ZodBoolean>;
+    pendingChanges: z.ZodNumber;
+    behind: z.ZodNumber;
+    boards: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            branch: "branch";
+            remote: "remote";
+            folder: "folder";
+            "code-branch": "code-branch";
+        }>;
+        ref: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        remote: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+        storage: z.ZodOptional<z.ZodEnum<{
+            plain: "plain";
+            linked: "linked";
+            standalone: "standalone";
+        }>>;
+        trackedBy: z.ZodOptional<z.ZodString>;
+        docs: z.ZodNumber;
+        lastChange: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    conflict: z.ZodNullable<z.ZodObject<{
+        current: z.ZodObject<{
+            kind: z.ZodEnum<{
+                branch: "branch";
+                remote: "remote";
+                folder: "folder";
+                "code-branch": "code-branch";
+            }>;
+            ref: z.ZodString;
+            label: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            remote: z.ZodOptional<z.ZodString>;
+            commit: z.ZodOptional<z.ZodString>;
+            storage: z.ZodOptional<z.ZodEnum<{
+                plain: "plain";
+                linked: "linked";
+                standalone: "standalone";
+            }>>;
+            trackedBy: z.ZodOptional<z.ZodString>;
+            docs: z.ZodNumber;
+            lastChange: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        other: z.ZodObject<{
+            kind: z.ZodEnum<{
+                branch: "branch";
+                remote: "remote";
+                folder: "folder";
+                "code-branch": "code-branch";
+            }>;
+            ref: z.ZodString;
+            label: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            remote: z.ZodOptional<z.ZodString>;
+            commit: z.ZodOptional<z.ZodString>;
+            storage: z.ZodOptional<z.ZodEnum<{
+                plain: "plain";
+                linked: "linked";
+                standalone: "standalone";
+            }>>;
+            trackedBy: z.ZodOptional<z.ZodString>;
+            docs: z.ZodNumber;
+            lastChange: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        relation: z.ZodEnum<{
+            same: "same";
+            contains: "contains";
+            contained: "contained";
+            diverged: "diverged";
+            unrelated: "unrelated";
+        }>;
+        message: z.ZodString;
+        resolve: z.ZodString;
+    }, z.core.$strip>>;
+    strayWorktrees: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        missing: z.ZodBoolean;
+    }, z.core.$strip>>;
+    outsideHome: z.ZodNullable<z.ZodString>;
+    trackedTwice: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            branch: "branch";
+            remote: "remote";
+            folder: "folder";
+            "code-branch": "code-branch";
+        }>;
+        ref: z.ZodString;
+        label: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        remote: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+        storage: z.ZodOptional<z.ZodEnum<{
+            plain: "plain";
+            linked: "linked";
+            standalone: "standalone";
+        }>>;
+        trackedBy: z.ZodOptional<z.ZodString>;
+        docs: z.ZodNumber;
+        lastChange: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** `retire`: the decision, now in logs/ with its status. */
+export declare const retireOutputSchema: z.ZodObject<{
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        claimKey: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodString>;
+        stance: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        supersedes: z.ZodArray<z.ZodString>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+/** `adr_promote`: a legacy ADR, accepted and moved to logs/. */
+export declare const adrPromoteOutputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodLiteral<"promoted">;
+    completedAt: z.ZodString;
 }, z.core.$strip>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/mcp/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/mcp/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAGhC,CAAC;AAIH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB9B,CAAC;AAmCH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;mBAI7B,CAAC;AAIH,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AAIH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAW/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;iBAShC,CAAC;AAIH,gFAAgF;AAChF,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;6BAsB9B,CAAC;AAaH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAgD/B,CAAC;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;kCAmBnC,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;iBAgB5B,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/mcp/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8DxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYhC,CAAC;AAIH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;IAqB9B,oEAAoE;;;IAGpE,wFAAwF;;;;;;IAExF,mEAAmE;;IAEnE;;;;OAIG;;;;;;;;iBAQH,CAAC;AAqDH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAI7B,CAAC;AAIH,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB;;;;;iBAO9B,CAAC;AAIH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAW/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAWhC,CAAC;AAIH,gFAAgF;AAChF,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;6BAsB9B,CAAC;AAaH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAgD/B,CAAC;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;kCAmBnC,CAAC;AAqBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAc5B,CAAC;AAiBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;iBAiB7B,CAAC;AAqBH,mFAAmF;AACnF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAY5B,CAAC;AAIH,iDAAiD;AACjD,eAAO,MAAM,gBAAgB;;;;;iBAO3B,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAsB1B,CAAC;AAYH,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ9B,CAAC;AAEH,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;iBAU5B,CAAC;AASH,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyB5B,CAAC;AAEH,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;iBAgB/B,CAAC;AAWH,kDAAkD;AAClD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW3B,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;iBAc3B,CAAC;AAiBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyB5B,CAAC;AAEH,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;iBAE7B,CAAC;AAEH,gEAAgE;AAChE,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC"}