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

package/dist/services/sessions.js

@@ -6,10 +6,19 @@ import { parseJsonObject } from "../shared/json.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { cancelLaneWaitersForWorker } from "./lanes.js";
+import { checkpointSessionUsage } from "./usage.js";
+import { refreshRunSessionProjection } from "./run-projection.js";
+import { appendFlowRunTimelineEvent } from "./runs.js";
 export function registerFlowSession(context, input) {
     const payload = decodeFlowSessionPayload(input);
     const project = requireProjectByRoot(context, resolveProjectRoot(payload.project_root));
     const session = upsertFlowSession(context, project, payload, input.sessionId);
+    if (session.run_id)
+        appendFlowRunTimelineEvent(context, project.id, session.run_id, { type: "session_bound", session_id: session.session_id });
+    if (session.run_id)
+        refreshRunSessionProjection(context, project.id, session.run_id);
+    if (session.run_id)
+        checkpointSessionUsage(context, session, { checkpoint: "run_started", stage: session.current_stage });
     appendAudit(context, {
         projectId: project.id,
         eventType: "flow_session.registered",
@@ -38,9 +47,21 @@ export function getFlowSessionStatus(context, input) {
 export function stopFlowSession(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const session = requireFlowSession(context, project.id, input.sessionId);
+    if (session.run_id)
+        checkpointSessionUsage(context, session, { checkpoint: "session_stopped", stage: session.current_stage });
     markSessionStopped(context, project, session, input.reason);
+    if (session.run_id)
+        refreshRunSessionProjection(context, project.id, session.run_id);
     return { ok: true, session: flowSessionById(context, project.id, input.sessionId) };
 }
+export function syncFlowSessionUsage(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const session = requireFlowSession(context, project.id, input.sessionId);
+    if (!session.run_id) {
+        return { ok: true, session_id: session.session_id, extraction_status: "not_observable", diagnostic: "session_not_bound_to_run" };
+    }
+    return { ok: true, snapshot: checkpointSessionUsage(context, session, { checkpoint: "manual_sync", stage: session.current_stage }) };
+}
 export function stopMergeWorker(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const sessions = flowSessionsForProject(context, project.id, { workerId: input.workerId }).filter((session) => session.flow_kind === "merge_worker" && ["active", "pending", "stopping"].includes(session.status));
@@ -101,6 +122,8 @@ export function updateFlowSessionContinuation(context, projectId, sessionId, act
     context.db.run(`UPDATE flow_sessions
      SET continuation_count = ?, last_action_hash = ?, updated_at = ?
      WHERE project_id = ? AND session_id = ?`, [nextCount, actionHash, context.now(), projectId, sessionId]);
+    if (session.run_id)
+        refreshRunSessionProjection(context, projectId, session.run_id);
     return nextCount;
 }
 export function recordPendingFlowSessionBinding(context, project, input) {
@@ -148,6 +171,8 @@ export function confirmPendingFlowSessionBinding(context, project, input) {
         cwd: pending.cwd ?? payload.cwd ?? null,
         transcript_path: pending.transcript_path ?? payload.transcript_path ?? null
     }, input.sessionId);
+    if (session.run_id)
+        refreshRunSessionProjection(context, project.id, session.run_id);
     context.db.run(`UPDATE pending_flow_session_bindings SET status = 'confirmed', updated_at = ?
      WHERE project_id = ? AND session_id = ?`, [context.now(), project.id, input.sessionId]);
     appendAudit(context, {
@@ -205,6 +230,12 @@ function normalizeFlowSessionPayload(payload) {
         project_root: projectRoot,
         flow_kind: flowKind,
         run_id: stringField(payload, "run_id", false) ?? null,
+        parent_session_id: stringField(payload, "parent_session_id", false) ?? null,
+        role: stringField(payload, "role", false) ?? null,
+        aspect_id: stringField(payload, "aspect_id", false) ?? null,
+        plan_item_id: stringField(payload, "plan_item_id", false) ?? null,
+        session_kind: sessionKind(payload),
+        coverage_units: normalizeCoverageUnits(payload.coverage_units),
         protocol_id: stringField(payload, "protocol_id", false) ?? null,
         worker_id: stringField(payload, "worker_id", false) ?? null,
         workspace_path: stringField(payload, "workspace_path", false) ?? null,
@@ -221,15 +252,24 @@ function upsertFlowSession(context, project, payload, forcedSessionId) {
     const sessionId = forcedSessionId ?? payload.session_id ?? payload.worker_id ?? payload.protocol_id ?? crypto.randomUUID();
     const workspacePath = payload.workspace_path ?? payload.cwd ?? project.root;
     context.db.run(`INSERT INTO flow_sessions
-      (session_id, project_id, project_root, flow_kind, status, run_id, protocol_id, worker_id, workspace_path,
+      (session_id, project_id, project_root, flow_kind, status, run_id, parent_session_id, role, aspect_id, plan_item_id, session_kind, protocol_id, worker_id, workspace_path,
        continuation_policy, current_stage, next_action, last_action_hash, continuation_count, stop_reason,
-       transcript_path, cwd, metadata_json, created_at, updated_at, stopped_at)
-     VALUES (?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, NULL, 0, NULL, ?, ?, ?, ?, ?, NULL)
+       transcript_path, cwd, metadata_json, coverage_units_json, created_at, updated_at, stopped_at)
+     VALUES (
+       ?, ?, ?, ?, 'active',
+       ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, 0, NULL,
+       ?, ?, ?, ?, ?, ?, NULL
+     )
      ON CONFLICT(session_id, project_id) DO UPDATE SET
        project_root = excluded.project_root,
        flow_kind = excluded.flow_kind,
        status = 'active',
        run_id = excluded.run_id,
+       parent_session_id = excluded.parent_session_id,
+       role = excluded.role,
+       aspect_id = excluded.aspect_id,
+       plan_item_id = excluded.plan_item_id,
+       session_kind = excluded.session_kind,
        protocol_id = excluded.protocol_id,
        worker_id = excluded.worker_id,
        workspace_path = excluded.workspace_path,
@@ -239,6 +279,7 @@ function upsertFlowSession(context, project, payload, forcedSessionId) {
        transcript_path = COALESCE(excluded.transcript_path, transcript_path),
        cwd = COALESCE(excluded.cwd, cwd),
        metadata_json = excluded.metadata_json,
+       coverage_units_json = excluded.coverage_units_json,
        updated_at = excluded.updated_at,
        stop_reason = NULL,
        stopped_at = NULL`, [
@@ -247,6 +288,11 @@ function upsertFlowSession(context, project, payload, forcedSessionId) {
         project.root,
         payload.flow_kind,
         payload.run_id ?? null,
+        payload.parent_session_id ?? null,
+        payload.role ?? null,
+        payload.aspect_id ?? null,
+        payload.plan_item_id ?? null,
+        payload.session_kind ?? null,
         payload.protocol_id,
         payload.worker_id,
         workspacePath,
@@ -256,6 +302,7 @@ function upsertFlowSession(context, project, payload, forcedSessionId) {
         payload.transcript_path ?? null,
         payload.cwd ?? null,
         JSON.stringify(payload.metadata ?? {}),
+        JSON.stringify(payload.coverage_units ?? []),
         now,
         now
     ]);
@@ -273,6 +320,10 @@ function markSessionStopped(context, project, session, reason) {
     context.db.run(`UPDATE flow_sessions
      SET status = 'stopped', stop_reason = ?, updated_at = ?, stopped_at = ?
      WHERE project_id = ? AND session_id = ?`, [reason, now, now, project.id, session.session_id]);
+    if (session.run_id)
+        appendFlowRunTimelineEvent(context, project.id, session.run_id, { type: "session_stopped", session_id: session.session_id });
+    if (session.run_id)
+        refreshRunSessionProjection(context, project.id, session.run_id);
     let lockRelease = undefined;
     let waiterCancellation = undefined;
     if (session.worker_id) {
@@ -364,6 +415,33 @@ function stringField(payload, key, required) {
     }
     return undefined;
 }
+function sessionKind(payload) {
+    const value = stringField(payload, "session_kind", false);
+    if (!value)
+        return null;
+    if (["orchestrator", "llm_worker", "runtime_worker"].includes(value)) {
+        return value;
+    }
+    throw new AppError("validation", "session_kind is not supported", 2, { session_kind: value });
+}
+function normalizeCoverageUnits(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value)) {
+        throw new AppError("validation", "coverage_units must be an array", 2);
+    }
+    return value.map((item, index) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw new AppError("validation", `coverage_units[${index}] must be an object`, 2);
+        }
+        const object = item;
+        if (typeof object.unit_id !== "string" || object.unit_id.length === 0) {
+            throw new AppError("validation", `coverage_units[${index}].unit_id is required`, 2);
+        }
+        const optional = (key) => object[key] === undefined || object[key] === null ? null : typeof object[key] === "string" ? object[key] : (() => { throw new AppError("validation", `coverage_units[${index}].${key} must be a string`, 2); })();
+        return { unit_id: object.unit_id, group_id: optional("group_id"), job_id: optional("job_id"), kind: optional("kind") };
+    });
+}
 function requiredStringField(payload, key) {
     const value = stringField(payload, key, true);
     if (!value) {

package/dist/services/status.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
+import { loadProjectFlowContract } from "../domain/flow-contract.js";
+import { AppError } from "../shared/errors.js";
 import { getCanonStatus } from "./canon.js";
 import { getCliBuildInfo } from "./build-info.js";
 import { getProjectVersionStatus, resolveStatusProjectRoot } from "./version-status.js";
@@ -25,6 +27,7 @@ export function getRuntimeStatus(context, input = {}) {
     const compatibilityManifest = resolvedCanonForProject ? readCompatibilityManifest(canon) : null;
     const cliCompatibility = cliCompatibilityVerdict(cli, compatibilityManifest);
     const engineSelection = projectRoot ? selectEngine(context, { projectRoot }) : null;
+    const flowContract = projectRoot ? projectFlowContractStatus(projectRoot) : null;
     const registry = input.checkRegistry ? checkNpmRegistry(context, cli.package_name) : undefined;
     return {
         ok: true,
@@ -45,7 +48,8 @@ export function getRuntimeStatus(context, input = {}) {
             status: project?.status ?? null,
             memory_bank: projectVersionStatus?.memory_bank ?? null,
             flow_pack: projectVersionStatus?.flow_pack ?? null,
-            drift: projectVersionStatus?.drift ?? null
+            drift: projectVersionStatus?.drift ?? null,
+            flow_contract: flowContract
         },
         engine: engineSelection
             ? {
@@ -60,6 +64,33 @@ export function getRuntimeStatus(context, input = {}) {
         }
     };
 }
+function projectFlowContractStatus(projectRoot) {
+    try {
+        const contract = loadProjectFlowContract(projectRoot);
+        return { status: "valid", id: contract.id, version: contract.version, diagnostic: null, action: null };
+    }
+    catch (error) {
+        if (!(error instanceof AppError))
+            throw error;
+        const file = typeof error.details.file === "string"
+            ? error.details.file
+            : path.join(projectRoot, ".memory-bank", "dd-flow", "flow-contract.json");
+        return {
+            status: "degraded",
+            id: null,
+            version: null,
+            diagnostic: {
+                code: "flow_contract_invalid",
+                path: typeof error.details.path === "string" ? error.details.path : "/",
+                message: error.message
+            },
+            action: {
+                code: "repair_or_upgrade_flow_contract",
+                command: `dd-flow schema validate --schema flow-contract --file "${file}" --project-root "${projectRoot}" --json`
+            }
+        };
+    }
+}
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }

package/dist/services/usage.js

@@ -0,0 +1,233 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+export function checkpointSessionUsage(context, session, input) {
+    const observedAt = context.now();
+    const result = readCodexTranscript(session.transcript_path, session.session_id);
+    const snapshot = {
+        id: `USG-${crypto.randomUUID()}`,
+        ...session,
+        checkpoint: input.checkpoint,
+        stage: input.stage ?? null,
+        stage_attempt: input.stageAttempt ?? null,
+        observed_at: observedAt,
+        total_tokens: result.counter?.usage.total_tokens ?? null,
+        input_tokens: result.counter?.usage.input_tokens ?? null,
+        cached_input_tokens: result.counter?.usage.cached_input_tokens ?? null,
+        output_tokens: result.counter?.usage.output_tokens ?? null,
+        reasoning_output_tokens: result.counter?.usage.reasoning_output_tokens ?? null,
+        source_kind: "codex_transcript_v1",
+        token_event_at: result.counter?.token_event_at ?? null,
+        turn_id: result.counter?.turn_id ?? null,
+        turn_attribution: result.counter?.turn_attribution ?? "unavailable",
+        parser_version: 1,
+        extraction_status: result.status,
+        diagnostic_code: result.diagnostic ?? null
+    };
+    const previous = context.db.get(`SELECT s.*, f.parent_session_id, f.role, f.aspect_id, f.plan_item_id, f.session_kind
+       FROM flow_run_usage_snapshots s
+       LEFT JOIN flow_sessions f ON f.project_id = s.project_id AND f.session_id = s.session_id
+      WHERE s.project_id = ? AND s.run_id = ? AND s.session_id = ? AND s.checkpoint = ?
+      ORDER BY s.observed_at DESC, s.id DESC LIMIT 1`, [session.project_id, session.run_id, session.session_id, input.checkpoint]);
+    if (previous && sameUsageSnapshot(previous, snapshot)) {
+        return snapshotForOutput(previous);
+    }
+    context.db.run(`INSERT INTO flow_run_usage_snapshots
+      (id, project_id, run_id, session_id, checkpoint, stage, stage_attempt, observed_at,
+       total_tokens, input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens,
+       source_kind, token_event_at, turn_id, turn_attribution, parser_version, extraction_status, diagnostic_code, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        snapshot.id, snapshot.project_id, snapshot.run_id, snapshot.session_id, snapshot.checkpoint, snapshot.stage,
+        snapshot.stage_attempt, snapshot.observed_at, snapshot.total_tokens, snapshot.input_tokens,
+        snapshot.cached_input_tokens, snapshot.output_tokens, snapshot.reasoning_output_tokens, snapshot.source_kind,
+        snapshot.token_event_at, snapshot.turn_id, snapshot.turn_attribution, snapshot.parser_version,
+        snapshot.extraction_status, snapshot.diagnostic_code, observedAt
+    ]);
+    return snapshotForOutput(snapshot);
+}
+export function checkpointRunUsage(context, input) {
+    const sessions = context.db.all(`SELECT session_id, project_id, run_id, transcript_path, parent_session_id, role, aspect_id, plan_item_id, session_kind
+     FROM flow_sessions WHERE project_id = ? AND run_id = ?`, [input.projectId, input.runId]);
+    return sessions.map((session) => checkpointSessionUsage(context, session, input));
+}
+export function usageForRun(context, input) {
+    const sessions = context.db.all(`SELECT session_id, project_id, run_id, transcript_path, parent_session_id, role, aspect_id, plan_item_id, session_kind
+     FROM flow_sessions WHERE project_id = ? AND run_id = ?`, [input.projectId, input.runId]);
+    const refreshed = sessions.map((session) => checkpointSessionUsage(context, session, { checkpoint: "manual_sync" }));
+    const rows = context.db.all(`SELECT s.*, f.parent_session_id, f.role, f.aspect_id, f.plan_item_id, f.session_kind
+     FROM flow_run_usage_snapshots s
+     LEFT JOIN flow_sessions f ON f.project_id = s.project_id AND f.session_id = s.session_id
+     WHERE s.project_id = ? AND s.run_id = ? ORDER BY s.session_id, s.observed_at, s.id`, [input.projectId, input.runId]);
+    const deltas = usageDeltas(rows);
+    const supported = new Set(["session", "role", "aspect", "plan-item", "stage", "protocol"]);
+    const groupBy = supported.has(input.groupBy) ? input.groupBy : "session";
+    const groups = new Map();
+    for (const delta of deltas) {
+        const key = groupKey(delta, groupBy);
+        const group = groups.get(key) ?? { tokens: zeroUsage(), snapshots: 0, statuses: {}, transition_buckets: 0 };
+        group.snapshots += 1;
+        group.statuses[delta.extraction_status] = (group.statuses[delta.extraction_status] ?? 0) + 1;
+        if (delta.usage)
+            addUsage(group.tokens, delta.usage);
+        if (delta.transition)
+            group.transition_buckets += 1;
+        groups.set(key, group);
+    }
+    return {
+        ok: true,
+        schema_id: "dd-flow/run-usage@1",
+        run_id: input.runId,
+        source: { kind: "codex_transcript_v1", parser_version: 1, refreshed_sessions: refreshed.length },
+        sessions: sessions.map((session) => ({
+            session_id: session.session_id, parent_session_id: session.parent_session_id ?? null, role: session.role ?? null,
+            aspect_id: session.aspect_id ?? null, plan_item_id: session.plan_item_id ?? null, session_kind: session.session_kind ?? null
+        })),
+        groups: [...groups.entries()].map(([key, group]) => ({ key, ...group })),
+        deltas,
+        coverage: coverageForRows(rows)
+    };
+}
+function readCodexTranscript(transcriptPath, expectedSessionId) {
+    if (!transcriptPath)
+        return { status: "ephemeral_session", diagnostic: "transcript_path_missing" };
+    if (!fs.existsSync(transcriptPath))
+        return { status: "transcript_missing", diagnostic: "transcript_path_missing" };
+    try {
+        const lines = fs.readFileSync(transcriptPath, "utf8").split(/\r?\n/);
+        let sessionId;
+        let nearestTurn = null;
+        let latest;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const payload = object(event.payload);
+            if (event.type === "session_meta")
+                sessionId = stringValue(payload?.id) ?? sessionId;
+            if (event.type === "event_msg" && payload?.type === "task_started")
+                nearestTurn = stringValue(payload.turn_id) ?? nearestTurn;
+            if (event.type !== "event_msg" || payload?.type !== "token_count")
+                continue;
+            const info = object(payload.info);
+            const total = object(info?.total_token_usage);
+            const parsed = parseUsage(total);
+            if (parsed)
+                latest = { usage: parsed, token_event_at: stringValue(event.timestamp) ?? null, turn_id: nearestTurn, turn_attribution: nearestTurn ? "inferred_nearest_task_started" : "unavailable" };
+        }
+        if (sessionId && sessionId !== expectedSessionId)
+            return { status: "session_mismatch", diagnostic: "transcript_session_id_mismatch" };
+        if (!latest)
+            return { status: "not_yet_emitted", diagnostic: "token_count_not_found" };
+        return { status: "measured", counter: latest };
+    }
+    catch {
+        return { status: "malformed_source", diagnostic: "transcript_read_failed" };
+    }
+}
+function usageDeltas(rows) {
+    const previous = new Map();
+    return rows.map((row) => {
+        const prior = previous.get(row.session_id);
+        previous.set(row.session_id, row);
+        const measured = row.extraction_status === "measured" && prior?.extraction_status === "measured";
+        const reset = measured && prior ? counterReset(row, prior) : false;
+        const usage = measured && prior && !reset ? subtractUsage(row, prior) : null;
+        const transition = reset
+            ? { transition: "counter_reset", attribution: "cross_stage_turn", confidence: "indeterminate" }
+            : measured && prior?.stage && row.stage && prior.stage !== row.stage
+                ? { transition: `${prior.stage} -> ${row.stage}`, attribution: "cross_stage_turn", confidence: "indeterminate" }
+                : null;
+        return {
+            snapshot_id: row.id, session_id: row.session_id, checkpoint: row.checkpoint, observed_at: row.observed_at,
+            stage: row.stage, role: row.role ?? null, aspect_id: row.aspect_id ?? null, plan_item_id: row.plan_item_id ?? null,
+            extraction_status: reset ? "stale_source" : row.extraction_status, usage: transition ? null : usage,
+            ...(transition ? transition : {}), source: { kind: row.source_kind, token_event_at: row.token_event_at, turn_id: row.turn_id, turn_attribution: row.turn_attribution }
+        };
+    });
+}
+function subtractUsage(current, previous) {
+    return {
+        total_tokens: (current.total_tokens ?? 0) - (previous.total_tokens ?? 0),
+        input_tokens: current.input_tokens === null || previous.input_tokens === null ? null : current.input_tokens - previous.input_tokens,
+        cached_input_tokens: current.cached_input_tokens === null || previous.cached_input_tokens === null ? null : current.cached_input_tokens - previous.cached_input_tokens,
+        output_tokens: current.output_tokens === null || previous.output_tokens === null ? null : current.output_tokens - previous.output_tokens,
+        reasoning_output_tokens: current.reasoning_output_tokens === null || previous.reasoning_output_tokens === null ? null : current.reasoning_output_tokens - previous.reasoning_output_tokens
+    };
+}
+function counterReset(current, previous) {
+    return [
+        [current.total_tokens, previous.total_tokens],
+        [current.input_tokens, previous.input_tokens],
+        [current.cached_input_tokens, previous.cached_input_tokens],
+        [current.output_tokens, previous.output_tokens],
+        [current.reasoning_output_tokens, previous.reasoning_output_tokens]
+    ].some(([now, before]) => typeof now === "number" && typeof before === "number" && now < before);
+}
+function groupKey(delta, groupBy) {
+    if (groupBy === "stage")
+        return String(delta.stage ?? delta.transition ?? "unattributed");
+    if (groupBy === "role")
+        return delta.role ?? "unassigned";
+    if (groupBy === "aspect")
+        return delta.aspect_id ?? "unassigned";
+    if (groupBy === "plan-item")
+        return delta.plan_item_id ?? "unassigned";
+    return String(delta.session_id ?? "unknown");
+}
+function coverageForRows(rows) {
+    return rows.reduce((result, row) => {
+        result[row.extraction_status] = (result[row.extraction_status] ?? 0) + 1;
+        return result;
+    }, {});
+}
+function snapshotForOutput(snapshot) {
+    const safe = { ...snapshot };
+    delete safe.transcript_path;
+    return { schema_id: "dd-flow/session-usage-snapshot@1", ...safe };
+}
+function sameUsageSnapshot(previous, current) {
+    return previous.stage === current.stage
+        && previous.stage_attempt === current.stage_attempt
+        && previous.extraction_status === current.extraction_status
+        && previous.total_tokens === current.total_tokens
+        && previous.input_tokens === current.input_tokens
+        && previous.cached_input_tokens === current.cached_input_tokens
+        && previous.output_tokens === current.output_tokens
+        && previous.reasoning_output_tokens === current.reasoning_output_tokens
+        && previous.token_event_at === current.token_event_at
+        && previous.turn_id === current.turn_id;
+}
+function parseUsage(value) {
+    if (!value)
+        return undefined;
+    const total = numberValue(value.total_tokens);
+    if (total === undefined)
+        return undefined;
+    return {
+        total_tokens: total,
+        input_tokens: numberValue(value.input_tokens) ?? null,
+        cached_input_tokens: numberValue(value.cached_input_tokens) ?? null,
+        output_tokens: numberValue(value.output_tokens) ?? null,
+        reasoning_output_tokens: numberValue(value.reasoning_output_tokens) ?? null
+    };
+}
+function addUsage(target, source) {
+    target.total_tokens += source.total_tokens;
+    if (source.input_tokens !== null)
+        target.input_tokens += source.input_tokens;
+    if (source.cached_input_tokens !== null)
+        target.cached_input_tokens += source.cached_input_tokens;
+    if (source.output_tokens !== null)
+        target.output_tokens += source.output_tokens;
+    if (source.reasoning_output_tokens !== null)
+        target.reasoning_output_tokens += source.reasoning_output_tokens;
+}
+function zeroUsage() { return { total_tokens: 0, input_tokens: 0, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0 }; }
+function object(value) { return value && typeof value === "object" && !Array.isArray(value) ? value : undefined; }
+function stringValue(value) { return typeof value === "string" && value ? value : undefined; }
+function numberValue(value) { return typeof value === "number" && Number.isFinite(value) ? value : undefined; }

package/dist/services/worktrees.js

@@ -4,12 +4,13 @@ import { spawnSync } from "node:child_process";
 import { flowContractForState } from "../domain/flow-contract.js";
 import { requireStage } from "../domain/validation.js";
 import { AppError } from "../shared/errors.js";
-import { projectCheckoutRoot } from "../storage/paths.js";
+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";
 export function planWorktree(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
+    const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
     const state = readProtocolRuntimeState(context, protocol).state;
     const suggestedPath = path.join(projectCheckoutRoot(context.ddFlowHome, protocol.project_id), "worktrees", protocol.id, path.basename(protocol.project_root));
     return {
@@ -28,8 +29,8 @@ export function planWorktree(context, input) {
     };
 }
 export function createWorktreeRecord(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
-    const existing = activeWorktreeRecord(context, protocol.id);
+    const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
+    const existing = activeWorktreeRecord(context, protocol.project_id, protocol.id);
     if (existing) {
         throw new AppError("worktree_already_exists", "Protocol already has an active worktree record", 1, {
             protocol_id: protocol.id,
@@ -81,15 +82,15 @@ export function createWorktreeRecord(context, input) {
         eventType: "worktree.created",
         payload: { protocol_id: protocol.id, feature_branch: input.branch, base: input.base, path: worktreePath }
     });
-    return { ok: true, worktree: activeWorktreeRecord(context, protocol.id) };
+    return { ok: true, worktree: activeWorktreeRecord(context, protocol.project_id, protocol.id) };
 }
 export function getWorktreeStatus(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
-    return { ok: true, protocol_id: protocol.id, worktree: worktreeRecord(context, protocol.id), worktrunk: detectWorktrunk(context) };
+    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) };
 }
 export function bootstrapWorktree(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
-    const record = activeWorktreeRecord(context, protocol.id);
+    const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
+    const record = activeWorktreeRecord(context, protocol.project_id, protocol.id);
     if (!record) {
         throw new AppError("not_found", `Worktree record is not active for protocol: ${protocol.id}`, 1);
     }
@@ -101,7 +102,7 @@ export function bootstrapWorktree(context, input) {
     };
     context.db.run(`UPDATE worktree_records
      SET bootstrap_status = 'succeeded', last_command_result_json = ?, updated_at = ?
-     WHERE protocol_id = ?`, [JSON.stringify(result), now, protocol.id]);
+     WHERE project_id = ? AND protocol_id = ?`, [JSON.stringify(result), now, protocol.project_id, protocol.id]);
     const state = readProtocolRuntimeState(context, protocol).state;
     persistProtocolState(context, protocol, {
         ...state,
@@ -117,14 +118,14 @@ export function bootstrapWorktree(context, input) {
         eventType: "worktree.bootstrap_succeeded",
         payload: { protocol_id: protocol.id, worktree_path: record.worktree_path }
     });
-    return { ok: true, worktree: worktreeRecord(context, protocol.id) };
+    return { ok: true, worktree: worktreeRecord(context, protocol.project_id, protocol.id) };
 }
 export function closeWorktree(context, input) {
     if (!["keep", "remove"].includes(input.mode)) {
         throw new AppError("validation", "--mode must be keep or remove", 2);
     }
-    const protocol = requireProtocol(context, input.protocolId);
-    const record = activeWorktreeRecord(context, protocol.id);
+    const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
+    const record = activeWorktreeRecord(context, protocol.project_id, protocol.id);
     if (!record) {
         throw new AppError("not_found", `Worktree record is not active for protocol: ${protocol.id}`, 1);
     }
@@ -137,7 +138,7 @@ export function closeWorktree(context, input) {
     }
     const now = context.now();
     const nextStatus = input.mode === "keep" ? "kept" : fs.existsSync(record.worktree_path) ? "kept" : "removed";
-    context.db.run(`UPDATE worktree_records SET status = ?, updated_at = ?, closed_at = ? WHERE protocol_id = ?`, [nextStatus, now, now, protocol.id]);
+    context.db.run(`UPDATE worktree_records SET status = ?, updated_at = ?, closed_at = ? WHERE project_id = ? AND protocol_id = ?`, [nextStatus, now, now, protocol.project_id, protocol.id]);
     appendAudit(context, {
         protocolId: protocol.id,
         projectId: protocol.project_id,
@@ -146,21 +147,25 @@ export function closeWorktree(context, input) {
     });
     return {
         ok: true,
-        worktree: worktreeRecord(context, protocol.id),
+        worktree: worktreeRecord(context, protocol.project_id, protocol.id),
         outcome: {
             status: nextStatus,
             reason: nextStatus === "removed" ? "path_absent" : input.mode === "remove" ? "physical_checkout_kept" : "keep_requested"
         }
     };
 }
+function scopedProtocol(context, projectRoot, protocolId) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(projectRoot));
+    return requireProtocol(context, protocolId, project.id);
+}
 export function worktreeRecordsForProject(context, projectId) {
     return context.db.all(`SELECT * FROM worktree_records WHERE project_id = ? ORDER BY updated_at DESC`, [projectId]);
 }
-export function worktreeRecord(context, protocolId) {
-    return context.db.get("SELECT * FROM worktree_records WHERE protocol_id = ?", [protocolId]);
+export function worktreeRecord(context, projectId, protocolId) {
+    return context.db.get("SELECT * FROM worktree_records WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
 }
-function activeWorktreeRecord(context, protocolId) {
-    return context.db.get("SELECT * FROM worktree_records WHERE protocol_id = ? AND status = 'active'", [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];