@work-graph/cli 0.2.0

package/vendor/src/draftIntakePromotionRules.mjs

@@ -0,0 +1,205 @@
+import { validateStepAtomDraft } from './stepAtomFormatter.mjs';
+
+export const DRAFT_INTAKE_PROMOTION_EVAL_SCHEMA = 'workgraph.draft-intake.promotion-eval.v1';
+export const DRAFT_INTAKE_CANDIDATE_LIST_SCHEMA = 'workgraph.draft-intake.candidate-list.v1';
+
+const ALLOWED_MIGRATION_STRATEGIES = new Set(['port', 'rebuild', 'replace', 'defer']);
+const ALLOWED_INTAKE_SOURCE_KINDS = new Set([
+  'code-gap-analyzer',
+  'suggestion',
+  'llm_draft',
+  'manual',
+]);
+
+/**
+ * Deterministic promotion gates from protocols/workgraph-draft-intake.bvc.
+ * No silent backlog mutation — eligible drafts become operator-reviewed candidates only.
+ */
+export const DRAFT_INTAKE_PROMOTION_RULES = Object.freeze([
+  {
+    id: 'proposal_validation',
+    description: 'StepAtomDraft validation and formatter pass without errors.',
+  },
+  {
+    id: 'work_id_present',
+    description: 'Draft carries non-empty work.id / suggestedWorkId.',
+  },
+  {
+    id: 'migration_strategy',
+    description: 'Draft labels include allowed migration.strategy.',
+  },
+  {
+    id: 'intake_provenance',
+    description: 'Draft includes intake.source_kind, intake.source_path, intake.review_status=pending.',
+  },
+  {
+    id: 'target_files',
+    description: 'Code-gap drafts reference at least one target file.',
+  },
+  {
+    id: 'duplicate_work_id',
+    description: 'Suggested work.id is absent from canonical backlog / existingWorkIds.',
+  },
+  {
+    id: 'confidence_gate',
+    description: 'Suggestion confidence is not low unless explicitly allowed.',
+  },
+]);
+
+function normalizeWorkIdSet(existingWorkIds) {
+  if (existingWorkIds instanceof Set) {
+    return existingWorkIds;
+  }
+
+  if (Array.isArray(existingWorkIds)) {
+    return new Set(existingWorkIds.map((value) => String(value).trim()).filter(Boolean));
+  }
+
+  return new Set();
+}
+
+function buildCheck(id, passed, message) {
+  return { id, passed, message };
+}
+
+/**
+ * @param {{
+ *   ok?: boolean,
+ *   validationErrors?: string[],
+ *   codeGapDraft?: { suggestedWorkId?: string, confidence?: string, targetFiles?: string[], draft?: { labels?: Record<string, string> } },
+ * }} proposal
+ * @param {{ existingWorkIds?: Iterable<string>, allowLowConfidence?: boolean, requireTargetFiles?: boolean }} [options]
+ */
+export function evaluateDraftIntakePromotion(proposal, options = {}) {
+  if (!proposal || typeof proposal !== 'object') {
+    throw new TypeError('proposal is required');
+  }
+
+  const draft = proposal.codeGapDraft?.draft ?? {};
+  const labels = draft.labels ?? {};
+  const workId = String(proposal.codeGapDraft?.suggestedWorkId ?? labels['work.id'] ?? '').trim();
+  const validationErrors = [...(proposal.validationErrors ?? [])];
+  const existingWorkIds = normalizeWorkIdSet(options.existingWorkIds);
+  const requireTargetFiles = options.requireTargetFiles !== false;
+  const allowLowConfidence = options.allowLowConfidence === true;
+
+  const checks = [
+    buildCheck(
+      'proposal_validation',
+      proposal.ok === true && validationErrors.length === 0,
+      proposal.ok === true && validationErrors.length === 0
+        ? 'Proposal validation passed.'
+        : `Proposal validation failed: ${validationErrors.join('; ') || proposal.error || 'unknown'}`,
+    ),
+    buildCheck(
+      'work_id_present',
+      workId !== '',
+      workId !== '' ? `work.id ${workId} present.` : 'work.id is missing.',
+    ),
+    buildCheck(
+      'migration_strategy',
+      ALLOWED_MIGRATION_STRATEGIES.has(String(labels['migration.strategy'] ?? '').trim()),
+      ALLOWED_MIGRATION_STRATEGIES.has(String(labels['migration.strategy'] ?? '').trim())
+        ? `migration.strategy=${labels['migration.strategy']}.`
+        : 'migration.strategy missing or unsupported.',
+    ),
+    buildCheck(
+      'intake_provenance',
+      ALLOWED_INTAKE_SOURCE_KINDS.has(String(labels['intake.source_kind'] ?? '').trim())
+        && String(labels['intake.source_path'] ?? '').trim() !== ''
+        && String(labels['intake.review_status'] ?? '').trim() === 'pending',
+      ALLOWED_INTAKE_SOURCE_KINDS.has(String(labels['intake.source_kind'] ?? '').trim())
+        && String(labels['intake.source_path'] ?? '').trim() !== ''
+        && String(labels['intake.review_status'] ?? '').trim() === 'pending'
+        ? 'intake provenance labels complete and review_status=pending.'
+        : 'intake provenance incomplete or review_status is not pending.',
+    ),
+    buildCheck(
+      'target_files',
+      !requireTargetFiles || (proposal.codeGapDraft?.targetFiles?.length ?? 0) > 0 || String(labels['work.target_files'] ?? '').trim() !== '',
+      requireTargetFiles
+        ? 'At least one target file is referenced.'
+        : 'Target files optional for this intake kind.',
+    ),
+    buildCheck(
+      'duplicate_work_id',
+      workId === '' || !existingWorkIds.has(workId),
+      workId !== '' && existingWorkIds.has(workId)
+        ? `work.id already exists: ${workId}`
+        : 'No duplicate work.id in canonical backlog.',
+    ),
+    buildCheck(
+      'confidence_gate',
+      allowLowConfidence || proposal.codeGapDraft?.confidence !== 'low',
+      allowLowConfidence || proposal.codeGapDraft?.confidence !== 'low'
+        ? 'Confidence gate passed.'
+        : 'Low-confidence suggestions require explicit operator review before candidacy.',
+    ),
+  ];
+
+  const failedChecks = checks.filter((check) => !check.passed);
+
+  return {
+    schema: DRAFT_INTAKE_PROMOTION_EVAL_SCHEMA,
+    eligible: failedChecks.length === 0,
+    status: failedChecks.length === 0 ? 'candidate' : 'rejected',
+    workId: workId || null,
+    failedCheckIds: failedChecks.map((check) => check.id),
+    checks,
+    promotionProtocol: 'protocols/workgraph-draft-intake.bvc',
+    reviewRequired: true,
+  };
+}
+
+export function evaluateDraftIntakePromotionFromDraft(draft, options = {}) {
+  const validationErrors = validateStepAtomDraft(draft);
+  const proposal = {
+    ok: validationErrors.length === 0,
+    validationErrors,
+    codeGapDraft: {
+      suggestedWorkId: draft.labels?.['work.id'] ?? '',
+      confidence: options.confidence ?? 'medium',
+      targetFiles: String(draft.labels?.['work.target_files'] ?? '')
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean),
+      draft,
+    },
+  };
+
+  return evaluateDraftIntakePromotion(proposal, options);
+}
+
+/**
+ * @param {Array<{ proposal: object, suggestion?: object }>} entries
+ */
+export function partitionDraftIntakeCandidates(entries, options = {}) {
+  const candidates = [];
+  const rejected = [];
+
+  for (const entry of entries) {
+    const evaluation = evaluateDraftIntakePromotion(entry.proposal, options);
+    const row = {
+      workId: evaluation.workId,
+      evaluation,
+      proposal: entry.proposal,
+      suggestion: entry.suggestion ?? null,
+    };
+
+    if (evaluation.eligible) {
+      candidates.push(row);
+    } else {
+      rejected.push(row);
+    }
+  }
+
+  return {
+    schema: DRAFT_INTAKE_CANDIDATE_LIST_SCHEMA,
+    candidateCount: candidates.length,
+    rejectedCount: rejected.length,
+    candidates,
+    rejected,
+    promotionProtocol: 'protocols/workgraph-draft-intake.bvc',
+    rules: DRAFT_INTAKE_PROMOTION_RULES.map((rule) => rule.id),
+  };
+}

