@work-graph/cli 0.2.4 → 0.2.6

package/vendor/src/workGraphRuntime.mjs

@@ -537,6 +537,18 @@ function isInlineSectionHeading(line) {
     || /^[A-Za-zА-Яа-яЁё0-9][^:\n]{0,40}\s\/\s[^:\n]{0,40}:$/u.test(line);
 }
 
+function isProseLineWithTrailingColon(line) {
+  if (!/:\s*$/u.test(line)) {
+    return false;
+  }
+  const before = line.slice(0, -1).trim();
+  return before.length > 42 || (/\s/u.test(before) && before.length > 24);
+}
+
+function isSectionBoundaryInSemanticBlock(line) {
+  return isInlineSectionHeading(line) && !isProseLineWithTrailingColon(line);
+}
+
 function parseSections(body) {
   const result = {
     labels: {},
@@ -615,7 +627,7 @@ function parseSections(body) {
     }
 
     if (section === 'basis' || section === 'vector' || section === 'goal') {
-      if (isInlineSectionHeading(line)) {
+      if (isSectionBoundaryInSemanticBlock(line)) {
         section = '';
         continue;
       }

package/vendor/src/workGraphToolSurfaceAudit.mjs

@@ -351,6 +351,14 @@ export const PROMPT_EVAL_WORKGRAPH_FIXTURES_V1 = [
     allowedTools: ['worker.runAgentWorkerLiveLoop'],
     expectedKeywords: ['verify', 'succeeded', 'dry-run'],
   },
+  {
+    id: 'cursor-mcp-primer-v1',
+    tier: 'optional-llm',
+    failureClass: 'model_failure',
+    description: 'Session warm-up: agent must claim via MCP before write; no TodoWrite for trackable work; Russian create_work_item prose',
+    allowedTools: ['workGraph.claimNext', 'workGraph.createWorkItem', 'workGraph.transitionStatus'],
+    expectedKeywords: ['claim_work_item', 'no TodoWrite', 'русск', 'work.id'],
+  },
   {
     id: 'loop-hint-repeat-tool',
     tier: 'optional-llm',

package/vendor/src/workItemBlockClassifier.mjs

@@ -0,0 +1,72 @@
+export function classifyWorkItemBlock(item) {
+  const searchable = [
+    item.id,
+    item.title,
+    item.department,
+    item.ownerRole,
+    item.nextAction,
+    ...(item.targetFiles ?? []),
+  ]
+    .join(' ')
+    .toLowerCase();
+
+  if (
+    item.department === 'domain-marketplace'
+    || item.department === 'domain-onebase'
+    || searchable.includes('intent/domains/marketplace')
+    || searchable.includes('intent/domains/onebase')
+    || searchable.includes('onebase')
+    || searchable.includes('../onebase')
+    || searchable.includes('marketplace')
+  ) {
+    return 'domains';
+  }
+
+  if (
+    searchable.includes('memory')
+    || searchable.includes('claude-note')
+    || item.department === 'knowledge-publishing'
+  ) {
+    return 'project-memory';
+  }
+
+  if (
+    searchable.includes('trace')
+    || searchable.includes('evidence')
+    || searchable.includes('verification')
+  ) {
+    return 'trace-evidence';
+  }
+
+  if (
+    searchable.includes('worker')
+    || searchable.includes('agent-worker')
+    || searchable.includes('agent-runtime')
+    || searchable.includes('design-agent-')
+    || searchable.includes('implement-agent-')
+    || searchable.includes('runner')
+    || searchable.includes('promptpilot')
+  ) {
+    return 'agent-runtime';
+  }
+
+  if (
+    searchable.includes('step-atom')
+    || searchable.includes('formatter')
+    || searchable.includes('charter')
+    || searchable.includes('parser-roundtrip')
+  ) {
+    return 'step-canon';
+  }
+
+  if (
+    item.department === 'frontend-ui'
+    || /\b(ui|dashboard|board|graph-viewer|atom-inspector|architecture|schematic)\b/u.test(searchable)
+    || searchable.includes('pvrg')
+    || searchable.includes('derived-graph')
+  ) {
+    return 'derived-projections';
+  }
+
+  return 'work-graph';
+}

package/vendor/src/workItemContractProjection.mjs

@@ -0,0 +1,164 @@
+import { VERIFICATION_MATRIX } from './verificationLoop.mjs';
+
+export const WORK_ITEM_CONTRACT_SCHEMA = 'work-item-contract.v1';
+
+const TIER_RANK = { A: 3, B: 2, C: 1 };
+
+const TIER_LETTER = {
+  deterministic: 'A',
+  'optional-env': 'B',
+  'optional-llm': 'C',
+};
+
+function normalizeLines(value) {
+  if (Array.isArray(value)) {
+    return value.map((line) => String(line).trim()).filter(Boolean);
+  }
+
+  return String(value ?? '')
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function contextHintFromWorkItem(workItem) {
+  const basis = normalizeLines(workItem?.basis);
+  if (basis.length > 0) {
+    return basis[0].slice(0, 240);
+  }
+
+  const vector = normalizeLines(workItem?.vector);
+  if (vector.length > 0) {
+    return vector[0].slice(0, 240);
+  }
+
+  return workItem?.title ?? workItem?.id ?? '';
+}
+
+export function hasCodegenGateLabels(workItem) {
+  const labels = workItem?.labels ?? {};
+  return Boolean(
+    labels['trace.codegen_source_step']
+    || labels['trace.codegen_integrity_hash']
+    || labels['trace.codegen'],
+  );
+}
+
+/** @param {string} workId */
+export function resolveMatrixRowsForWorkId(workId) {
+  const normalizedWorkId = String(workId ?? '').trim();
+  if (normalizedWorkId === '') {
+    return [];
+  }
+
+  return VERIFICATION_MATRIX.filter((row) => row.gateTaskIds.includes(normalizedWorkId));
+}
+
+/** @param {Array<typeof VERIFICATION_MATRIX[number]>} rows */
+export function pickPrimaryMatrixRow(rows) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    return null;
+  }
+
+  const indexById = new Map(VERIFICATION_MATRIX.map((row, index) => [row.id, index]));
+
+  const sorted = [...rows].sort((left, right) => {
+    const leftRank = TIER_RANK[TIER_LETTER[left.tier] ?? ''] ?? 0;
+    const rightRank = TIER_RANK[TIER_LETTER[right.tier] ?? ''] ?? 0;
+    if (rightRank !== leftRank) {
+      return rightRank - leftRank;
+    }
+
+    const leftIndex = indexById.get(left.id) ?? Number.MAX_SAFE_INTEGER;
+    const rightIndex = indexById.get(right.id) ?? Number.MAX_SAFE_INTEGER;
+    if (leftIndex !== rightIndex) {
+      return leftIndex - rightIndex;
+    }
+
+    return String(left.id).localeCompare(String(right.id), 'en', { sensitivity: 'variant' });
+  });
+
+  return sorted[0] ?? null;
+}
+
+export function tierLetterFromMatrixRow(row) {
+  if (!row) {
+    return null;
+  }
+
+  return TIER_LETTER[row.tier] ?? null;
+}
+
+function buildEvidenceRequired(primaryRow, workItem) {
+  const required = [];
+
+  if (primaryRow && primaryRow.command && !/вручную/u.test(primaryRow.command)) {
+    required.push({
+      type: 'command',
+      cmd: primaryRow.command,
+      mustPass: true,
+    });
+  }
+
+  for (const targetFile of workItem?.targetFiles ?? []) {
+    required.push({
+      type: 'file',
+      files: [targetFile],
+    });
+  }
+
+  return required;
+}
+
+/**
+ * Pure projection: WorkItem atom + VERIFICATION_MATRIX → work-item-contract.v1
+ * @param {object} workItem
+ * @param {object} [options]
+ */
+export function buildWorkItemContractV1(workItem, options = {}) {
+  if (!workItem || typeof workItem !== 'object') {
+    throw new TypeError('workItem is required');
+  }
+
+  const rows = resolveMatrixRowsForWorkId(workItem.id);
+  const primaryRow = pickPrimaryMatrixRow(rows);
+  const tier = tierLetterFromMatrixRow(primaryRow);
+  const checksProse = Array.isArray(workItem.checks)
+    ? workItem.checks.map((line) => String(line).trim()).filter(Boolean)
+    : [];
+
+  return {
+    schema: WORK_ITEM_CONTRACT_SCHEMA,
+    workId: workItem.id,
+    input: {
+      targetFiles: [...(workItem.targetFiles ?? [])],
+      dependsOn: [...(workItem.dependsOn ?? [])],
+      contextHint: contextHintFromWorkItem(workItem),
+    },
+    output: {
+      evidenceRequired: buildEvidenceRequired(primaryRow, workItem),
+      checksProse,
+    },
+    verification: {
+      tier,
+      matrixRowId: primaryRow?.id ?? null,
+      matrixRowIds: rows.map((row) => row.id),
+      codegenGate: hasCodegenGateLabels(workItem),
+    },
+    meta: {
+      readOnly: true,
+      source: options.source ?? 'work-item-contract-projection',
+    },
+  };
+}
+
+/** @param {Array<object>} items */
+export function buildWorkItemContractsForItems(items, options = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  return items
+    .filter((item) => resolveMatrixRowsForWorkId(item.id).length > 0)
+    .map((item) => buildWorkItemContractV1(item, options));
+}

package/vendor/src/workItemReadyForDone.mjs

@@ -0,0 +1,296 @@
+import { evaluateParentCloseGate } from './workItemHierarchy.mjs';
+import {
+  buildWorkItemContractV1,
+  resolveMatrixRowsForWorkId,
+} from './workItemContractProjection.mjs';
+import { VERIFICATION_MATRIX } from './verificationLoop.mjs';
+
+export const WORK_ITEM_READY_FOR_DONE_SCHEMA = 'work-item-ready-for-done.v1';
+
+function normalizeEvidenceLines(item, pendingEvidence) {
+  const lines = [...(item?.evidence ?? [])].map((line) => String(line).trim()).filter(Boolean);
+  const pending = String(pendingEvidence ?? '').trim();
+  if (pending !== '') {
+    lines.push(pending);
+  }
+
+  return lines;
+}
+
+function parseStructuredEvidenceLine(line) {
+  const trimmed = String(line ?? '').trim();
+  if (!trimmed.startsWith('{')) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function commandEvidenceLooksValid(record) {
+  if (!record || typeof record !== 'object') {
+    return false;
+  }
+
+  const type = String(record.type ?? '').trim();
+  if (type !== 'command' && type !== 'test') {
+    return false;
+  }
+
+  const command = String(record.command ?? record.cmd ?? '').trim();
+  if (command === '') {
+    return false;
+  }
+
+  const exitCode = record.exitCode ?? record.exit_code;
+  if (exitCode === undefined || exitCode === null) {
+    return false;
+  }
+
+  return Number(exitCode) === 0 && String(record.status ?? 'succeeded').trim() !== 'failed';
+}
+
+export function legacyEvidenceMatchesTierA(lines, contract) {
+  const haystack = lines.join('\n').toLowerCase();
+  if (haystack === '') {
+    return false;
+  }
+
+  if (/exit[_ ]?code\s*=\s*0/u.test(haystack) || /exitcode["']?\s*:\s*0/u.test(haystack)) {
+    return true;
+  }
+
+  if (/npm test|test:deterministic|go test|passed|green|зелён/u.test(haystack)) {
+    return true;
+  }
+
+  const rows = resolveMatrixRowsForWorkId(contract.workId);
+  const hints = rows.flatMap((row) => row.evidenceHints ?? []);
+  if (hints.some((hint) => haystack.includes(String(hint).toLowerCase()))) {
+    return true;
+  }
+
+  for (const required of contract.output?.evidenceRequired ?? []) {
+    const cmd = String(required.cmd ?? '').trim().toLowerCase();
+    if (cmd !== '' && haystack.includes(cmd)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function hasTierACommandEvidence(item, contract, pendingEvidence) {
+  const lines = normalizeEvidenceLines(item, pendingEvidence);
+
+  for (const line of lines) {
+    const structured = parseStructuredEvidenceLine(line);
+    if (structured && commandEvidenceLooksValid(structured)) {
+      return true;
+    }
+  }
+
+  return legacyEvidenceMatchesTierA(lines, contract);
+}
+
+export function validateEvidenceForContract(evidenceJson, contract, workId) {
+  const violations = [];
+
+  if (!evidenceJson || typeof evidenceJson !== 'object') {
+    return {
+      ok: false,
+      violations: [{
+        code: 'invalid_evidence_json',
+        severity: 'error',
+        message: 'evidenceJson must be an object',
+        fix: 'pass evidence-record.v1 shaped JSON',
+      }],
+    };
+  }
+
+  const type = String(evidenceJson.type ?? '').trim();
+  const status = String(evidenceJson.status ?? '').trim();
+  const taskId = String(evidenceJson.taskId ?? workId ?? '').trim();
+
+  if (type === '') {
+    violations.push({
+      code: 'missing_evidence_type',
+      severity: 'error',
+      message: 'evidence type is required',
+      fix: 'set type to command or test',
+    });
+  }
+
+  if (status === '') {
+    violations.push({
+      code: 'missing_evidence_status',
+      severity: 'error',
+      message: 'evidence status is required',
+      fix: 'set status to succeeded',
+    });
+  } else if (status === 'failed' || status === 'blocked') {
+    violations.push({
+      code: 'evidence_status_failed',
+      severity: 'error',
+      message: `evidence status is ${status}`,
+      fix: 'provide succeeded evidence',
+    });
+  }
+
+  if (taskId === '') {
+    violations.push({
+      code: 'missing_task_id',
+      severity: 'error',
+      message: 'evidence taskId is required',
+      fix: `set taskId to ${workId}`,
+    });
+  } else if (workId && taskId !== workId) {
+    violations.push({
+      code: 'task_id_mismatch',
+      severity: 'error',
+      message: `evidence taskId ${taskId} does not match workId ${workId}`,
+      fix: `set taskId to ${workId}`,
+    });
+  }
+
+  if (type === 'command' || type === 'test') {
+    const command = String(evidenceJson.command ?? evidenceJson.cmd ?? '').trim();
+    const exitCode = evidenceJson.exitCode ?? evidenceJson.exit_code;
+
+    if (command === '') {
+      violations.push({
+        code: 'missing_command',
+        severity: 'error',
+        message: 'command/test evidence requires command',
+        fix: 'set command to npm run test:deterministic',
+      });
+    }
+
+    if (exitCode === undefined || exitCode === null) {
+      violations.push({
+        code: 'missing_exit_code',
+        severity: 'error',
+        message: 'command/test evidence requires exitCode',
+        fix: 'set exitCode to 0',
+      });
+    } else if (Number(exitCode) !== 0) {
+      violations.push({
+        code: 'non_zero_exit_code',
+        severity: 'error',
+        message: `exitCode must be 0, got ${exitCode}`,
+        fix: 'rerun command until exitCode=0',
+      });
+    }
+  }
+
+  if (contract?.verification?.tier === 'A' && (type === 'command' || type === 'test')) {
+    const requiredCommands = (contract.output?.evidenceRequired ?? [])
+      .filter((entry) => entry.type === 'command')
+      .map((entry) => String(entry.cmd ?? '').trim())
+      .filter(Boolean);
+
+    const command = String(evidenceJson.command ?? evidenceJson.cmd ?? '').trim();
+    if (requiredCommands.length > 0 && command !== '' && !requiredCommands.includes(command)) {
+      violations.push({
+        code: 'command_not_in_contract',
+        severity: 'warn',
+        message: `command ${command} is not listed in contract evidenceRequired`,
+        fix: `prefer one of: ${requiredCommands.join(', ')}`,
+      });
+    }
+  }
+
+  return {
+    ok: violations.every((violation) => violation.severity !== 'error'),
+    violations,
+  };
+}
+
+/**
+ * @param {object} workItem
+ * @param {object} [options]
+ */
+export function evaluateWorkItemReadyForDone(workItem, options = {}) {
+  if (!workItem || typeof workItem !== 'object') {
+    throw new TypeError('workItem is required');
+  }
+
+  const allItems = options.allItems ?? [];
+  const pendingEvidence = options.pendingEvidence;
+  const targetStatus = options.targetStatus ?? 'done';
+  const contract = options.contract ?? buildWorkItemContractV1(workItem, options);
+  const evidenceLines = normalizeEvidenceLines(workItem, pendingEvidence);
+  const violations = [];
+  const suggestedCommands = (contract.output?.evidenceRequired ?? [])
+    .map((entry) => String(entry.cmd ?? '').trim())
+    .filter((cmd) => cmd !== '' && !/вручную/u.test(cmd));
+
+  if (evidenceLines.length === 0) {
+    violations.push({
+      code: 'missing_evidence',
+      severity: 'error',
+      message: 'done requires non-empty evidence',
+      fix: 'add_work_item_evidence with command output',
+    });
+  }
+
+  if (contract.verification?.tier === 'A' && !hasTierACommandEvidence(workItem, contract, pendingEvidence)) {
+    violations.push({
+      code: 'structured_evidence_required',
+      severity: 'error',
+      message: 'Tier A gate task requires command evidence with exitCode=0 or matching verification hints',
+      fix: 'validate_evidence then add structured payload or npm test passed line',
+    });
+  }
+
+  if (allItems.length > 0 && (targetStatus === 'done' || targetStatus === 'verified')) {
+    const parentGate = evaluateParentCloseGate(allItems, workItem, targetStatus);
+    if (!parentGate.ok) {
+      violations.push({
+        code: 'parent_close_blocked',
+        severity: 'error',
+        message: parentGate.message,
+        fix: 'close or block open child WorkItems first',
+      });
+    }
+  }
+
+  const ok = violations.every((violation) => violation.severity !== 'error');
+
+  return {
+    schema: WORK_ITEM_READY_FOR_DONE_SCHEMA,
+    workId: workItem.id,
+    ok,
+    violations,
+    suggestedCommands: [...new Set(suggestedCommands)],
+    contract,
+  };
+}
+
+export function buildContractHealthSummary(items) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const gateItems = items.filter((item) => resolveMatrixRowsForWorkId(item.id).length > 0);
+  const tierAItems = gateItems.filter((item) => {
+    const contract = buildWorkItemContractV1(item);
+    return contract.verification?.tier === 'A';
+  });
+
+  const structuredCount = tierAItems.filter((item) => hasTierACommandEvidence(item, buildWorkItemContractV1(item))).length;
+  const readyCount = gateItems.filter((item) => evaluateWorkItemReadyForDone(item, { allItems: items }).ok).length;
+
+  return {
+    schema: 'contract-health.v1',
+    gateTaskCount: gateItems.length,
+    tierAGateTaskCount: tierAItems.length,
+    structuredEvidencePct: tierAItems.length === 0 ? 100 : Math.round((structuredCount / tierAItems.length) * 100),
+    contractReadyPct: gateItems.length === 0 ? 100 : Math.round((readyCount / gateItems.length) * 100),
+    matrixRowCount: VERIFICATION_MATRIX.length,
+  };
+}