@4-r-c-4-n-4/todo 0.1.4 → 0.1.6

package/BIBLE.md

@@ -140,6 +140,19 @@ git branch -d todo/<parent-id>
 
 If you need manual control instead of a loop, use `todo work --skip-branch <child-id>` to activate a child without a redundant checkout. Do NOT use plain `todo work` for subsequent children on a shared branch — it performs a no-op checkout and prints confusing resume output.
 
+### Branch Protection (recommended)
+
+The local-merge step above is convenient for solo work, but `todo` is built for agent-driven flows where unreviewed code shouldn't land on `main` silently. GitHub's branch-protection rules close that gap without adding any process inside the tool — turn them on once and the same `todo` workflow stops bypassing review.
+
+For `main`, enable:
+
+- **Require a pull request before merging** — the agent stops at the PR; you click Merge.
+- **Require status checks to pass** — your CI's `Lint, typecheck, test` job. Catches the kind of regression that this session's commit `b6709ed` (missing `pretest` hook) would have stopped on red.
+- **Require linear history** — enforces the skill's `--no-ff` rule. Squash merges would orphan the resolution-commit SHAs stored in `.todo/done/<id>.json`.
+- **Require approvals (optional)** — even for a solo repo, setting "1 approval" forces you to actually open the PR and skim the diff before clicking through. Cheap insurance against autopilot merges.
+
+Once protected, the closing step becomes `todo pr` (push branch + open PR + stop) instead of a local merge. The local-merge sequence in the previous sections remains valid for unprotected repos or quick solo work.
+
 ---
 
 ## Ticket Types

package/dist/branch-guard.d.ts

@@ -0,0 +1,18 @@
+import type { Ticket } from "./types.js";
+export declare function expectedBranchFor(ticket: Ticket): string;
+export interface BranchCheck {
+    ok: boolean;
+    message?: string;
+}
+export declare function checkOnExpectedBranch(ticket: Ticket, currentBranch: string): BranchCheck;
+export declare function checkBranchHasTodoCommit(ticket: Ticket, repoRoot: string, commitPrefix: string): BranchCheck;
+/**
+ * True iff the ticket has at least one child AND every child is in a
+ * terminal state (done/wontfix/duplicate). Parents in this shape carry no
+ * code commit of their own — the work lives in children whose commits use
+ * `todo:<child-id>` prefixes — so the commit-prefix branch guard should
+ * skip them. Children with missing files are treated as non-terminal so
+ * the guard stays conservative.
+ */
+export declare function isParentWithAllChildrenClosed(ticket: Ticket, repoRoot: string): boolean;
+export declare function checkWorkingTreeClean(repoRoot: string): BranchCheck;

package/dist/branch-guard.js

