@work-graph/cli 0.2.0

package/vendor/src/homeSnapshotProjection.mjs

@@ -0,0 +1,275 @@
+import {
+  CYCLE_SLICE_SCHEMA,
+  DEFAULT_DONE_ARCHIVE_CAP,
+  DONE_STATUSES,
+  OPERATIONAL_STATUSES,
+  deriveWorkCycle,
+} from './workGraphCycleSlice.mjs';
+
+export const HOME_SNAPSHOT_SCHEMA = 'home.snapshot.v1';
+
+export const HOME_REFRESH_BUDGETS = Object.freeze({
+  kpiMs: 30000,
+  activeRunsMs: 5000,
+  myQueueMs: 30000,
+  inboxPreviewMs: 30000,
+});
+
+const ACTIVE_RUN_STATUSES = new Set(['claimed', 'doing', 'in_progress', 'verify']);
+const READY_STATUS = 'ready';
+const BLOCKED_STATUS = 'blocked';
+const DEFAULT_QUEUE_LIMIT = 5;
+const DEFAULT_INBOX_PREVIEW_LIMIT = 5;
+const PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
+const RISK_RANK = { high: 0, medium: 1, low: 2 };
+
+const compareText = (left, right) =>
+  String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+function rankOf(map, value, fallback = 1) {
+  if (value === undefined || value === null) {
+    return fallback;
+  }
+  const key = String(value).trim().toLowerCase();
+  return Object.hasOwn(map, key) ? map[key] : fallback;
+}
+
+function compareReadyItems(left, right) {
+  const priorityDelta = rankOf(PRIORITY_RANK, left.priority) - rankOf(PRIORITY_RANK, right.priority);
+  if (priorityDelta !== 0) {
+    return priorityDelta;
+  }
+  const riskDelta = rankOf(RISK_RANK, left.risk) - rankOf(RISK_RANK, right.risk);
+  if (riskDelta !== 0) {
+    return riskDelta;
+  }
+  return compareText(left.id, right.id);
+}
+
+function compareActiveRuns(left, right) {
+  const order = ['verify', 'doing', 'in_progress', 'claimed'];
+  const leftIndex = order.indexOf(left.status);
+  const rightIndex = order.indexOf(right.status);
+  if (leftIndex !== rightIndex) {
+    return leftIndex - rightIndex;
+  }
+  return compareText(left.id, right.id);
+}
+
+function summarizeQueueItem(item) {
+  return {
+    workId: item.id,
+    title: item.title ?? '',
+    status: item.status,
+    department: item.department ?? '',
+    ownerRole: item.ownerRole ?? '',
+    priority: item.priority ?? '',
+    risk: item.risk ?? '',
+    nextAction: item.nextAction ?? '',
+    parentId: item.labels?.['work.parent_id'] ?? item.parentId ?? null,
+  };
+}
+
+function summarizeActiveRun(item) {
+  return {
+    workId: item.id,
+    title: item.title ?? '',
+    status: item.status,
+    ownerRole: item.ownerRole ?? '',
+    department: item.department ?? '',
+    blockerReason: item.blocker?.reason ?? null,
+  };
+}
+
+function buildStatusBuckets(items) {
+  const counts = { ready: 0, blocked: 0, doing: 0, verify: 0, done: 0, backlog: 0, other: 0 };
+  for (const item of items) {
+    if (item.status === READY_STATUS) {
+      counts.ready += 1;
+    } else if (item.status === BLOCKED_STATUS) {
+      counts.blocked += 1;
+    } else if (item.status === 'verify') {
+      counts.verify += 1;
+    } else if (item.status === 'doing' || item.status === 'in_progress' || item.status === 'claimed') {
+      counts.doing += 1;
+    } else if (DONE_STATUSES.has(item.status)) {
+      counts.done += 1;
+    } else if (item.status === 'backlog') {
+      counts.backlog += 1;
+    } else {
+      counts.other += 1;
+    }
+  }
+  return counts;
+}
+
+function buildCycleProgress(items, options) {
+  const itemById = new Map(items.map((item) => [item.id, item]));
+  const currentCycle = options.currentCycle
+    ?? (typeof options.resolveCurrentCycle === 'function' ? options.resolveCurrentCycle(items) : null);
+
+  if (!currentCycle || currentCycle === 'all') {
+    const total = items.length;
+    const done = items.filter((item) => DONE_STATUSES.has(item.status)).length;
+    return {
+      cycleId: currentCycle ?? null,
+      total,
+      done,
+      operational: items.filter((item) => OPERATIONAL_STATUSES.has(item.status)).length,
+      percent: total === 0 ? 0 : Math.round((done / total) * 100),
+    };
+  }
+
+  const inCycle = items.filter((item) => deriveWorkCycle(item, itemById) === currentCycle);
+  const total = inCycle.length;
+  const done = inCycle.filter((item) => DONE_STATUSES.has(item.status)).length;
+  return {
+    cycleId: currentCycle,
+    total,
+    done,
+    operational: inCycle.filter((item) => OPERATIONAL_STATUSES.has(item.status)).length,
+    percent: total === 0 ? 0 : Math.round((done / total) * 100),
+  };
+}
+
+function pickMyQueue(items, options) {
+  const ownerRole = options.ownerRole ? String(options.ownerRole).trim().toLowerCase() : null;
+  const limit = Number.isInteger(options.queueLimit) && options.queueLimit > 0
+    ? options.queueLimit
+    : DEFAULT_QUEUE_LIMIT;
+
+  const readyItems = items.filter((item) => item.status === READY_STATUS);
+  const filtered = ownerRole
+    ? readyItems.filter((item) => String(item.ownerRole ?? '').trim().toLowerCase() === ownerRole)
+    : readyItems;
+
+  const sorted = [...filtered].sort(compareReadyItems);
+  return sorted.slice(0, limit).map(summarizeQueueItem);
+}
+
+function pickActiveRuns(items) {
+  return items
+    .filter((item) => ACTIVE_RUN_STATUSES.has(item.status))
+    .sort(compareActiveRuns)
+    .map(summarizeActiveRun);
+}
+
+function buildInboxPreview(events, limit = DEFAULT_INBOX_PREVIEW_LIMIT) {
+  if (!Array.isArray(events)) {
+    return [];
+  }
+  return events
+    .slice(0, Math.max(0, limit))
+    .map((event) => ({
+      id: event.id ?? '',
+      kind: event.kind ?? 'event',
+      severity: event.severity ?? 'info',
+      title: event.title ?? '',
+      summary: event.summary ?? '',
+      link: event.link ?? null,
+      at: event.at ?? null,
+      unread: event.unread !== false,
+    }));
+}
+
+function buildVerifyPassRate(options) {
+  if (typeof options.verifyPassRate === 'number' && Number.isFinite(options.verifyPassRate)) {
+    return {
+      rate: Math.max(0, Math.min(1, options.verifyPassRate)),
+      windowRuns: Number.isInteger(options.verifyWindowRuns) ? options.verifyWindowRuns : null,
+      source: options.verifyPassRateSource ?? 'caller',
+    };
+  }
+  return { rate: null, windowRuns: null, source: 'unavailable' };
+}
+
+function buildThroughput(options) {
+  if (typeof options.throughputPerDay === 'number' && Number.isFinite(options.throughputPerDay)) {
+    return {
+      perDay: options.throughputPerDay,
+      windowDays: Number.isInteger(options.throughputWindowDays) ? options.throughputWindowDays : 7,
+      source: options.throughputSource ?? 'caller',
+    };
+  }
+  return { perDay: null, windowDays: null, source: 'unavailable' };
+}
+
+function buildDaemonUptime(options) {
+  if (options.daemonStartedAt && Number.isFinite(Date.parse(options.daemonStartedAt))) {
+    return {
+      startedAt: options.daemonStartedAt,
+      uptimeMs: Math.max(0, Date.now() - Date.parse(options.daemonStartedAt)),
+      source: options.daemonSource ?? 'caller',
+    };
+  }
+  return { startedAt: null, uptimeMs: null, source: 'unavailable' };
+}
+
+function buildAgentRunsToday(options) {
+  if (Number.isInteger(options.agentRunsToday) && options.agentRunsToday >= 0) {
+    return { count: options.agentRunsToday, source: options.agentRunsSource ?? 'caller' };
+  }
+  return { count: null, source: 'unavailable' };
+}
+
+/**
+ * Build a Home (mission control) snapshot from a workgraph.snapshot.v1.
+ *
+ * @param {object} workGraphSnapshot — must contain {items: WorkItem[]}.
+ * @param {object} [options]
+ * @param {string} [options.ownerRole] — filter My queue by owner role.
+ * @param {number} [options.queueLimit=5] — My queue size cap.
+ * @param {number} [options.inboxPreviewLimit=5] — inbox preview cap.
+ * @param {string} [options.currentCycle] — explicit cycle id; otherwise resolveCurrentCycle().
+ * @param {(items: WorkItem[]) => string} [options.resolveCurrentCycle]
+ * @param {Array<object>} [options.inboxPreview] — pre-built inbox events (newest first).
+ * @param {number} [options.verifyPassRate]
+ * @param {number} [options.throughputPerDay]
+ * @param {string} [options.daemonStartedAt]
+ * @param {number} [options.agentRunsToday]
+ * @param {number} [options.doneArchiveCap=DEFAULT_DONE_ARCHIVE_CAP]
+ * @returns {object} schema home.snapshot.v1
+ */
+export function buildHomeSnapshot(workGraphSnapshot, options = {}) {
+  if (!workGraphSnapshot || typeof workGraphSnapshot !== 'object') {
+    throw new TypeError('workGraphSnapshot must be an object');
+  }
+  const items = Array.isArray(workGraphSnapshot.items) ? workGraphSnapshot.items : [];
+
+  const statusBuckets = buildStatusBuckets(items);
+  const cycleProgress = buildCycleProgress(items, options);
+
+  return {
+    schema: HOME_SNAPSHOT_SCHEMA,
+    sourceSchema: workGraphSnapshot.schema ?? null,
+    cycleSliceSchema: CYCLE_SLICE_SCHEMA,
+    generatedAt: options.now ?? new Date().toISOString(),
+    refreshBudgets: HOME_REFRESH_BUDGETS,
+    kpi: {
+      cycleProgress,
+      ready: statusBuckets.ready,
+      blocked: statusBuckets.blocked,
+      verify: statusBuckets.verify,
+      doing: statusBuckets.doing,
+      done: statusBuckets.done,
+      backlog: statusBuckets.backlog,
+      verifyPassRate: buildVerifyPassRate(options),
+      throughput: buildThroughput(options),
+      daemonUptime: buildDaemonUptime(options),
+      agentRunsToday: buildAgentRunsToday(options),
+    },
+    myQueue: {
+      ownerRole: options.ownerRole ?? null,
+      items: pickMyQueue(items, options),
+      doneArchiveCap: options.doneArchiveCap ?? DEFAULT_DONE_ARCHIVE_CAP,
+    },
+    activeRuns: pickActiveRuns(items),
+    inboxPreview: {
+      limit: Number.isInteger(options.inboxPreviewLimit) && options.inboxPreviewLimit > 0
+        ? options.inboxPreviewLimit
+        : DEFAULT_INBOX_PREVIEW_LIMIT,
+      items: buildInboxPreview(options.inboxPreview, options.inboxPreviewLimit),
+    },
+    sessionEpicId: options.sessionEpicId ?? null,
+  };
+}

