@deksden-com/dd-flow-cli 0.4.2 → 0.6.0

package/dist/services/worktrees.js

@@ -8,7 +8,7 @@ import { projectCheckoutRoot, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { persistProtocolState, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 import { requireProjectByRoot } from "./projects.js";
-const worktrunkBinEnv = "DD_FLOW_WORKTRUNK_BIN";
+import { ensureManagedWorktrunk, inspectManagedWorktrunk } from "./tooling.js";
 export function planWorktree(context, input) {
     const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
     const state = readProtocolRuntimeState(context, protocol).state;
@@ -25,7 +25,7 @@ export function planWorktree(context, input) {
             owner: "dd-flow",
             purpose: "feature"
         },
-        worktrunk: detectWorktrunk(context)
+        worktrunk: inspectManagedWorktrunk(context)
     };
 }
 export function createWorktreeRecord(context, input) {
@@ -37,15 +37,16 @@ export function createWorktreeRecord(context, input) {
             worktree_path: existing.worktree_path
         });
     }
-    const worktrunk = requireWorktrunk(context);
-    const worktreePath = path.resolve(input.path);
-    if (isTrackedProjectPath(protocol.project_root, worktreePath)) {
-        throw new AppError("worktree_active", "Worktree path is inside tracked project files", 1, { path: worktreePath });
-    }
-    const command = [worktrunk.bin, "worktree", "create", "--branch", input.branch, "--base", input.base, "--path", worktreePath];
+    const worktrunk = ensureManagedWorktrunk(context);
+    const command = [worktrunk.bin, "-C", protocol.project_root, "switch", "--create", input.branch, "--base", input.base, "--no-cd", "--format=json", "-y"];
     const result = runExternal(command);
     if (result.exit_code !== 0) {
-        throw new AppError("tool_unavailable", "Worktrunk command failed", 1, { command: sanitizeCommand(command), result });
+        throw new AppError("worktrunk_command_unavailable", "Worktrunk switch failed", 1, { command: sanitizeCommand(command), result });
+    }
+    const response = parseWorktrunkResponse(result.stdout, command);
+    const worktreePath = response.workspace_path;
+    if (isTrackedProjectPath(protocol.project_root, worktreePath)) {
+        throw new AppError("worktree_active", "Worktrunk returned a workspace inside tracked project files", 1, { path: worktreePath });
     }
     const now = context.now();
     const state = readProtocolRuntimeState(context, protocol).state;
@@ -59,7 +60,7 @@ export function createWorktreeRecord(context, input) {
         input.branch,
         input.base,
         worktreePath,
-        JSON.stringify({ bin: worktrunk.bin }),
+        JSON.stringify({ bin: worktrunk.bin, version: worktrunk.version, command, response }),
         JSON.stringify(result),
         now,
         now
@@ -71,8 +72,8 @@ export function createWorktreeRecord(context, input) {
             feature_branch: input.branch,
             worktree_path: worktreePath,
             base_commit: input.base,
-            worktrunk: { bin: worktrunk.bin },
-            bootstrap: { status: "pending" }
+            worktrunk: { bin: worktrunk.bin, version: worktrunk.version, response },
+            bootstrap: { status: typeof response.bootstrap_status === "string" ? response.bootstrap_status : "pending" }
         },
         updated_at: now
     });
