@deksden-com/dd-flow-cli 0.7.0 → 0.8.0

package/dist/services/ids.js

@@ -4,8 +4,9 @@ import { formatFullId, parseFullEntityId } from "../domain/entity-ids.js";
 import { AppError } from "../shared/errors.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 const kindConfig = {
-    protocol: { type: "PRT", table: "protocols", fileRoot: ".memory-bank/protocol" },
-    run: { type: "RUN", table: "flow_runs" }
+    protocol: { type: "PRT", table: "protocols", idField: "id", fileRoot: ".memory-bank/protocol" },
+    run: { type: "RUN", table: "runs", idField: "id" },
+    work: { type: "WRK", table: "works", idField: "work_id" }
 };
 export function previewNextEntityId(context, input) {
     const projectRoot = resolveProjectRoot(input.projectRoot);
@@ -14,7 +15,7 @@ export function previewNextEntityId(context, input) {
     const config = kindConfig[kind];
     const used = new Set();
     const project = context.db.get("SELECT id FROM projects WHERE root = ?", [projectRoot]);
-    for (const id of databaseIds(context, config.table, config.type, project?.id)) {
+    for (const id of databaseIds(context, config.table, config.idField, config.type, project?.id)) {
         addSequence(used, id, config.type);
     }
     if (config.fileRoot) {
@@ -39,19 +40,28 @@ export function previewNextEntityId(context, input) {
         }
     };
 }
+/** Work ids are globally allocated because work_id is the database primary key. */
+export function nextWorkId(context, _projectId, slug) {
+    const used = new Set();
+    for (const row of context.db.all("SELECT work_id AS id FROM works WHERE work_id LIKE ?", ["WRK-%"]))
+        addSequence(used, row.id, "WRK");
+    return formatFullId("WRK", Math.max(0, ...used) + 1, normalizeSlug(slug));
+}
 function parseEntityKind(value) {
     const normalized = value.toLowerCase();
     if (normalized === "protocol" || normalized === "prt")
         return "protocol";
     if (normalized === "run")
         return "run";
-    throw new AppError("validation", "--type must be protocol or run", 2, { type: value });
+    if (normalized === "work" || normalized === "wrk")
+        return "work";
+    throw new AppError("validation", "--type must be protocol, run, or work", 2, { type: value });
 }
-function databaseIds(context, table, type, projectId) {
+function databaseIds(context, table, idField, type, projectId) {
     if (!projectId)
         return [];
     return context.db
-        .all(`SELECT id FROM ${table} WHERE project_id = ? AND id LIKE ?`, [projectId, `${type}-%`])
+        .all(`SELECT ${idField} AS id FROM ${table} WHERE project_id = ? AND ${idField} LIKE ?`, [projectId, `${type}-%`])
         .map((row) => row.id);
 }
 function filesystemIds(projectRoot, relativeRoot, type) {

package/dist/services/lanes.js

@@ -459,7 +459,7 @@ function assertWorkerMayAcquireLaneLock(context, projectId, lane, workerId) {
     if (lane !== "merge") {
         return;
     }
-    const latest = context.db.get(`SELECT status, stop_reason, flow_kind FROM flow_sessions
+    const latest = context.db.get(`SELECT status, stop_reason, flow_kind FROM sessions
      WHERE project_id = ? AND worker_id = ? AND flow_kind IN ('merge_worker', 'merge_job')
      ORDER BY updated_at DESC, rowid DESC LIMIT 1`, [projectId, workerId]);
     if (latest && ["stopped", "stopping"].includes(latest.status)) {

package/dist/services/merge-queue.js

@@ -1,4 +1,4 @@
-import { loadProjectFlowContract } from "../domain/flow-contract.js";
+import { flowContractForState } from "../domain/flow-contract.js";
 import { AppError } from "../shared/errors.js";
 import { appendAudit } from "./audit.js";
 import { requireProjectByRoot } from "./projects.js";
@@ -340,7 +340,7 @@ export function completeMergeJob(context, input) {
      SET status = 'merged', last_reason = ?, completed_at = ?, updated_at = ?
      WHERE id = ?`, [input.summary, now, now, job.id]);
     const state = readProtocolRuntimeState(context, protocol).state;
-    const flowContract = loadProjectFlowContract(protocol.project_root);
+    const flowContract = flowContractForState(state);
     const targetStage = flowContract.merge_queue.complete.target_stage;
     const targetStatus = flowContract.stages[targetStage]?.terminal ? targetStage : "running";
     persistProtocolState(context, protocol, {
@@ -390,7 +390,7 @@ export function completeMergeBundle(context, input) {
          SET status = 'merged', last_reason = ?, completed_at = ?, updated_at = ?
          WHERE id = ?`, [input.summary, now, now, job.id]);
             const state = readProtocolRuntimeState(context, protocol).state;
-            const flowContract = loadProjectFlowContract(protocol.project_root);
+            const flowContract = flowContractForState(state);
             const targetStage = flowContract.merge_queue.complete.target_stage;
             const targetStatus = flowContract.stages[targetStage]?.terminal ? targetStage : "running";
             persistProtocolState(context, protocol, {
@@ -691,7 +691,7 @@ function requireClaimedJob(context, projectId, protocolId, sessionId) {
 function transitionClaimedProtocolToIntegration(context, projectId, protocolId, workerId, now) {
     const protocol = requireProtocol(context, protocolId, projectId);
     const state = readProtocolRuntimeState(context, protocol).state;
-    const flowContract = loadProjectFlowContract(protocol.project_root);
+    const flowContract = flowContractForState(state);
     if (!["ready_for_merge", "queued_for_merge"].includes(state.stage)) {
         throw new AppError("merge_protocol_not_ready", "Cannot claim a protocol whose runtime state is not ready for merge", 1, {
             protocol_id: protocolId,
@@ -733,7 +733,7 @@ function releaseLaneLockIfOwned(context, input) {
     }
 }
 function stopAfterCurrentIfRequested(context, projectId, projectRoot, workerId, reason) {
-    const requested = context.db.get(`SELECT session_id FROM flow_sessions
+    const requested = context.db.get(`SELECT session_id FROM sessions
      WHERE project_id = ? AND worker_id = ? AND flow_kind = 'merge_worker'
        AND status = 'stopping' AND current_stage = 'stop_after_current'
      ORDER BY updated_at DESC, rowid DESC LIMIT 1`, [projectId, workerId]);

package/dist/services/merge-worker.js

@@ -72,7 +72,7 @@ export function stopProjectMergeWorker(context, input) {
     if (claimed.length > 0) {
         const now = context.now();
         for (const session of targetSessions) {
-            context.db.run(`UPDATE flow_sessions
+            context.db.run(`UPDATE sessions
          SET status = 'stopping', stop_reason = ?, current_stage = ?, next_action = ?, updated_at = ?
          WHERE project_id = ? AND session_id = ?`, [input.reason, "stop_after_current", "finish_current_merge_job_then_stop", now, project.id, session.session_id]);
         }
@@ -198,7 +198,7 @@ function detectMergeWorkerState(context, projectId) {
     return { state: "clear" };
 }
 function activeMergeWorkerSessions(context, projectId) {
-    return context.db.all(`SELECT session_id, worker_id, status, current_stage, next_action, updated_at FROM flow_sessions
+    return context.db.all(`SELECT session_id, worker_id, status, current_stage, next_action, updated_at FROM sessions
      WHERE project_id = ? AND flow_kind = 'merge_worker' AND status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping')
      ORDER BY updated_at DESC, rowid DESC`, [projectId]);
 }

package/dist/services/migrations.js

@@ -486,12 +486,12 @@ function adjacentMigrationChain(source, target, impacts = []) {
 function activeStateSummary(context, _projectId) {
     return {
         protocols: context.db.all("SELECT id, project_id, status, stage FROM protocols WHERE status NOT IN ('closed', 'cancelled') ORDER BY updated_at DESC"),
-        runs: context.db.all("SELECT id, project_id, status, verdict FROM flow_runs WHERE status = 'running' ORDER BY updated_at DESC"),
+        runs: context.db.all("SELECT id, project_id, status, verdict FROM runs WHERE status = 'running' ORDER BY updated_at DESC"),
         merge_queue: context.db.all("SELECT protocol_id, project_id, status FROM merge_queue WHERE status IN ('ready', 'claimed', 'requeued') ORDER BY updated_at DESC"),
         lane_locks: context.db.all("SELECT lane, project_id, worker_id, status FROM lane_locks WHERE status = 'active' ORDER BY updated_at DESC"),
         lane_waiters: context.db.all("SELECT id, lane, project_id, worker_id, status FROM lane_waiters WHERE status = 'queued' ORDER BY queued_at ASC, id ASC"),
         merge_sessions: context.db.all("SELECT session_id, project_id, status, current_protocol_id FROM merge_sessions WHERE status IN ('starting', 'active', 'stopping') ORDER BY updated_at DESC"),
-        sessions: context.db.all("SELECT session_id, project_id, status FROM flow_sessions WHERE status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping') ORDER BY updated_at DESC")
+        sessions: context.db.all("SELECT session_id, project_id, status FROM sessions WHERE status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping') ORDER BY updated_at DESC")
     };
 }
 function activeStateBlockers(active) {

package/dist/services/plan-runtime.js

@@ -98,7 +98,7 @@ export function updatePlanProgress(context, input) {
     refreshProtocolRuns(context, input.projectId, input.protocolId);
 }
 function refreshProtocolRuns(context, projectId, protocolId) {
-    for (const run of context.db.all("SELECT id FROM flow_runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?", [projectId, protocolId]))
+    for (const run of context.db.all("SELECT id FROM runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?", [projectId, protocolId]))
         refreshRunSessionProjection(context, projectId, run.id);
 }
 function mergeProgress(item, row, canonical) {

package/dist/services/projects.js

@@ -218,9 +218,9 @@ export function getProjectStatus(context, input) {
         merge_queue: mergeQueue,
         hook_status: hookStatusForProject(context, project.id),
         codex_home_profiles: codexHomeProfilesForProject(context, project.id),
-        flow_sessions: activeFlowSessionBindingsForProject(context, project.id),
+        sessions: activeFlowSessionBindingsForProject(context, project.id),
         codex_session_bindings: activeCodexSessionBindingsForProject(context, project.id),
-        codex_hook_events: codexHookEventsForProject(context, project.id),
+        hook_events: codexHookEventsForProject(context, project.id),
         worktrees,
         lane_status: {
             lanes: context.db.all("SELECT * FROM lanes WHERE project_id = ? ORDER BY name ASC", [project.id]),
@@ -319,10 +319,10 @@ function projectReferenceTables() {
         "codex_home_profiles",
         "codex_session_bindings",
         "project_config",
-        "flow_sessions",
+        "sessions",
         "flow_session_segments",
         "flow_jobs",
-        "codex_hook_events",
+        "hook_events",
         "worktree_records"
     ];
 }

package/dist/services/prompts.js

@@ -69,12 +69,12 @@ export function renderWorkerPrompt(context, input) {
         runId: run.id,
         protocolId: protocol.id,
         planItemId: item.id,
-        groupId: item.execution_context.write_scope[0] ?? null
+        groupId: item.execution_context.planned_write_areas[0] ?? null
     });
     const staticInputs = profile.static_files.map((file) => readStaticInput(projectRoot, file));
     const requiredRead = item.execution_context.required_read.map((file) => checkedReference(projectRoot, runHomePath(run), file, "required_read", true));
     const discoveryBoundary = item.execution_context.discovery_boundary.map((file) => checkedReference(projectRoot, runHomePath(run), file, "discovery_boundary", false));
-    const writeScope = item.execution_context.write_scope.map((file) => checkedReference(projectRoot, undefined, file, "write_scope", false));
+    const plannedWriteAreas = item.execution_context.planned_write_areas.map((file) => checkedReference(projectRoot, undefined, file, "planned_write_areas", false));
     const runHome = runHomePath(run);
     const outputDir = path.join(runHome, stage.dir, "subagents", item.id);
     assertWithin(runHome, outputDir, "output directory");
@@ -85,7 +85,7 @@ export function renderWorkerPrompt(context, input) {
         workspaceRoot,
         requiredRead,
         discoveryBoundary,
-        writeScope,
+        plannedWriteAreas,
         outputDir,
         staticInputs,
         ...(genericTask ? { handoff: genericTask.handoff } : {})
@@ -107,7 +107,7 @@ export function renderWorkerPrompt(context, input) {
         canon_version: readCanonVersion(projectRoot),
         renderer_version: getCliVersionReport().cli.version,
         static_inputs: staticInputs.map(({ path: inputPath, sha256 }) => ({ path: inputPath, sha256 })),
-        validation: { required_read: requiredRead, discovery_boundary: discoveryBoundary, write_scope: writeScope },
+        validation: { required_read: requiredRead, discovery_boundary: discoveryBoundary, planned_write_areas: plannedWriteAreas },
         ...(genericTask ? { task_handoff: genericTask.handoff } : {})
     });
     writeJson(reportPath, {
@@ -121,7 +121,7 @@ export function renderWorkerPrompt(context, input) {
         stage: input.stage,
         workspace_root: workspaceRoot,
         output: { launch_prompt: promptPath, prompt_stack: stackPath },
-        validation: { required_read: requiredRead, discovery_boundary: discoveryBoundary, write_scope: writeScope },
+        validation: { required_read: requiredRead, discovery_boundary: discoveryBoundary, planned_write_areas: plannedWriteAreas },
         ...(genericTask ? { task_handoff: genericTask.handoff } : {})
     });
     return {
@@ -204,7 +204,7 @@ function protocolIdForRun(context, projectId, runId) {
     return run.subject_id;
 }
 function requireRun(context, projectId, runId) {
-    const row = context.db.get("SELECT id, project_id, subject_type, subject_id, workspace_root, run_index_path, run_home_path, index_json FROM flow_runs WHERE project_id = ? AND (id = ? OR short_id = ?)", [projectId, runId, runId]);
+    const row = context.db.get("SELECT id, project_id, subject_type, subject_id, workspace_root, run_index_path, run_home_path, index_json FROM runs WHERE project_id = ? AND (id = ? OR short_id = ?)", [projectId, runId, runId]);
     if (!row)
         throw new AppError("not_found", `Run is not found: ${runId}`, 1);
     return row;
@@ -290,9 +290,10 @@ function renderPrompt(input) {
         `- Non-goals: ${(item.semantic_spine?.non_goals ?? []).join("; ") || "none"}`,
         `- Acceptance contribution: ${item.semantic_spine?.acceptance_contribution ?? "not_applicable"}`,
         "",
-        "## Runtime",
-        `- Workspace: \`${input.workspaceRoot}\``,
-        `- Allowed writes: ${input.writeScope.map((value) => `\`${value}\``).join(", ") || "none"}`,
+        "## Hard Write Boundary",
+        `- All project writes must stay under: \`${input.workspaceRoot}\``,
+        "- Do not write outside this workspace, to another RUN, or into Git/worktree control data.",
+        "- Accepted requirements and non-goals remain binding; planned write areas do not.",
         `- Checks: ${(item.execution_context?.checks ?? []).map((value) => `\`${value}\``).join(", ") || "none"}`,
         `- Report directory: \`${input.outputDir}\``,
         "",
@@ -307,10 +308,15 @@ function renderPrompt(input) {
                 ""
             ]
             : []),
-        "## Bounded Discovery",
+        "## Discovery Hints",
         ...input.discoveryBoundary.map((value) => `- \`${value}\``),
         "",
-        "Read the static instructions below before acting. Report the sources actually read and any additions inside the discovery boundary. If an essential source is outside that boundary, stop with a plan question or DEF rather than expanding scope silently.",
+        "## Planned Write Areas",
+        "These are SOFT coordination hints for parallel workers, not an allowlist or permission boundary.",
+        `- Areas: ${input.plannedWriteAreas.map((value) => `\`${value}\``).join(", ") || "none predicted"}`,
+        "- You may read or change any project-local file needed to complete the accepted task. Report every actual changed path.",
+        "",
+        "Read the static instructions below before acting. Read every required source first; discovery hints do not prohibit necessary additional project-local reads. Report material additional sources and changes.",
         "",
         ...staticInputs.flatMap((entry) => [`## Static Input: ${entry.path}`, "", entry.content.trim(), ""])
     ].join("\n");

package/dist/services/protocols.js

@@ -47,7 +47,7 @@ export function registerProtocol(context, input) {
         JSON.stringify(state.blockers),
         JSON.stringify(state.active_def),
         runtimeStateJsonPath(context.ddFlowHome, project.id, protocolId),
-        planJsonPath(projectRoot, protocolId),
+        planJsonPath(workspacePath ?? projectRoot, protocolId),
         existing?.created_at ?? now,
         now
     ];
@@ -107,9 +107,9 @@ export function getProtocolStatus(context, input) {
         worktree: context.db.get("SELECT * FROM worktree_records WHERE project_id = ? AND protocol_id = ?", [protocol.project_id, protocol.id]),
         hook_status: hookStatusForProject(context, protocol.project_id),
         codex_home_profiles: codexHomeProfilesForProject(context, protocol.project_id),
-        flow_sessions: activeFlowSessionBindingsForProject(context, protocol.project_id).filter((session) => session.protocol_id === protocol.id),
+        sessions: activeFlowSessionBindingsForProject(context, protocol.project_id).filter((session) => session.protocol_id === protocol.id),
         codex_session_bindings: activeCodexSessionBindingsForProject(context, protocol.project_id).filter((binding) => binding.protocol_id === protocol.id),
-        codex_hook_events: codexHookEventsForProject(context, protocol.project_id).filter((event) => event.protocol_id === protocol.id),
+        hook_events: codexHookEventsForProject(context, protocol.project_id).filter((event) => event.protocol_id === protocol.id),
         audit: getAuditEvents(context, protocol.project_id, protocol.id)
     };
 }
@@ -502,7 +502,7 @@ export function cancelProtocol(context, input) {
         }
         let closedSessions = 0;
         if (input.closeSessions) {
-            const result = context.db.run(`UPDATE flow_sessions
+            const result = context.db.run(`UPDATE sessions
          SET status = 'stopped', stop_reason = ?, updated_at = ?, stopped_at = ?
          WHERE project_id = ?
            AND protocol_id = ?
@@ -705,7 +705,7 @@ function removeLocalFeatureBranch(projectRoot, branch, force) {
     return { ok: true, skipped: false, reason: force ? "branch_force_deleted" : "branch_deleted", branch };
 }
 function releaseRelatedMergeLocks(context, protocol, reason) {
-    const workers = context.db.all(`SELECT DISTINCT worker_id FROM flow_sessions
+    const workers = context.db.all(`SELECT DISTINCT worker_id FROM sessions
      WHERE project_id = ? AND protocol_id = ? AND worker_id IS NOT NULL`, [protocol.project_id, protocol.id]).map((row) => row.worker_id).filter((workerId) => Boolean(workerId));
     const job = context.db.get("SELECT claimed_by_session_id FROM merge_queue WHERE project_id = ? AND protocol_id = ?", [protocol.project_id, protocol.id]);
     if (job?.claimed_by_session_id) {
@@ -866,7 +866,7 @@ export function persistProtocolState(context, protocol, state) {
     ]);
     if (state.status === "closed" || state.stage === "closed") {
         const now = context.now();
-        context.db.run(`UPDATE flow_sessions
+        context.db.run(`UPDATE sessions
        SET status = 'stopped', stop_reason = 'protocol closed', updated_at = ?, stopped_at = ?
        WHERE project_id = ?
          AND protocol_id = ?
@@ -1216,14 +1216,14 @@ function readinessMissingFields(state) {
 }
 function linkedRunsForProtocol(context, protocol, limit) {
     return context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
-     FROM flow_runs
+     FROM runs
      WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?
      ORDER BY updated_at DESC, id DESC
      LIMIT ?`, [protocol.project_id, protocol.id, limit]);
 }
 function resolveLinkedRun(context, protocol, runIdOrAlias) {
     const matches = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
-     FROM flow_runs
+     FROM runs
      WHERE project_id = ? AND (id = ? OR short_id = ?)
      ORDER BY updated_at DESC, id DESC`, [protocol.project_id, runIdOrAlias, runIdOrAlias]);
     if (matches.length === 1)

package/dist/services/run-projection.js

@@ -2,16 +2,23 @@ import fs from "node:fs";
 import path from "node:path";
 import { reconcileSessionCoverageRows } from "../domain/session-coverage.js";
 export function refreshRunSessionProjection(context, projectId, runId) {
-    const run = context.db.get("SELECT id, status, project_root, subject_type, subject_id, runtime_path, run_index_path, index_json FROM flow_runs WHERE project_id = ? AND id = ?", [projectId, runId]);
+    const run = context.db.get("SELECT id, flow_kind, status, project_root, subject_type, subject_id, runtime_path, run_index_path, index_json FROM runs WHERE project_id = ? AND id = ?", [projectId, runId]);
     if (!run)
         return;
     const index = JSON.parse(run.index_json);
-    const sessionRows = context.db.all(`SELECT session_id, parent_session_id, role, session_kind, worker_id, current_stage, status,
+    const sessionRows = context.db.all(`SELECT session_id, harness, provider_session_id, parent_session_id, role, session_kind, worker_id, current_stage, status,
             created_at, updated_at, stopped_at, coverage_units_json
-       FROM flow_sessions WHERE project_id = ? AND run_id = ? ORDER BY created_at, session_id`, [projectId, runId]);
+       FROM sessions WHERE project_id = ? AND run_id = ? ORDER BY created_at, session_id`, [projectId, runId]);
     const sessions = sessionRows.map(sessionProjection);
+    const workRows = context.db.all("SELECT work_id, parent_work_id, status, depends_on_json, launch_policy, started_at, completed_at FROM works WHERE project_id = ? AND run_id = ? ORDER BY created_at, work_id", [projectId, runId]);
+    const works = workRows.map((work) => ({ work_id: work.work_id, parent_work_id: work.parent_work_id, status: work.status, depends_on: parseStringArray(work.depends_on_json), launch_policy: work.launch_policy, started_at: work.started_at, completed_at: work.completed_at }));
+    const rootWorkId = workRows.find((work) => work.parent_work_id === null)?.work_id ?? null;
     const coverage = reconcileSessionCoverageRows(sessionRows);
-    const sessionCoverage = {
+    const sessionCoverage = run.flow_kind === "vnext_specify" && coverage.expected_unit_ids.length === 0 ? {
+        status: "not_applicable",
+        expected: [], observed: [], missing: [],
+        diagnostics: ["worker_coverage_not_required"]
+    } : {
         status: coverage.status,
         expected: coverage.expected_unit_ids,
         observed: coverage.observed_unit_ids,
@@ -20,19 +27,35 @@ export function refreshRunSessionProjection(context, projectId, runId) {
     };
     const plan = run.subject_type === "protocol" ? planProjection(context, projectId, run.subject_id, run.project_root) : {};
     const workers = workerProjection(context, projectId, runId);
+    const vnext = run.flow_kind === "vnext_specify" || run.flow_kind === "vnext_protocolize";
+    const hadLegacyCoverage = vnext && ("session_coverage" in index || "usage_coverage" in index);
+    if (vnext) {
+        delete index.session_coverage;
+        delete index.usage_coverage;
+        delete index.workers;
+        delete index.current_stage;
+        delete index.attempts;
+    }
     if (JSON.stringify(index.sessions ?? []) === JSON.stringify(sessions)
-        && JSON.stringify(index.session_coverage) === JSON.stringify(sessionCoverage)
+        && JSON.stringify(index.works ?? []) === JSON.stringify(works)
+        && index.root_work_id === rootWorkId
+        && (vnext || JSON.stringify(index.session_coverage) === JSON.stringify(sessionCoverage))
         && JSON.stringify(index.plan_ref) === JSON.stringify(plan.plan_ref)
         && JSON.stringify(index.plan_progress) === JSON.stringify(plan.plan_progress)
-        && JSON.stringify(index.workers ?? {}) === JSON.stringify(workers))
+        && (vnext || JSON.stringify(index.workers ?? {}) === JSON.stringify(workers))
+        && !hadLegacyCoverage)
         return;
     index.sessions = sessions;
-    index.session_coverage = sessionCoverage;
+    index.works = works;
+    index.root_work_id = rootWorkId;
+    if (!vnext)
+        index.session_coverage = sessionCoverage;
     if (plan.plan_ref)
         index.plan_ref = plan.plan_ref;
     if (plan.plan_progress)
         index.plan_progress = plan.plan_progress;
-    index.workers = workers;
+    if (!vnext)
+        index.workers = workers;
     index.updated_at = context.now();
     const runtime = readJson(run.runtime_path);
     const runtimeRevision = typeof runtime?.runtime_revision === "number"
@@ -41,19 +64,30 @@ export function refreshRunSessionProjection(context, projectId, runId) {
             ? index.runtime_revision + 1
             : 1;
     index.runtime_revision = runtimeRevision;
-    const authoritative = runtime ?? { ...index, schema_id: "dd-flow/flow-run@2" };
+    const authoritative = { ...(runtime ?? {}), ...index, schema_id: String(index.schema_id ?? runtime?.schema_id ?? "dd-flow/flow-run@3") };
     authoritative.sessions = sessions;
-    authoritative.session_coverage = sessionCoverage;
+    authoritative.works = works;
+    authoritative.root_work_id = rootWorkId;
+    if (vnext) {
+        delete authoritative.session_coverage;
+        delete authoritative.usage_coverage;
+        delete authoritative.workers;
+        delete authoritative.current_stage;
+        delete authoritative.attempts;
+    }
+    else
+        authoritative.session_coverage = sessionCoverage;
     if (plan.plan_ref)
         authoritative.plan_ref = plan.plan_ref;
     if (plan.plan_progress)
         authoritative.plan_progress = plan.plan_progress;
-    authoritative.workers = workers;
+    if (!vnext)
+        authoritative.workers = workers;
     authoritative.updated_at = index.updated_at;
     authoritative.runtime_revision = runtimeRevision;
     if (run.status !== "discarded" || fs.existsSync(run.runtime_path))
         writeJson(run.runtime_path, authoritative);
-    context.db.run("UPDATE flow_runs SET index_json = ?, updated_at = ? WHERE project_id = ? AND id = ?", [JSON.stringify(index), index.updated_at, projectId, runId]);
+    context.db.run("UPDATE runs SET index_json = ?, updated_at = ? WHERE project_id = ? AND id = ?", [JSON.stringify(index), index.updated_at, projectId, runId]);
 }
 function planProjection(context, projectId, protocolId, projectRoot) {
     const binding = context.db.get("SELECT plan_path, plan_revision, plan_sha256 FROM plan_bindings WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
@@ -107,10 +141,12 @@ function parseStringArray(value) {
 function sessionProjection(row) {
     return {
         session_id: row.session_id,
+        harness: row.harness,
+        provider_session_id: row.provider_session_id,
         parent_session_id: row.parent_session_id,
         role: row.role,
         session_kind: row.session_kind,
-        worker_id: row.worker_id,
+        work_id: row.worker_id,
         current_stage: row.current_stage,
         status: row.status,
         created_at: row.created_at,