@@ -0,0 +1,80 @@
+"use strict";
+// Branch-convention guards used by `todo close` and `todo work`.
+//
+// These turn the conventions documented in the todo-implement skill into
+// hard preconditions: agents follow exit codes far more reliably than
+// prose, so every drift gets a clear, actionable error.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectedBranchFor = expectedBranchFor;
+exports.checkOnExpectedBranch = checkOnExpectedBranch;
+exports.checkBranchHasTodoCommit = checkBranchHasTodoCommit;
+exports.isParentWithAllChildrenClosed = isParentWithAllChildrenClosed;
+exports.checkWorkingTreeClean = checkWorkingTreeClean;
+const git_js_1 = require("./git.js");
+const ticket_js_1 = require("./ticket.js");
+function expectedBranchFor(ticket) {
+    if (ticket.work?.branch)
+        return ticket.work.branch;
+    if (ticket.relationships?.parent)
+        return `todo/${ticket.relationships.parent}`;
+    return `todo/${ticket.id}`;
+}
+function checkOnExpectedBranch(ticket, currentBranch) {
+    const expected = expectedBranchFor(ticket);
+    if (currentBranch === expected)
+        return { ok: true };
+    return {
+        ok: false,
+        message: `Refusing to close ${ticket.id}: HEAD is on '${currentBranch}', expected '${expected}'.\n` +
+            `  Run \`todo work ${ticket.id}\` to switch to the right branch, ` +
+            `or pass --force to override.`,
+    };
+}
+function checkBranchHasTodoCommit(ticket, repoRoot, commitPrefix) {
+    const base = ticket.work?.base_branch ?? (0, git_js_1.getDefaultBranch)(repoRoot);
+    const messages = (0, git_js_1.getCommitMessagesBetween)(base, "HEAD", repoRoot);
+    const needle = `${commitPrefix}${ticket.id}`;
+    const found = messages.some((m) => m.includes(needle));
+    if (found)
+        return { ok: true };
+    return {
+        ok: false,
+        message: `Refusing to close ${ticket.id}: no commit since ${base} has message containing '${needle}'.\n` +
+            `  Either amend a commit to include the prefix, or pass --force ` +
+            `if this ticket genuinely has no code change attached.`,
+    };
+}
+/**
+ * True iff the ticket has at least one child AND every child is in a
+ * terminal state (done/wontfix/duplicate). Parents in this shape carry no
+ * code commit of their own — the work lives in children whose commits use
+ * `todo:<child-id>` prefixes — so the commit-prefix branch guard should
+ * skip them. Children with missing files are treated as non-terminal so
+ * the guard stays conservative.
+ */
+function isParentWithAllChildrenClosed(ticket, repoRoot) {
+    const children = ticket.relationships?.children ?? [];
+    if (children.length === 0)
+        return false;
+    for (const childId of children) {
+        let child;
+        try {
+            child = (0, ticket_js_1.readTicket)(repoRoot, childId);
+        }
+        catch {
+            return false;
+        }
+        if (!ticket_js_1.TERMINAL_STATES.includes(child.state))
+            return false;
+    }
+    return true;
+}
+function checkWorkingTreeClean(repoRoot) {
+    if (!(0, git_js_1.hasUncommittedChanges)(repoRoot))
+        return { ok: true };
+    return {
+        ok: false,
+        message: "Refusing to switch branches: working tree has uncommitted changes.\n" +
+            "  Commit, stash, or discard them first.",
+    };
+}

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const commander_1 = require("commander");
 const analyze_js_1 = require("./commands/analyze.js");
 const close_js_1 = require("./commands/close.js");
@@ -8,19 +10,25 @@ const dedup_js_1 = require("./commands/dedup.js");
 const edit_js_1 = require("./commands/edit.js");
 const export_js_1 = require("./commands/export.js");
 const init_js_1 = require("./commands/init.js");
+const install_hooks_js_1 = require("./commands/install-hooks.js");
 const link_js_1 = require("./commands/link.js");
 const list_js_1 = require("./commands/list.js");
 const new_js_1 = require("./commands/new.js");
 const next_js_1 = require("./commands/next.js");
+const pr_js_1 = require("./commands/pr.js");
 const scan_js_1 = require("./commands/scan.js");
 const show_js_1 = require("./commands/show.js");
+const sync_js_1 = require("./commands/sync.js");
 const transition_js_1 = require("./commands/transition.js");
 const work_js_1 = require("./commands/work.js");
+// Read version from the package.json shipped alongside dist/. Avoids drift
+// between the published npm version and what `todo --version` prints.
+const pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "..", "package.json"), "utf8"));
 const program = new commander_1.Command();
 program
     .name("todo")
     .description("Git-native work tracking for coding agents")
-    .version("1.0.0");
+    .version(pkg.version);
 (0, init_js_1.registerInit)(program);
 (0, new_js_1.registerNew)(program);
 (0, list_js_1.registerList)(program);
@@ -35,4 +43,7 @@ program
 (0, link_js_1.registerLink)(program);
 (0, scan_js_1.registerScan)(program);
 (0, dedup_js_1.registerDedup)(program);