@@ -86,7 +87,7 @@ export function createWorktreeRecord(context, input) {
 }
 export function getWorktreeStatus(context, input) {
     const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
-    return { ok: true, protocol_id: protocol.id, worktree: worktreeRecord(context, protocol.project_id, protocol.id), worktrunk: detectWorktrunk(context) };
+    return { ok: true, protocol_id: protocol.id, worktree: worktreeRecord(context, protocol.project_id, protocol.id), worktrunk: inspectManagedWorktrunk(context) };
 }
 export function bootstrapWorktree(context, input) {
     const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
@@ -94,12 +95,32 @@ export function bootstrapWorktree(context, input) {
     if (!record) {
         throw new AppError("not_found", `Worktree record is not active for protocol: ${protocol.id}`, 1);
     }
+    const includeFile = path.join(protocol.project_root, ".worktreeinclude");
+    const configFile = path.join(protocol.project_root, ".config", "wt.toml");
+    if (!fs.existsSync(includeFile) || !fs.existsSync(configFile)) {
+        throw new AppError("bootstrap_unavailable", "Project-owned Worktrunk bootstrap files are required", 1, {
+            include_file: includeFile,
+            config_file: configFile,
+            next_action: "Add .worktreeinclude and .config/wt.toml before bootstrapping the workspace."
+        });
+    }
+    const worktrunk = ensureManagedWorktrunk(context);
+    const commands = [
+        [worktrunk.bin, "-C", record.worktree_path, "step", "copy-ignored", "--require-include"],
+        [worktrunk.bin, "-C", record.worktree_path, "hook", "pre-start", "--yes"]
+    ];
+    const results = [];
+    for (const command of commands) {
+        const result = runExternal(command);
+        results.push({ command: sanitizeCommand(command), ...result });
+        if (result.exit_code !== 0) {
+            const failed = { command: sanitizeCommand(command), result, results };
+            markBootstrapFailed(context, protocol, record, failed);
+            throw new AppError("bootstrap_failed", "Project-owned Worktrunk bootstrap failed", 1, failed);
+        }
+    }
     const now = context.now();
-    const result = {
-        exit_code: 0,
-        stdout: "No project bootstrap command configured.",
-        stderr: ""
-    };
+    const result = { commands: results, status: "succeeded" };
     context.db.run(`UPDATE worktree_records
      SET bootstrap_status = 'succeeded', last_command_result_json = ?, updated_at = ?
      WHERE project_id = ? AND protocol_id = ?`, [JSON.stringify(result), now, protocol.project_id, protocol.id]);
@@ -108,7 +129,7 @@ export function bootstrapWorktree(context, input) {
         ...state,
         workspace: {
             ...state.workspace,
-            bootstrap: { status: "succeeded", commands: [], blockers: [] }
+            bootstrap: { status: "succeeded", commands: results, blockers: [] }
         },
         updated_at: now
     });
@@ -116,7 +137,7 @@ export function bootstrapWorktree(context, input) {
         protocolId: protocol.id,
         projectId: protocol.project_id,
         eventType: "worktree.bootstrap_succeeded",
-        payload: { protocol_id: protocol.id, worktree_path: record.worktree_path }
+        payload: { protocol_id: protocol.id, worktree_path: record.worktree_path, commands: results }
     });
     return { ok: true, worktree: worktreeRecord(context, protocol.project_id, protocol.id) };
 }