package/vendor/src/inboxEventStream.mjs

@@ -0,0 +1,140 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export const INBOX_EVENTS_SCHEMA = 'inbox.events.v1';
+export const INBOX_READ_STATE_SCHEMA = 'inbox.read-state.v1';
+export const DEFAULT_INBOX_READ_STATE_PATH = '.workgraph/inbox-read-state.json';
+
+function parseTime(value) {
+  if (!value) {
+    return 0;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function buildInboxEventsFromSources(sources = {}) {
+  const events = [];
+
+  for (const run of sources.workerRuns ?? []) {
+    const at = run.recordedAt ?? run.startedAt ?? run.finishedAt ?? null;
+    events.push({
+      id: `agent-run:${run.runId ?? run.taskId ?? at ?? events.length}`,
+      kind: 'agent-run',
+      severity: run.ok === false || run.status === 'failed' ? 'error' : 'info',
+      title: run.taskId ? `Agent run: ${run.taskId}` : 'Agent run',
+      summary: run.failureReason ?? run.summary ?? run.transition ?? '',
+      link: run.taskId ? { type: 'work', workId: run.taskId } : null,
+      at,
+      unread: true,
+    });
+  }
+
+  for (const entry of sources.daemonAudit ?? []) {
+    const at = entry.recordedAt ?? entry.at ?? null;
+    events.push({
+      id: `daemon:${entry.tickId ?? entry.taskId ?? at ?? events.length}`,
+      kind: 'daemon',
+      severity: entry.event === 'recovery' || entry.status === 'failed' ? 'warning' : 'info',
+      title: entry.event ? `Daemon: ${entry.event}` : 'Daemon tick',
+      summary: entry.summary ?? entry.message ?? '',
+      link: entry.taskId ? { type: 'work', workId: entry.taskId } : null,
+      at,
+      unread: true,
+    });
+  }
+
+  for (const record of sources.analyticsRecords ?? []) {
+    const key = record.key ?? record.id ?? '';
+    events.push({
+      id: `analytics:${key || events.length}`,
+      kind: 'analytics',
+      severity: 'info',
+      title: record.title ?? key ?? 'Analytics',
+      summary: record.topic ?? record.query ?? '',
+      link: record.bodyPath ? { type: 'analytics', path: record.bodyPath, key } : null,
+      at: record.updatedAt ?? record.createdAt ?? record.appendedAt ?? null,
+      unread: true,
+    });
+  }
+
+  for (const item of sources.verifyItems ?? []) {
+    if (item.status !== 'verify') {
+      continue;
+    }
+    events.push({
+      id: `verify:${item.id}`,
+      kind: 'work-verify',
+      severity: 'info',
+      title: `Verify: ${item.title ?? item.id}`,
+      summary: item.nextAction ?? '',
+      link: { type: 'work', workId: item.id },
+      at: item.labels?.['work.decision.at'] ?? null,
+      unread: true,
+    });
+  }
+
+  return events.sort((left, right) => parseTime(right.at) - parseTime(left.at));
+}
+
+export function applyInboxReadState(events, readState = {}) {
+  const readIds = new Set(Array.isArray(readState.readIds) ? readState.readIds : []);
+  return events.map((event) => ({
+    ...event,
+    unread: !readIds.has(event.id),
+  }));
+}
+
+export function countUnreadInboxEvents(events) {
+  return events.filter((event) => event.unread !== false).length;
+}
+
+export async function readInboxReadState(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const statePath = join(cwd, options.statePath ?? DEFAULT_INBOX_READ_STATE_PATH);
+
+  try {
+    const text = await readFile(statePath, 'utf8');
+    const parsed = JSON.parse(text);
+    return {
+      schema: INBOX_READ_STATE_SCHEMA,
+      readIds: Array.isArray(parsed.readIds) ? parsed.readIds : [],
+      updatedAt: parsed.updatedAt ?? null,
+    };
+  } catch {
+    return { schema: INBOX_READ_STATE_SCHEMA, readIds: [], updatedAt: null };
+  }
+}
+
+export async function markInboxEventsRead(eventIds, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const statePath = join(cwd, options.statePath ?? DEFAULT_INBOX_READ_STATE_PATH);
+  const current = await readInboxReadState({ cwd, statePath });
+  const merged = new Set([...current.readIds, ...eventIds.filter(Boolean)]);
+
+  const next = {
+    schema: INBOX_READ_STATE_SCHEMA,
+    readIds: [...merged],
+    updatedAt: new Date().toISOString(),
+  };
+
+  await mkdir(join(cwd, '.workgraph'), { recursive: true });
+  await writeFile(statePath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  return next;
+}
+
+export async function readInboxEventsResponse(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 50;
+  const sources = options.sources ?? {};
+  const events = buildInboxEventsFromSources(sources);
+  const readState = await readInboxReadState({ cwd, statePath: options.statePath });
+  const withRead = applyInboxReadState(events, readState);
+
+  return {
+    schema: INBOX_EVENTS_SCHEMA,
+    generatedAt: new Date().toISOString(),
+    unreadCount: countUnreadInboxEvents(withRead),
+    items: withRead.slice(0, limit),
+  };
+}

package/vendor/src/intentComposerApi.mjs

@@ -0,0 +1,245 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import {
+  appendWorkItemAtomToBacklogText,
+  findWorkItemAtomSpan,
+  writeBacklogTextAtomically,
+} from './workGraphBacklogPersist.mjs';
+import {
+  appendWorkItemAtomToIntentTree,
+  readWorkItemAtomFromRepo,
+} from './intentTreeWorkItems.mjs';
+import { formatStepAtomDraft, validateStepAtomDraft } from './stepAtomFormatter.mjs';
+
+export const INTENT_COMPOSER_PROPOSAL_SCHEMA = 'intent-composer.proposal.v1';
+export const INTENT_COMPOSER_DRAFT_SCHEMA = 'intent-composer.draft.v1';
+export const INTENT_COMPOSER_APPLY_SCHEMA = 'intent-composer.apply.response.v1';
+
+function slugifyIntent(value) {
+  const asciiParts = String(value ?? '')
+    .toLowerCase()
+    .split(/[^a-z0-9]+/u)
+    .filter(Boolean);
+
+  if (asciiParts.length > 0) {
+    return asciiParts.join('-').slice(0, 40);
+  }
+
+  const hash = [...String(value ?? '')].reduce((acc, ch) => ((acc * 31) + ch.charCodeAt(0)) >>> 0, 7);
+  return `msg-${hash.toString(36)}`;
+}
+
+function atomNameFromSlug(slug) {
+  const safe = slug.replace(/-/g, '_');
+  return `Задача_${safe}`;
+}
+
+export function buildIntentDraftFromMessage(message, options = {}) {
+  const text = String(message ?? '').trim();
+  if (text === '') {
+    throw new TypeError('message is required');
+  }
+
+  const slug = slugifyIntent(text);
+  const workId = String(options.workId ?? `intent-${slug}`).trim();
+  const title = text.length > 120 ? `${text.slice(0, 117)}...` : text;
+
+  const draft = {
+    name: atomNameFromSlug(slug),
+    profile: 'work_item',
+    basis: [text],
+    vector: [
+      'Оформить WorkItem из намерения пользователя через раздел «Замысел».',
+    ],
+    goal: [
+      'Получить reviewable backlog draft без записи chat transcript в канон.',
+    ],
+    checks: [
+      'draft проходит StepAtomDraft validation',
+      'operator подтверждает apply в backlog',
+    ],
+    labels: {
+      'atom.profile': 'work_item',
+      'work.id': workId,
+      'work.title': title,
+      'work.status': 'backlog',
+      'work.owner_role': options.ownerRole ?? 'product_architect',
+      'work.department': options.department ?? 'ui-dashboard',
+      'work.priority': options.priority ?? 'medium',
+      'work.risk': 'low',
+      'work.next_action': options.nextAction ?? 'review draft и promote в ready',
+      'intake.source_kind': 'intent-composer',
+      'intake.review_status': 'pending',
+      'work.pipeline_stage': 'intake',
+      'trace.status': 'pending',
+      'migration.strategy': 'rebuild',
+    },
+  };
+
+  const questions = text.length < 48
+    ? ['Уточните ожидаемый результат и target files для WorkItem.']
+    : [];
+
+  return {
+    schema: INTENT_COMPOSER_DRAFT_SCHEMA,
+    message: text,
+    suggestedWorkId: workId,
+    reviewRequired: true,
+    questions,
+    risks: [],
+    targetFiles: [],
+    criteria: draft.checks,
+    draft,
+  };
+}
+
+export function buildIntentComposerProposal(body, options = {}) {
+  const message = String(body?.message ?? body?.text ?? '').trim();
+  if (message === '') {
+    return {
+      schema: INTENT_COMPOSER_PROPOSAL_SCHEMA,
+      ok: false,
+      error: 'message_required',
+      validationErrors: ['message is required'],
+    };
+  }
+
+  const intentDraft = buildIntentDraftFromMessage(message, {
+    workId: body.workId,
+    ownerRole: body.ownerRole,
+    department: body.department,
+    priority: body.priority,
+    nextAction: body.nextAction,
+  });
+
+  const validationErrors = validateStepAtomDraft(intentDraft.draft);
+  let formattedAtom = null;
+
+  if (validationErrors.length === 0) {
+    try {
+      formattedAtom = formatStepAtomDraft(intentDraft.draft);
+    } catch (error) {
+      validationErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  return {
+    schema: INTENT_COMPOSER_PROPOSAL_SCHEMA,
+    ok: validationErrors.length === 0,
+    error: validationErrors.length === 0 ? null : 'validation_failed',
+    intentDraft,
+    formattedAtom,
+    validationErrors,
+    validationWarnings: options.warnings ?? [],
+    reviewRequired: true,
+    distinctFromAgentRun: true,
+  };
+}
+
+export function parseIntentComposerRequestBody(rawBody) {
+  if (rawBody === undefined || rawBody === null) {
+    return {};
+  }
+
+  if (typeof rawBody === 'string' && rawBody.trim() === '') {
+    return {};
+  }
+
+  const body = typeof rawBody === 'string' ? JSON.parse(rawBody) : rawBody;
+
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    throw new TypeError('intent composer body must be a JSON object');
+  }
+
+  return body;
+}
+
+export async function executeIntentComposerProposal(options = {}) {
+  const body = parseIntentComposerRequestBody(options.body ?? {});
+  return buildIntentComposerProposal(body, options);
+}
+
+export async function executeIntentComposerApply(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const body = parseIntentComposerRequestBody(options.body ?? {});
+
+  const proposal = body.proposal
+    ?? buildIntentComposerProposal(body);
+
+  if (!proposal.ok || !proposal.intentDraft?.draft) {
+    return {
+      schema: INTENT_COMPOSER_APPLY_SCHEMA,
+      ok: false,
+      error: proposal.error ?? 'invalid_proposal',
+      workId: null,
+      persistedBacklog: false,
+      validationErrors: proposal.validationErrors ?? [],
+    };
+  }
+
+  const workId = String(proposal.intentDraft.suggestedWorkId ?? '').trim();
+  const formattedAtom = proposal.formattedAtom
+    ?? formatStepAtomDraft(proposal.intentDraft.draft);
+
+  if (options.backlogText !== undefined || options.backlogPath) {
+    const backlogPath = resolve(cwd, options.backlogPath);
+    const backlogText = options.backlogText ?? await readFile(backlogPath, 'utf8');
+    if (findWorkItemAtomSpan(backlogText, workId)) {
+      return {
+        schema: INTENT_COMPOSER_APPLY_SCHEMA,
+        ok: false,
+        error: 'duplicate_work_id',
+        workId,
+        persistedBacklog: false,
+        validationErrors: [`work.id already exists: ${workId}`],
+      };
+    }
+
+    const nextText = appendWorkItemAtomToBacklogText(backlogText, formattedAtom);
+
+    if (options.persistBacklog !== false) {
+      await writeBacklogTextAtomically(backlogPath, nextText);
+    }
+
+    return {
+      schema: INTENT_COMPOSER_APPLY_SCHEMA,
+      ok: true,
+      error: null,
+      workId,
+      persistedBacklog: options.persistBacklog !== false,
+      validationErrors: [],
+      formattedAtom,
+    };
+  }
+
+  try {
+    await readWorkItemAtomFromRepo(workId, { ...options, cwd });
+    return {
+      schema: INTENT_COMPOSER_APPLY_SCHEMA,
+      ok: false,
+      error: 'duplicate_work_id',
+      workId,
+      persistedBacklog: false,
+      validationErrors: [`work.id already exists: ${workId}`],
+    };
+  } catch (error) {
+    if (!String(error instanceof Error ? error.message : error).includes('not found')) {
+      throw error;
+    }
+  }
+
+  if (options.persistBacklog !== false) {
+    await appendWorkItemAtomToIntentTree(formattedAtom, { ...options, cwd });
+  }
+
+  return {
+    schema: INTENT_COMPOSER_APPLY_SCHEMA,
+    ok: true,
+    error: null,
+    workId,
+    persistedBacklog: options.persistBacklog !== false,
+    validationErrors: [],
+    formattedAtom,
+  };
+}