+(0, install_hooks_js_1.registerInstallHooks)(program);
+(0, sync_js_1.registerSync)(program);
+(0, pr_js_1.registerPr)(program);
 program.parse(process.argv);

package/dist/commands/close.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerClose = registerClose;
+const branch_guard_js_1 = require("../branch-guard.js");
+const config_js_1 = require("../config.js");
 const context_js_1 = require("../context.js");
 const errors_js_1 = require("../errors.js");
 const git_js_1 = require("../git.js");
@@ -14,11 +16,40 @@ function registerClose(program) {
         .option("--test <file::func>", "test file and function (colon-separated)")
         .option("--note <text>", "resolution note")
         .option("--checkout", "git checkout base_branch after closing")
+        .option("--force", "skip branch and commit-message guards")
         .action((id, opts) => {
         const ctx = (0, context_js_1.getContext)(true);
-        const { repoRoot } = ctx;
+        const { repoRoot, config } = ctx;
         try {
             const ticket = (0, ticket_js_1.readTicketByPrefix)(repoRoot, id);
+            // Branch-convention guards (skippable with --force).
+            if (!opts.force) {
+                let currentBranch = "";
+                try {
+                    currentBranch = (0, git_js_1.getCurrentBranch)(repoRoot);
+                }
+                catch {
+                    // Detached HEAD or other; treat as a branch mismatch.
+                }
+                const branchCheck = (0, branch_guard_js_1.checkOnExpectedBranch)(ticket, currentBranch);
+                if (!branchCheck.ok) {
+                    console.error(`Error: ${branchCheck.message}`);
+                    process.exit(1);
+                }
+                // Parents with all-terminal children carry no code commit of
+                // their own — skip the commit-prefix check for them. The
+                // branch-match check above still fires.
+                if (!(0, branch_guard_js_1.isParentWithAllChildrenClosed)(ticket, repoRoot)) {
+                    const commitCheck = (0, branch_guard_js_1.checkBranchHasTodoCommit)(ticket, repoRoot, (0, config_js_1.getCommitPrefix)(config));
+                    if (!commitCheck.ok) {
+                        console.error(`Error: ${commitCheck.message}`);
+                        process.exit(1);
+                    }
+                }
+            }
+            else {
+                console.error("Warning: --force used; skipping branch guards.");
+            }
             // Resolve commit
             let commit;
             if (opts.commit) {

package/dist/commands/install-hooks.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerInstallHooks(program: Command): void;

package/dist/commands/install-hooks.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInstallHooks = registerInstallHooks;
+const config_js_1 = require("../config.js");
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const hooks_js_1 = require("../hooks.js");
+function reportInstall(name, res) {
+    if (res.action === "refused") {
+        console.error(`Error: ${res.reason}`);
+        return false;
+    }
+    console.log(`${name}: ${res.action} ${res.path}`);
+    return true;
+}
+function reportUninstall(name, res) {
+    if (res.action === "refused") {
+        console.error(`Error: ${res.reason}`);
+        return false;
+    }
+    console.log(res.reason
+        ? `${name}: ${res.reason} (${res.path})`
+        : `${name}: removed ${res.path}`);
+    return true;
+}
+function selectHooks(opts) {
+    if (opts.onlySync)
+        return ["post-commit"];
+    if (opts.withSync)
+        return ["prepare-commit-msg", "post-commit"];
+    return ["prepare-commit-msg"];
+}
+function renderHook(name, config) {
+    if (name === "prepare-commit-msg") {
+        return (0, hooks_js_1.renderPrepareCommitMsg)((0, config_js_1.getCommitPrefix)(config));
+    }
+    return (0, hooks_js_1.renderPostCommit)();
+}
+function registerInstallHooks(program) {
+    program
+        .command("install-hooks")
+        .description("Install git hooks enforcing todo conventions (prepare-commit-msg, optionally post-commit auto-sync)")
+        .option("--force", "overwrite hooks not managed by todo")
+        .option("--uninstall", "remove managed hooks instead of installing")
+        .option("--with-sync", "also install the post-commit hook that runs `todo sync --quiet` after each commit")
+        .option("--only-sync", "install or uninstall only the post-commit auto-sync hook (skip prepare-commit-msg)")
+        .action((opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot, config } = ctx;
+        try {
+            const hooks = selectHooks(opts);
+            let failed = false;
+            for (const name of hooks) {
+                if (opts.uninstall) {
+                    const res = (0, hooks_js_1.uninstallHook)(repoRoot, name, {
+                        force: !!opts.force,
+                    });
+                    if (!reportUninstall(name, res))
+                        failed = true;
+                }
+                else {
+                    const content = renderHook(name, config);
+                    const res = (0, hooks_js_1.installHook)(repoRoot, name, content, {
+                        force: !!opts.force,
+                    });
+                    if (!reportInstall(name, res))
+                        failed = true;
+                }
+            }
+            if (failed)
+                process.exit(1);
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/pr.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerPr(program: Command): void;

package/dist/commands/pr.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPr = registerPr;
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const git_js_1 = require("../git.js");
+const pr_js_1 = require("../pr.js");
+const ticket_js_1 = require("../ticket.js");
+function registerPr(program) {
+    program
+        .command("pr")
+        .description("Push the current todo/<id> branch and open (or update) a GitHub PR")
+        .option("--base <branch>", "PR base branch (default: repo default)")
+        .option("--draft", "open the PR as a draft")
+        .action((opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot } = ctx;
+        try {
+            let branch;
+            try {
+                branch = (0, git_js_1.getCurrentBranch)(repoRoot);
+            }
+            catch {
+                console.error("Error: could not resolve current branch (detached HEAD?).");
+                process.exit(1);
+            }
+            const id = (0, pr_js_1.branchToTicketId)(branch);
+            if (!id) {
+                console.error(`Error: not on a todo/<id> branch (HEAD is on '${branch}').\n` +
+                    "  Run `todo work <id>` first.");
+                process.exit(1);
+            }
+            let ticket;
+            try {
+                ticket = (0, ticket_js_1.readTicket)(repoRoot, id);
+            }
+            catch {
+                console.error(`Error: branch '${branch}' references ticket '${id}' but no .todo/ ` +
+                    "file exists for it. Was it deleted?");
+                process.exit(1);
+            }
+            const outcome = (0, pr_js_1.runPr)(repoRoot, branch, ticket, { base: opts.base, draft: !!opts.draft }, (0, pr_js_1.defaultPrEnv)(repoRoot));
+            if (outcome.kind === "error") {
+                console.error(`Error: ${outcome.message}`);
+                process.exit(1);
+            }
+            console.log(outcome.kind === "created"
+                ? `Opened PR: ${outcome.url}`
+                : `Updated PR: ${outcome.url}`);
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSync(program: Command): void;

package/dist/commands/sync.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSync = registerSync;
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const hermes_js_1 = require("../hermes.js");
+const ticket_js_1 = require("../ticket.js");
+function summariseAction(a) {
+    if (a.kind === "create") {
+        return `+ create ${a.ticket.id} (${a.ticket.state}) → ${a.targetStatus}`;
+    }
+    if (a.kind === "update") {
+        return `~ update ${a.ticket.id} ${a.fromStatus} → ${a.toStatus}`;
+    }
+    if (a.kind === "noop") {
+        return `= ${a.ticket.id} unchanged (${a.status})`;
+    }
+    return `! skip ${a.ticket.id}: ${a.reason}`;
+}
+function registerSync(program) {
+    program
+        .command("sync")
+        .description("Push ticket state to a Hermes Kanban board")
+        .option("--dry-run", "show what would change without contacting Hermes")
+        .option("--quiet", "only print errors")
+        .option("--board <slug>", "override the configured board slug")
+        .action(async (opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot, config } = ctx;
+        try {
+            const resolved = (0, hermes_js_1.resolveHermesConfig)(config.hermes, process.env, opts.board);
+            if ("error" in resolved) {
+                console.error(`Error: ${resolved.error}`);
+                process.exit(1);
+            }
+            const open = (0, ticket_js_1.listTickets)(repoRoot, "open");
+            const done = (0, ticket_js_1.listTickets)(repoRoot, "done");
+            const tickets = [...open, ...done];
+            const client = (0, hermes_js_1.makeKanbanClient)(resolved);
+            const existingByHermesId = new Map();
+            if (!opts.dryRun) {
+                const board = await client.getBoard();
+                for (const col of board.columns) {
+                    for (const task of col.tasks) {
+                        // Tasks come back with their per-column status; trust it.
+                        existingByHermesId.set(task.id, { ...task, status: col.name });
+                    }
+                }
+            }
+            else {
+                // In dry-run we can't reach the server; treat ids we have cached
+                // in tickets as existing (best-effort preview only).
+                for (const t of tickets) {
+                    const hid = t.external_refs?.hermes_task_id;
+                    if (hid) {
+                        existingByHermesId.set(hid, {
+                            id: hid,
+                            title: t.summary,
+                            status: "?",
+                        });
+                    }
+                }
+            }
+            const actions = (0, hermes_js_1.planSyncActions)(tickets, existingByHermesId);
+            if (!opts.quiet) {
+                for (const a of actions)
+                    console.log(summariseAction(a));
+            }
+            if (opts.dryRun) {
+                if (!opts.quiet)
+                    console.log("(dry run — no requests made)");
+                return;
+            }
+            const stats = await (0, hermes_js_1.applySyncActions)(actions, client, (ticket, hermesId) => {
+                const refs = ticket.external_refs ?? {};
+                refs.hermes_task_id = hermesId;
+                refs.hermes_board = resolved.board;
+                ticket.external_refs = refs;
+                ticket.updated_at = new Date().toISOString();
+                (0, ticket_js_1.writeTicket)(repoRoot, ticket);
+            });
+            if (!opts.quiet) {
+                console.log(`done: ${stats.created} created, ${stats.updated} updated, ` +
+                    `${stats.noop} unchanged, ${stats.skipped} skipped`);
+            }
+            // fetch keep-alive sockets can hold the event loop open for ~30s
+            // past completion; for a CLI we want a snappy exit.
+            process.exit(0);
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/work.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerWork = registerWork;
+const branch_guard_js_1 = require("../branch-guard.js");
 const context_js_1 = require("../context.js");
 const errors_js_1 = require("../errors.js");
 const git_js_1 = require("../git.js");
@@ -51,6 +52,27 @@ function registerWork(program) {
                 }
             }
             const defaultBranch = (0, git_js_1.getDefaultBranch)(repoRoot);
+            // Dirty-tree guard: refuse to leave a different todo/* branch
+            // with uncommitted work. We let `main`/other branches through —
+            // only the cross-ticket case is the one that loses work.
+            if (!opts.skipBranch) {
+                let currentBranch = "";
+                try {
+                    currentBranch = (0, git_js_1.getCurrentBranch)(repoRoot);
+                }
+                catch {
+                    currentBranch = "";
+                }
+                const onDifferentTodoBranch = currentBranch.startsWith("todo/") && currentBranch !== branch;
+                if (onDifferentTodoBranch) {
+                    const clean = (0, branch_guard_js_1.checkWorkingTreeClean)(repoRoot);
+                    if (!clean.ok) {
+                        console.error(`Error: ${clean.message}\n  You are on ${currentBranch}; ` +
+                            `target branch is ${branch}.`);
+                        process.exit(1);
+                    }
+                }
+            }
             if (opts.skipBranch) {
                 // --no-branch: orchestrator mode — activate on current branch without any git ops
                 const currentBranch = (0, git_js_1.getCurrentBranch)(repoRoot);

package/dist/git.d.ts

@@ -17,3 +17,6 @@ export declare function getLastCommitForFile(path: string, cwd?: string): string
 export declare function createBranch(name: string, cwd?: string): void;
 export declare function checkoutBranch(name: string, cwd?: string): void;
 export declare function getGitUserName(cwd?: string): string;
+export declare function hasUncommittedChanges(cwd?: string): boolean;
+export declare function getCommitMessagesBetween(base: string, head: string, cwd?: string): string[];
+export declare function getGitDir(cwd?: string): string;

package/dist/git.js

@@ -17,6 +17,9 @@ exports.getLastCommitForFile = getLastCommitForFile;
 exports.createBranch = createBranch;
 exports.checkoutBranch = checkoutBranch;
 exports.getGitUserName = getGitUserName;
+exports.hasUncommittedChanges = hasUncommittedChanges;
+exports.getCommitMessagesBetween = getCommitMessagesBetween;
+exports.getGitDir = getGitDir;
 const node_child_process_1 = require("node:child_process");
 class GitError extends Error {
     cause;
@@ -117,3 +120,24 @@ function checkoutBranch(name, cwd = process.cwd()) {
 function getGitUserName(cwd = process.cwd()) {
     return exec(["config", "user.name"], cwd);
 }
+function hasUncommittedChanges(cwd = process.cwd()) {
+    const out = exec(["status", "--porcelain"], cwd);
+    return out.length > 0;
+}
+function getCommitMessagesBetween(base, head, cwd = process.cwd()) {
+    try {
+        const out = exec(["log", `${base}..${head}`, "--format=%s%n%b%n--END--"], cwd);
+        if (!out)
+            return [];
+        return out
+            .split("\n--END--")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function getGitDir(cwd = process.cwd()) {
+    return exec(["rev-parse", "--git-dir"], cwd);
+}

package/dist/hermes.d.ts

@@ -0,0 +1,59 @@
+import type { HermesConfig, State, Ticket } from "./types.js";
+export declare const STATE_TO_KANBAN: Record<State, string>;
+export interface ResolvedHermesConfig {
+    dashboard_url: string;
+    board: string;
+    session_token: string;
+}
+export declare function resolveHermesConfig(cfg: HermesConfig | undefined, env?: NodeJS.ProcessEnv, boardOverride?: string): ResolvedHermesConfig | {
+    error: string;
+};
+export interface KanbanTask {
+    id: string;
+    title: string;
+    status: string;
+    body?: string;
+}
+export interface KanbanClient {
+    getBoard(): Promise<{
+        columns: {
+            name: string;
+            tasks: KanbanTask[];
+        }[];
+    }>;
+    getTask(id: string): Promise<KanbanTask | null>;
+    createTask(payload: {
+        title: string;
+        body?: string;
+        idempotency_key?: string;
+    }): Promise<KanbanTask>;
+    updateStatus(id: string, status: string): Promise<KanbanTask>;
+}
+export declare function makeKanbanClient(cfg: ResolvedHermesConfig, fetchImpl?: typeof fetch): KanbanClient;
+export type SyncAction = {
+    kind: "create";
+    ticket: Ticket;
+    targetStatus: string;
+} | {
+    kind: "update";
+    ticket: Ticket;
+    hermesId: string;
+    fromStatus: string;
+    toStatus: string;
+} | {
+    kind: "noop";
+    ticket: Ticket;
+    hermesId: string;
+    status: string;
+} | {
+    kind: "skip";
+    ticket: Ticket;
+    reason: string;
+};
+export declare function planSyncActions(tickets: Ticket[], existingByHermesId: Map<string, KanbanTask>): SyncAction[];
+export declare function applySyncActions(actions: SyncAction[], client: KanbanClient, onPersistId: (ticket: Ticket, hermesId: string) => void): Promise<{
+    created: number;
+    updated: number;
+    skipped: number;
+    noop: number;
+}>;