@@ -167,24 +188,6 @@ export function worktreeRecord(context, projectId, protocolId) {
 function activeWorktreeRecord(context, projectId, protocolId) {
     return context.db.get("SELECT * FROM worktree_records WHERE project_id = ? AND protocol_id = ? AND status = 'active'", [projectId, protocolId]);
 }
-function detectWorktrunk(context) {
-    const configured = context.env[worktrunkBinEnv];
-    if (configured && fs.existsSync(configured)) {
-        return { available: true, bin: configured };
-    }
-    const probe = spawnSync("worktrunk", ["--version"], { encoding: "utf8" });
-    return probe.error ? { available: false, bin: null } : { available: true, bin: "worktrunk" };
-}
-function requireWorktrunk(context) {
-    const detected = detectWorktrunk(context);
-    if (!detected.available || !detected.bin) {
-        throw new AppError("tool_unavailable", "Worktrunk executable is unavailable", 1, {
-            tool: "worktrunk",
-            next_action: `Set ${worktrunkBinEnv} to a Worktrunk-compatible executable for local proof.`
-        });
-    }
-    return { bin: detected.bin };
-}
 function runExternal(command) {
     const [bin, ...args] = command;
     if (!bin) {
@@ -203,7 +206,53 @@ function sanitizeCommand(command) {
 function sanitizeOutput(value) {
     return value.replace(/(token|secret|password)=\S+/gi, "$1=<redacted>");
 }
+function parseWorktrunkResponse(stdout, command) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout.trim());
+    }
+    catch (error) {
+        throw new AppError("worktrunk_invalid_response", "Worktrunk did not return valid JSON", 1, {
+            command: sanitizeCommand(command),
+            stdout: sanitizeOutput(stdout),
+            cause: String(error)
+        });
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new AppError("worktrunk_invalid_response", "Worktrunk JSON response must be an object", 1, { command: sanitizeCommand(command) });
+    }
+    const response = parsed;
+    if (typeof response.workspace_path !== "string" || !path.isAbsolute(response.workspace_path)) {
+        throw new AppError("worktrunk_invalid_response", "Worktrunk response must contain an absolute workspace_path", 1, {
+            command: sanitizeCommand(command),
+            response
+        });
+    }
+    return { ...response, workspace_path: path.resolve(response.workspace_path) };
+}
+function markBootstrapFailed(context, protocol, record, failure) {
+    const now = context.now();
+    context.db.run(`UPDATE worktree_records
+     SET bootstrap_status = 'failed', last_command_result_json = ?, updated_at = ?
+     WHERE project_id = ? AND protocol_id = ?`, [JSON.stringify(failure), now, protocol.project_id, protocol.id]);
+    const state = readProtocolRuntimeState(context, protocol).state;
+    persistProtocolState(context, protocol, {
+        ...state,
+        workspace: {
+            ...state.workspace,
+            worktree_path: record.worktree_path,
+            bootstrap: { status: "failed", commands: failure.results ?? [], blockers: [failure] }
+        },
+        updated_at: now
+    });
+    appendAudit(context, {
+        protocolId: protocol.id,
+        projectId: protocol.project_id,
+        eventType: "worktree.bootstrap_failed",
+        payload: { protocol_id: protocol.id, worktree_path: record.worktree_path, failure }
+    });
+}
 function isTrackedProjectPath(projectRoot, candidate) {
     const relative = path.relative(projectRoot, candidate);
-    return Boolean(relative && !relative.startsWith("..") && !path.isAbsolute(relative) && !relative.startsWith(".tasks"));
+    return !relative || (!relative.startsWith("..") && !path.isAbsolute(relative));
 }

package/dist/storage/database.js

@@ -60,15 +60,34 @@ function migrate(db) {
       FOREIGN KEY(project_id) REFERENCES projects(id)
     );
 
-    CREATE TABLE IF NOT EXISTS plans (
+    CREATE TABLE IF NOT EXISTS plan_bindings (
       project_id TEXT NOT NULL,
       protocol_id TEXT NOT NULL,
-      plan_json TEXT NOT NULL,
+      plan_revision INTEGER NOT NULL,
+      plan_sha256 TEXT NOT NULL,
+      plan_path TEXT NOT NULL,
+      bound_at TEXT NOT NULL,
       updated_at TEXT NOT NULL,
       PRIMARY KEY(project_id, protocol_id),
       FOREIGN KEY(project_id, protocol_id) REFERENCES protocols(project_id, id)
     );
 
+    CREATE TABLE IF NOT EXISTS plan_progress (
+      project_id TEXT NOT NULL,
+      protocol_id TEXT NOT NULL,
+      item_id TEXT NOT NULL,
+      plan_revision INTEGER NOT NULL,
+      plan_sha256 TEXT NOT NULL,
+      status TEXT NOT NULL,
+      summary TEXT NOT NULL DEFAULT '',
+      evidence_json TEXT NOT NULL DEFAULT '[]',
+      block_reason TEXT,
+      user_required INTEGER NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY(project_id, protocol_id, item_id),
+      FOREIGN KEY(project_id, protocol_id) REFERENCES protocols(project_id, id)
+    );
+
     CREATE TABLE IF NOT EXISTS audit_events (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       protocol_id TEXT,
@@ -313,6 +332,9 @@ function migrate(db) {
       total_tokens INTEGER,
       input_tokens INTEGER,
       cached_input_tokens INTEGER,
+      cache_read_input_tokens INTEGER,
+      cache_write_input_tokens INTEGER,
+      uncached_input_tokens INTEGER,
       output_tokens INTEGER,
       reasoning_output_tokens INTEGER,
       source_kind TEXT NOT NULL,
@@ -329,34 +351,62 @@ function migrate(db) {
     CREATE INDEX IF NOT EXISTS idx_flow_run_usage_snapshots_run
       ON flow_run_usage_snapshots(project_id, run_id, session_id, observed_at, id);
 
-    CREATE TABLE IF NOT EXISTS pending_flow_session_bindings (
-      session_id TEXT NOT NULL,
+    CREATE TABLE IF NOT EXISTS codex_hook_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
       project_id TEXT NOT NULL,
-      payload_json TEXT NOT NULL,
-      cwd TEXT,
-      transcript_path TEXT,
+      protocol_id TEXT,
+      session_id TEXT,
       turn_id TEXT,
+      event_key TEXT,
+      event_name TEXT NOT NULL,
+      tool_name TEXT,
       status TEXT NOT NULL,
+      sanitized_summary TEXT NOT NULL,
       created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY(session_id, project_id),
       FOREIGN KEY(project_id) REFERENCES projects(id)
     );
 
-    CREATE TABLE IF NOT EXISTS codex_hook_events (
+    CREATE TABLE IF NOT EXISTS flow_session_segments (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       project_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      run_id TEXT,
       protocol_id TEXT,
-      session_id TEXT,
-      turn_id TEXT,
-      event_name TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      ended_at TEXT,
+      cwd TEXT,
       tool_name TEXT,
+      event_key TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_flow_session_segments_session
+      ON flow_session_segments(project_id, session_id, started_at, id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_flow_session_segments_event
+      ON flow_session_segments(project_id, event_key);
+
+    CREATE TABLE IF NOT EXISTS flow_jobs (
+      job_id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      protocol_id TEXT,
+      plan_item_id TEXT NOT NULL,
+      group_id TEXT,
       status TEXT NOT NULL,
-      sanitized_summary TEXT NOT NULL,
-      created_at TEXT NOT NULL,
+      worker_session_id TEXT,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      last_error TEXT,
+      registered_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      started_at TEXT,
+      finished_at TEXT,
+      UNIQUE(project_id, run_id, plan_item_id),
       FOREIGN KEY(project_id) REFERENCES projects(id)
     );
 
+    CREATE INDEX IF NOT EXISTS idx_flow_jobs_resume
+      ON flow_jobs(project_id, run_id, status, plan_item_id);
+
     CREATE TABLE IF NOT EXISTS worktree_records (
       protocol_id TEXT NOT NULL,
       project_id TEXT NOT NULL,
@@ -399,9 +449,16 @@ function migrate(db) {
     ensureColumn(db, "flow_sessions", "plan_item_id", "ALTER TABLE flow_sessions ADD COLUMN plan_item_id TEXT");
     ensureColumn(db, "flow_sessions", "session_kind", "ALTER TABLE flow_sessions ADD COLUMN session_kind TEXT");
     ensureColumn(db, "flow_sessions", "coverage_units_json", "ALTER TABLE flow_sessions ADD COLUMN coverage_units_json TEXT NOT NULL DEFAULT '[]'");
+    ensureColumn(db, "flow_run_usage_snapshots", "cache_read_input_tokens", "ALTER TABLE flow_run_usage_snapshots ADD COLUMN cache_read_input_tokens INTEGER");
+    ensureColumn(db, "flow_run_usage_snapshots", "cache_write_input_tokens", "ALTER TABLE flow_run_usage_snapshots ADD COLUMN cache_write_input_tokens INTEGER");
+    ensureColumn(db, "flow_run_usage_snapshots", "uncached_input_tokens", "ALTER TABLE flow_run_usage_snapshots ADD COLUMN uncached_input_tokens INTEGER");
+    db.prepare("UPDATE flow_run_usage_snapshots SET cache_read_input_tokens = cached_input_tokens WHERE cache_read_input_tokens IS NULL AND cached_input_tokens IS NOT NULL").run();
     ensureColumn(db, "flow_runs", "run_home_path", "ALTER TABLE flow_runs ADD COLUMN run_home_path TEXT");
     ensureColumn(db, "flow_runs", "layout_version", "ALTER TABLE flow_runs ADD COLUMN layout_version TEXT");
     ensureColumn(db, "flow_runs", "artifact_root_kind", "ALTER TABLE flow_runs ADD COLUMN artifact_root_kind TEXT");
+    ensureColumn(db, "codex_hook_events", "event_key", "ALTER TABLE codex_hook_events ADD COLUMN event_key TEXT");
+    ensureColumn(db, "flow_jobs", "updated_at", "ALTER TABLE flow_jobs ADD COLUMN updated_at TEXT NOT NULL DEFAULT ''");
+    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_codex_hook_events_event_key ON codex_hook_events(project_id, event_key) WHERE event_key IS NOT NULL");
     ensureColumn(db, "lane_waiters", "expires_at", "ALTER TABLE lane_waiters ADD COLUMN expires_at TEXT");
     db.exec(`
     CREATE INDEX IF NOT EXISTS idx_flow_runs_project_updated
@@ -420,7 +477,6 @@ function migrateProjectScopedIdentity(db) {
     PRAGMA foreign_keys = OFF;
     BEGIN IMMEDIATE;
 
-    ALTER TABLE plans RENAME TO plans_legacy_global_identity;
     ALTER TABLE merge_queue RENAME TO merge_queue_legacy_global_identity;
     ALTER TABLE worktree_records RENAME TO worktree_records_legacy_global_identity;
     ALTER TABLE flow_runs RENAME TO flow_runs_legacy_global_identity;
@@ -455,19 +511,6 @@ function migrateProjectScopedIdentity(db) {
         state_path, plan_path, created_at, updated_at
       FROM protocols_legacy_global_identity;
 
-    CREATE TABLE plans (
-      project_id TEXT NOT NULL,
-      protocol_id TEXT NOT NULL,
-      plan_json TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY(project_id, protocol_id),
-      FOREIGN KEY(project_id, protocol_id) REFERENCES protocols(project_id, id)
-    );
-    INSERT INTO plans (project_id, protocol_id, plan_json, updated_at)
-      SELECT p.project_id, legacy.protocol_id, legacy.plan_json, legacy.updated_at
-      FROM plans_legacy_global_identity legacy
-      JOIN protocols p ON p.id = legacy.protocol_id;
-
     CREATE TABLE merge_queue (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       protocol_id TEXT NOT NULL,
@@ -554,7 +597,6 @@ function migrateProjectScopedIdentity(db) {
         artifact_root_kind, index_json, created_at, updated_at, completed_at
       FROM flow_runs_legacy_global_identity;
 
-    DROP TABLE plans_legacy_global_identity;
     DROP TABLE merge_queue_legacy_global_identity;
     DROP TABLE worktree_records_legacy_global_identity;
     DROP TABLE flow_runs_legacy_global_identity;

package/dist/storage/paths.js

@@ -24,9 +24,6 @@ export function runtimeProtocolDir(ddFlowHome, projectId, protocolId) {
 export function runtimeStateJsonPath(ddFlowHome, projectId, protocolId) {
     return path.join(runtimeProtocolDir(ddFlowHome, projectId, protocolId), "state.json");
 }
-export function runtimePlanJsonPath(ddFlowHome, projectId, protocolId) {
-    return path.join(runtimeProtocolDir(ddFlowHome, projectId, protocolId), "plan.json");
-}
 export function runtimeRunDir(ddFlowHome, projectId, runId) {
     return path.join(projectRuntimeRoot(ddFlowHome, projectId), "runs", runId);
 }
@@ -39,9 +36,6 @@ export function projectRunHome(ddFlowHome, projectId, runId) {
 export function projectRunJsonPath(ddFlowHome, projectId, runId) {
     return path.join(projectRunHome(ddFlowHome, projectId, runId), "run.json");
 }
-export function projectRunIndexPath(ddFlowHome, projectId, runId) {
-    return path.join(projectRunHome(ddFlowHome, projectId, runId), "run-index.json");
-}
 export function projectRunStageDir(ddFlowHome, projectId, runId, stageDir) {
     return path.join(projectRunHome(ddFlowHome, projectId, runId), stageDir);
 }
@@ -51,9 +45,6 @@ export function userFacingRunDir(workspaceRoot, runId) {
 export function legacyWorkspaceRunDir(workspaceRoot, runId) {
     return userFacingRunDir(workspaceRoot, runId);
 }
-export function userFacingRunIndexPath(workspaceRoot, runId) {
-    return path.join(userFacingRunDir(workspaceRoot, runId), "run-index.json");
-}
 export function userFacingRunStageDir(workspaceRoot, runId, stageDir) {
     return path.join(userFacingRunDir(workspaceRoot, runId), stageDir);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "bin": {
@@ -9,12 +9,22 @@
   "files": [
     "dist",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "tools"
   ],
   "engines": {
     "node": ">=26.0.0",
     "pnpm": ">=10.0.0"
   },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/generate-build-info.mjs && node scripts/copy-assets.mjs",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --max-warnings=0",
+    "test": "vitest run",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "pnpm run build && changeset publish"
+  },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
     "@eslint/js": "^9.39.1",
@@ -32,14 +42,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/generate-build-info.mjs && node scripts/copy-assets.mjs",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint . --max-warnings=0",
-    "test": "vitest run",
-    "changeset": "changeset",
-    "version-packages": "changeset version",
-    "release": "pnpm run build && changeset publish"
-  }
-}
+  "license": "MIT"
+}

package/tools/worktrunk-manifest.json

@@ -0,0 +1,34 @@
+{
+  "schema_id": "dd-flow/managed-tool-manifest@1",
+  "tool": "wt",
+  "version": "0.72.0",
+  "repository": "https://github.com/max-sixty/worktrunk",
+  "release_tag": "v0.72.0",
+  "artifacts": {
+    "darwin-arm64": {
+      "url": "https://github.com/max-sixty/worktrunk/releases/download/v0.72.0/worktrunk-aarch64-apple-darwin.tar.xz",
+      "sha256": "7e6cf79a3ef67559240431aae93c137d9a2b28a8ccdb55b64edead904b21ff73",
+      "archive": "tar.xz"
+    },
+    "darwin-x64": {
+      "url": "https://github.com/max-sixty/worktrunk/releases/download/v0.72.0/worktrunk-x86_64-apple-darwin.tar.xz",
+      "sha256": "2356bee43a6688a03d24b27dd18ce0db1f4666f111ee06f3c829d1f248472401",
+      "archive": "tar.xz"
+    },
+    "linux-arm64": {
+      "url": "https://github.com/max-sixty/worktrunk/releases/download/v0.72.0/worktrunk-aarch64-unknown-linux-musl.tar.xz",
+      "sha256": "2f6b45fd0592e4b0f66ca3c34cbaf90c7643a7eaabf8a9c4b0e12d48251a086c",
+      "archive": "tar.xz"
+    },
+    "linux-x64": {
+      "url": "https://github.com/max-sixty/worktrunk/releases/download/v0.72.0/worktrunk-x86_64-unknown-linux-musl.tar.xz",
+      "sha256": "e91bc7ceb0623942a797317f56541a825d6a36e24d055985a8299d30345be346",
+      "archive": "tar.xz"
+    },
+    "windows-x64": {
+      "url": "https://github.com/max-sixty/worktrunk/releases/download/v0.72.0/worktrunk-x86_64-pc-windows-msvc.zip",
+      "sha256": "cd1933e9c40836df460b6feb732999d20387bfda41da6e0972b392fadd087c03",
+      "archive": "zip"
+    }
+  }
+}