package/vendor/src/epicWorkScope.mjs

@@ -0,0 +1,85 @@
+import { buildEpicRoadmapProjection } from './intentRoadmapEpicProjection.mjs';
+import { attachDerivedWorkItemHierarchy, DONE_STATUSES, readWorkItemKind } from './workItemHierarchy.mjs';
+
+export const EPIC_WORK_SCOPE_SCHEMA = 'workgraph.epic-work-scope.v1';
+
+const ACTIVE_SCOPE_STATUSES = new Set(['claimed', 'doing', 'in_progress', 'verify']);
+
+/**
+ * Map work.status to markdown checklist mark for read-only scope blocks.
+ * @param {string} status
+ * @returns {'x' | '~' | ' '}
+ */
+export function scopeChecklistMark(status) {
+  const normalized = String(status ?? '').trim().toLowerCase();
+  if (DONE_STATUSES.has(normalized)) {
+    return 'x';
+  }
+  if (ACTIVE_SCOPE_STATUSES.has(normalized)) {
+    return '~';
+  }
+  return ' ';
+}
+
+/**
+ * Render AN-28 «Scope (read-only)» markdown block from epic scope slice.
+ * @param {object} scopeSlice — output of buildEpicWorkScopeSlice
+ * @param {{ title?: string }} [options]
+ */
+export function formatEpicScopeMarkdown(scopeSlice, options = {}) {
+  const title = options.title ?? 'Scope (read-only, Work Graph)';
+  const lines = [`## ${title}`, ''];
+  for (const child of scopeSlice.children ?? []) {
+    const mark = scopeChecklistMark(child.status);
+    const label = child.title ? ` — ${child.title}` : '';
+    lines.push(`- [${mark}] \`${child.id}\` — ${child.status}${label}`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Compact read-only rollup of direct epic children for chat/UI scope panels.
+ *
+ * @param {Array<object>} workItems
+ * @param {string} epicId
+ * @returns {object} schema workgraph.epic-work-scope.v1
+ */
+export function buildEpicWorkScopeSlice(workItems, epicId) {
+  const normalizedEpicId = String(epicId ?? '').trim();
+  if (normalizedEpicId === '') {
+    throw new TypeError('epicId is required');
+  }
+
+  const enriched = attachDerivedWorkItemHierarchy(workItems);
+  const epic = enriched.find((item) => item.id === normalizedEpicId);
+  if (!epic) {
+    throw new Error(`unknown epic id: ${normalizedEpicId}`);
+  }
+  if (readWorkItemKind(epic) !== 'epic') {
+    throw new Error(`work item is not an epic: ${normalizedEpicId}`);
+  }
+
+  const projection = buildEpicRoadmapProjection(enriched);
+  const entry = projection.epics.find((candidate) => candidate.epicId === normalizedEpicId);
+  if (!entry) {
+    throw new Error(`unknown epic id: ${normalizedEpicId}`);
+  }
+
+  return {
+    schema: EPIC_WORK_SCOPE_SCHEMA,
+    readOnly: true,
+    epicId: entry.epicId,
+    title: entry.title,
+    status: entry.status,
+    childCount: entry.childCount,
+    doneChildCount: entry.doneChildCount,
+    closeBlocked: entry.closeBlocked,
+    rollup: entry.rollup,
+    children: entry.children.map((child) => ({
+      id: child.workId,
+      title: child.title,
+      status: child.status,
+      itemKind: child.itemKind,
+    })),
+  };
+}

package/vendor/src/evalLiveLlmEnv.mjs

@@ -0,0 +1,63 @@
+const DEFAULT_LLM_BASE_URL = 'http://127.0.0.1:1234/v1';
+
+export function resolveLiveLlmEnv(env = process.env) {
+  const baseUrl = String(env.IOHASC_LLM_BASE_URL ?? DEFAULT_LLM_BASE_URL).trim().replace(/\/+$/u, '');
+  const model = String(env.IOHASC_LLM_MODEL ?? '').trim();
+  const apiKey = String(env.IOHASC_LLM_API_KEY ?? '').trim();
+
+  return {
+    IOHASC_E2E_REAL_LLM: '1',
+    IOHASC_LLM_BASE_URL: baseUrl,
+    IOHASC_LLM_MODEL: model,
+    IOHASC_LLM_API_KEY: apiKey,
+  };
+}
+
+export function validateLiveLlmEnv(env = process.env) {
+  const errors = [];
+  const resolved = resolveLiveLlmEnv(env);
+  const baseUrl = String(env.IOHASC_LLM_BASE_URL ?? DEFAULT_LLM_BASE_URL).trim();
+  const model = String(env.IOHASC_LLM_MODEL ?? '').trim();
+
+  if (!model) {
+    errors.push({
+      code: 'missing_model',
+      message: 'Set IOHASC_LLM_MODEL to the model id exposed by your OpenAI-compatible server.',
+    });
+  }
+
+  if (baseUrl !== '' && !/^https?:\/\//iu.test(baseUrl)) {
+    errors.push({
+      code: 'invalid_base_url',
+      message: 'IOHASC_LLM_BASE_URL must be an http(s) URL (example: http://127.0.0.1:1234/v1).',
+    });
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    config: resolved,
+    hints: {
+      powershell: "$env:IOHASC_E2E_REAL_LLM='1'; $env:IOHASC_LLM_BASE_URL='http://127.0.0.1:1234/v1'; $env:IOHASC_LLM_MODEL='your-model'; npm run eval:live-llm",
+      bash: "IOHASC_E2E_REAL_LLM=1 IOHASC_LLM_BASE_URL=http://127.0.0.1:1234/v1 IOHASC_LLM_MODEL=your-model npm run eval:live-llm",
+    },
+  };
+}
+
+export function formatLiveLlmEnvHelp(validation = validateLiveLlmEnv()) {
+  return [
+    'Live LLM eval wrapper (optional Tier B, non-blocking CI)',
+    'Runs: worker live-loop (--provider openai) + optional OneBase gate',
+    '',
+    'Required env:',
+    '  IOHASC_LLM_MODEL — model id on OpenAI-compatible proxy (LM Studio / LiteLLM / Ollama OpenAI route)',
+    '',
+    'Optional env:',
+    '  IOHASC_LLM_BASE_URL — default http://127.0.0.1:1234/v1',
+    '  IOHASC_LLM_API_KEY — Bearer token when proxy requires auth',
+    '  IOHASC_E2E_REAL_LLM=1 — set automatically by this wrapper',
+    '',
+    'Example:',
+    `  ${validation.hints.powershell}`,
+  ].join('\n');
+}

package/vendor/src/evidenceReadModel.mjs

@@ -0,0 +1,167 @@
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+function inferEvidenceType(summary) {
+  const text = String(summary);
+  if (/npm test|vitest|jest|go test/iu.test(text)) {
+    return 'test';
+  }
+
+  if (/npm run|node |command/iu.test(text)) {
+    return 'command';
+  }
+
+  if (/decision|решени/iu.test(text)) {
+    return 'decision';
+  }
+
+  if (/blocked|blocker/iu.test(text)) {
+    return 'blocker';
+  }
+
+  if (/worker|dry-run/iu.test(text)) {
+    return 'worker-run';
+  }
+
+  return 'change';
+}
+
+export function buildEvidenceRecordFromLegacyLine(taskId, summary, index) {
+  const type = inferEvidenceType(summary);
+  return {
+    schema: 'evidence-record.v1',
+    id: `${taskId}:legacy-evidence:${index + 1}`,
+    time: null,
+    source: 'workgraph.snapshot.v1',
+    taskId,
+    type,
+    summary: String(summary).trim(),
+    status: /fail|error|blocked/iu.test(summary) ? 'failed' : 'succeeded',
+    details: { importedFrom: 'legacy-evidence-string' },
+    artifacts: [],
+  };
+}
+
+export function buildEvidenceReadModelFromItems(items) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const records = items.flatMap((item) =>
+    (item.evidence ?? []).map((summary, index) => buildEvidenceRecordFromLegacyLine(item.id, summary, index)),
+  ).sort((left, right) => compareText(left.id, right.id));
+
+  return {
+    schema: 'evidence.read-model.v1',
+    count: records.length,
+    records,
+    compatibility: {
+      legacyStringEvidence: true,
+      structuredEvidenceV1: true,
+    },
+  };
+}
+
+export function buildEvidenceReadModelForTask(items, taskId) {
+  const item = items.find((entry) => entry.id === taskId);
+  if (item === undefined) {
+    return { schema: 'evidence.read-model.v1', count: 0, records: [], compatibility: { legacyStringEvidence: true, structuredEvidenceV1: true } };
+  }
+
+  return buildEvidenceReadModelFromItems([item]);
+}
+
+export function buildEvidenceTimelineForTask(items, taskId, options = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const normalizedTaskId = String(taskId ?? '').trim();
+  if (normalizedTaskId === '') {
+    throw new TypeError('taskId must be a non-empty string');
+  }
+
+  const item = items.find((entry) => entry.id === normalizedTaskId);
+  if (item === undefined) {
+    return {
+      schema: 'evidence.timeline.v1',
+      taskId: normalizedTaskId,
+      count: 0,
+      events: [],
+    };
+  }
+
+  const events = [];
+
+  for (const [index, summary] of (item.evidence ?? []).entries()) {
+    const record = buildEvidenceRecordFromLegacyLine(item.id, summary, index);
+    events.push({
+      id: record.id,
+      kind: 'evidence',
+      sequence: index + 1,
+      time: null,
+      title: record.type,
+      summary: record.summary,
+      status: record.status,
+    });
+  }
+
+  for (const [index, run] of (options.workerRuns ?? []).entries()) {
+    if (run.taskId !== normalizedTaskId) {
+      continue;
+    }
+
+    events.push({
+      id: `worker-run:${run.runId ?? `${normalizedTaskId}:${index + 1}`}`,
+      kind: 'transition',
+      sequence: 10_000 + index,
+      time: run.recordedAt ?? null,
+      title: 'worker transition',
+      summary: run.appliedTransition
+        ? `transition → ${run.appliedTransition}`
+        : String(run.summary ?? run.status ?? 'worker run'),
+      status: run.status ?? null,
+    });
+  }
+
+  if (item.blocker) {
+    events.push({
+      id: `${normalizedTaskId}:blocker`,
+      kind: 'transition',
+      sequence: 20_000,
+      time: null,
+      title: 'blocked',
+      summary: String(item.blocker),
+      status: 'blocked',
+    });
+  }
+
+  const sorted = [...events].sort((left, right) => {
+    const leftTime = left.time ? Date.parse(left.time) : null;
+    const rightTime = right.time ? Date.parse(right.time) : null;
+
+    if (leftTime === null && rightTime === null) {
+      return left.sequence - right.sequence;
+    }
+
+    if (leftTime === null) {
+      return -1;
+    }
+
+    if (rightTime === null) {
+      return 1;
+    }
+
+    if (leftTime !== rightTime) {
+      return leftTime - rightTime;
+    }
+
+    return left.sequence - right.sequence;
+  });
+
+  return {
+    schema: 'evidence.timeline.v1',
+    taskId: normalizedTaskId,
+    count: sorted.length,
+    events: sorted,
+  };
+}