@work-graph/cli 0.2.0

package/vendor/src/agentBehaviorRulesAudit.mjs

@@ -0,0 +1,168 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { parseStepAtomDrafts } from './stepAtomFormatter.mjs';
+import {
+  AGENT_BEHAVIOR_RULES_DIR,
+  PORTED_RULE_SOURCE_HINTS,
+  WORKER_BEHAVIOR_RULE_IDS,
+  loadAgentBehaviorRulesFromDir,
+} from './agentBehaviorRulesBundle.mjs';
+
+export const AGENT_BEHAVIOR_RULES_AUDIT_SCHEMA = 'workgraph.agent-behavior-rules-audit.v1';
+
+/** Canonical port map vs ../project/rules/agent-behavior/tool-rules-migrated.step */
+export const TOOL_RULES_MIGRATED_PORT_CATALOG = [
+  {
+    sourceAtom: 'Правила_Заметки_И_Пути',
+    status: 'deferred',
+    reason: 'Monaco writeFile/readFile/deleteFile tree; Work Graph uses MCP + bounded worker targetFiles',
+  },
+  {
+    sourceAtom: 'Команды_Shell_Npm',
+    status: 'deferred',
+    reason: 'Sidecar runCommand/bash; worker uses verification matrix gates',
+  },
+  {
+    sourceAtom: 'Режим_Агента_Доп_Правила',
+    status: 'adapted',
+    workGraphRuleId: 'worker-tool-policy',
+  },
+  {
+    sourceAtom: 'Только_Доставка_Через_Инструмент',
+    status: 'deferred',
+    reason: 'AGENT_TOOLS / writeFile delivery in Monaco chat',
+  },
+  {
+    sourceAtom: 'Настройка_MCP',
+    status: 'deferred',
+    reason: 'configureMcpServer UI flow in ioHasC settings',
+  },
+  {
+    sourceAtom: 'Стиль_Исполнения_Composer',
+    status: 'deferred',
+    reason: 'Composer chat UX; worker returns structured JSON output',
+  },
+  {
+    sourceAtom: 'Режим_По_Умолчанию_Разработчик',
+    status: 'ported',
+    workGraphRuleId: 'mcp-editing-policy',
+  },
+  {
+    sourceAtom: 'Планирование_И_Инструменты',
+    status: 'ported',
+    workGraphRuleId: 'mcp-loop-planning',
+  },
+  {
+    sourceAtom: 'Надёжное_Рассуждение_Guardrails',
+    status: 'ported',
+    workGraphRuleId: 'mcp-read-guardrails',
+  },
+  {
+    sourceAtom: 'После_Правок_LSP',
+    status: 'deferred',
+    reason: 'Monaco LSP sidecar diagnostics',
+  },
+  {
+    sourceAtom: 'После_Правок_Тесты',
+    status: 'adapted',
+    workGraphRuleId: 'worker-evidence-gates',
+  },
+  {
+    sourceAtom: 'Формат_Вызовов_Инструментов',
+    status: 'deferred',
+    reason: 'AGENT_TOOLS markdown / native tool_calls in orchestrator',
+  },
+  {
+    sourceAtom: 'Структурированный_Итог_PVRG',
+    status: 'adapted',
+    workGraphRuleId: 'mcp-read-guardrails',
+  },
+  {
+    sourceAtom: 'Обратная_Связь_По_Плану',
+    status: 'deferred',
+    reason: 'Plan mode orchestrator nudges',
+  },
+  {
+    sourceAtom: 'Агент_Low_Code_Устав',
+    status: 'deferred',
+    reason: 'generateFromCharter sidecar in ioHasC IDE',
+  },
+];
+
+const catalogBySourceAtom = new Map(
+  TOOL_RULES_MIGRATED_PORT_CATALOG.map((entry) => [entry.sourceAtom, entry]),
+);
+
+export async function parseToolRulesMigratedSourceAtomNames(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const sourcePath = resolve(cwd, options.sourcePath ?? '../project/rules/agent-behavior/tool-rules-migrated.step');
+  const text = options.sourceText ?? await readFile(sourcePath, 'utf8');
+  return parseStepAtomDrafts(text).map((parsed) => parsed.draft.name);
+}
+
+export async function auditToolRulesMigratedPort(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const sourcePath = options.sourcePath ?? '../project/rules/agent-behavior/tool-rules-migrated.step';
+  const sourceAtoms = await parseToolRulesMigratedSourceAtomNames({ cwd, sourcePath, sourceText: options.sourceText });
+  const allRules = await loadAgentBehaviorRulesFromDir({ cwd, ...options });
+  const ruleIds = new Set(allRules.map((rule) => rule.id));
+
+  const rows = sourceAtoms.map((sourceAtom) => {
+    const catalog = catalogBySourceAtom.get(sourceAtom);
+    if (!catalog) {
+      return {
+        sourceAtom,
+        status: 'missing_catalog_entry',
+        workGraphRuleId: null,
+        rulePresent: false,
+        ok: false,
+      };
+    }
+
+    const workGraphRuleId = catalog.workGraphRuleId ?? null;
+    const rulePresent = workGraphRuleId ? ruleIds.has(workGraphRuleId) : catalog.status === 'deferred';
+
+    return {
+      sourceAtom,
+      status: catalog.status,
+      reason: catalog.reason ?? null,
+      workGraphRuleId,
+      rulePresent,
+      ok: catalog.status === 'deferred' || catalog.status === 'adapted' || rulePresent,
+    };
+  });
+
+  const covered = rows.filter((row) => row.status === 'ported' || row.status === 'adapted');
+  const deferred = rows.filter((row) => row.status === 'deferred');
+  const missing = rows.filter((row) => !row.ok);
+
+  return {
+    schema: AGENT_BEHAVIOR_RULES_AUDIT_SCHEMA,
+    sourcePath,
+    rulesDir: AGENT_BEHAVIOR_RULES_DIR,
+    workerRuleIds: [...WORKER_BEHAVIOR_RULE_IDS],
+    sourceRuleCount: sourceAtoms.length,
+    catalogEntryCount: TOOL_RULES_MIGRATED_PORT_CATALOG.length,
+    coveredCount: covered.length,
+    deferredCount: deferred.length,
+    missingCount: missing.length,
+    ok: missing.length === 0 && sourceAtoms.length === TOOL_RULES_MIGRATED_PORT_CATALOG.length,
+    rows,
+    portedSourceHints: PORTED_RULE_SOURCE_HINTS,
+  };
+}
+
+export function formatAgentBehaviorRulesAuditReport(report) {
+  const lines = [
+    `agent behavior rules audit: ${report.ok ? 'ok' : 'failed'} (${report.coveredCount} covered/adapted, ${report.deferredCount} deferred, ${report.missingCount} missing)`,
+    `source: ${report.sourcePath}`,
+    `worker rule ids: ${report.workerRuleIds.join(', ')}`,
+  ];
+
+  for (const row of report.rows) {
+    lines.push(`${row.ok ? 'ok' : 'fail'}: ${row.sourceAtom} → ${row.status}${row.workGraphRuleId ? ` (${row.workGraphRuleId})` : ''}`);
+  }
+
+  return lines.join('\n');
+}

package/vendor/src/agentBehaviorRulesBundle.mjs

@@ -0,0 +1,144 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { collectStepFilePaths } from './promptRulesProjection.mjs';
+import { parseStepAtomDrafts } from './stepAtomFormatter.mjs';
+
+export const AGENT_BEHAVIOR_BUNDLE_SCHEMA = 'workgraph.agent-behavior-rules-bundle.v1';
+export const AGENT_BEHAVIOR_RULES_DIR = 'rules/agent-behavior';
+
+/** Rule ids injected into worker/OpenAI prompt slice (minimal port subset). */
+export const WORKER_BEHAVIOR_RULE_IDS = [
+  'golden-path',
+  'worker-tool-policy',
+  'worker-provider-neutrality',
+  'worker-failure-retry',
+  'worker-evidence-gates',
+  'worker-task-bound-run',
+  'mcp-read-guardrails',
+  'mcp-loop-planning',
+  'mcp-editing-policy',
+  'cursor-ide-workgraph-parity',
+  'chat-work-scope-readonly',
+  'work-item-create-analysis-decision',
+];
+
+/** Rule ids for MCP agent prompt slice (includes worker subset). */
+export const MCP_BEHAVIOR_RULE_IDS = [...WORKER_BEHAVIOR_RULE_IDS];
+
+/** Documented port map (subset); full tool-rules-migrated.bvc remains in ../project. */
+export const PORTED_RULE_SOURCE_HINTS = {
+  'worker-tool-policy': '../project/rules/agent-behavior/tool-rules-migrated.step (tool policy, bounded scope)',
+  'worker-provider-neutrality': '../project/rules/agent-behavior/tool-rules-migrated.step (provider-neutral execution)',
+  'worker-failure-retry': '../project/rules/agent-behavior/tool-rules-migrated.step (errors / retry)',
+  'worker-evidence-gates': '../project/rules/agent-behavior/tool-rules-migrated.step (evidence / verification)',
+  'worker-task-bound-run': '../project/rules/agent-behavior/tool-rules-migrated.step (task-bound agent run)',
+  'mcp-read-guardrails': '../project/rules/agent-behavior/tool-rules-migrated.step#Надёжное_Рассуждение_Guardrails',
+  'mcp-loop-planning': '../project/rules/agent-behavior/tool-rules-migrated.step#Планирование_И_Инструменты',
+  'mcp-editing-policy': '../project/rules/agent-behavior/tool-rules-migrated.step#Режим_По_Умолчанию_Разработчик',
+  'cursor-ide-workgraph-parity': 'rules/agent-behavior/cursor-ide-workgraph-parity.bvc',
+  'chat-work-scope-readonly': 'rules/agent-behavior/chat-work-scope-readonly.bvc',
+  'golden-path': 'rules/agent-behavior/rebuild.bvc',
+  'work-item-create-analysis-decision': 'rules/agent-behavior/work-item-create-analysis-decision.bvc',
+};
+
+const DEFAULT_PROMPT_SLICE_MAX_CHARS = 5500;
+
+export function buildBehaviorRuleRecord(filePath, draft, labels) {
+  const ruleId = labels['rule.id'] ?? draft.name;
+
+  return {
+    id: ruleId,
+    name: draft.name,
+    filePath,
+    basis: joinLines(draft.basis),
+    vector: joinLines(draft.vector),
+    goal: joinLines(draft.goal),
+    labels,
+    bundleGroup: labels['bundle.group'] ?? null,
+    traceStatus: labels['trace.status'] ?? 'unknown',
+  };
+}
+
+export async function loadAgentBehaviorRulesFromDir(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const roots = options.roots ?? [AGENT_BEHAVIOR_RULES_DIR];
+  const filePaths = options.filePaths ?? await collectStepFilePaths(cwd, roots);
+  const rulesById = new Map();
+
+  for (const filePath of filePaths) {
+    const absolutePath = resolve(cwd, filePath);
+    const text = options.fileContents?.[filePath] ?? await readFile(absolutePath, 'utf8');
+
+    for (const parsed of parseStepAtomDrafts(text)) {
+      if (parsed.draft.profile !== 'prompt_rule') {
+        continue;
+      }
+
+      const labels = parsed.draft.labels ?? {};
+      const ruleId = labels['rule.id'] ?? parsed.draft.name;
+      const record = buildBehaviorRuleRecord(filePath, parsed.draft, labels);
+
+      if (!parsed.errors.length) {
+        rulesById.set(ruleId, record);
+      }
+    }
+  }
+
+  return [...rulesById.values()].sort((left, right) => left.id.localeCompare(right.id, 'en'));
+}
+
+export function selectWorkerBehaviorRules(allRules, ruleIds = WORKER_BEHAVIOR_RULE_IDS) {
+  const byId = new Map(allRules.map((rule) => [rule.id, rule]));
+
+  return ruleIds
+    .map((ruleId) => byId.get(ruleId))
+    .filter(Boolean);
+}
+
+export function buildAgentBehaviorPromptSlice(rules, options = {}) {
+  const maxChars = options.maxChars ?? DEFAULT_PROMPT_SLICE_MAX_CHARS;
+  const chunks = [];
+
+  for (const rule of rules) {
+    chunks.push(
+      `[${rule.id}]\nБазис: ${rule.basis}\nВектор: ${rule.vector}\nЦель: ${rule.goal}`,
+    );
+  }
+
+  let slice = chunks.join('\n\n');
+
+  if (slice.length > maxChars) {
+    slice = `${slice.slice(0, maxChars - 3)}...`;
+  }
+
+  return slice;
+}
+
+export async function loadAgentBehaviorRulesBundle(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const ruleIds = options.ruleIds ?? WORKER_BEHAVIOR_RULE_IDS;
+  const allRules = await loadAgentBehaviorRulesFromDir({ cwd, ...options });
+  const workerRules = selectWorkerBehaviorRules(allRules, ruleIds);
+  const missingRuleIds = ruleIds.filter((ruleId) => !workerRules.some((rule) => rule.id === ruleId));
+
+  return {
+    schema: AGENT_BEHAVIOR_BUNDLE_SCHEMA,
+    rulesDir: AGENT_BEHAVIOR_RULES_DIR,
+    ruleIds: workerRules.map((rule) => rule.id),
+    workerRules,
+    allRules,
+    missingRuleIds,
+    promptSlice: buildAgentBehaviorPromptSlice(workerRules, options),
+    portedSourceHints: PORTED_RULE_SOURCE_HINTS,
+    ok: missingRuleIds.length === 0,
+  };
+}
+
+function joinLines(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return '';
+  }
+
+  return values.map((value) => String(value).trim()).filter(Boolean).join(' ');
+}

package/vendor/src/agentRunApi.mjs

@@ -0,0 +1,136 @@
+import {
+  appendWorkerRunJournal,
+  readWorkerRunJournal,
+  runAgentWorkerLiveLoop,
+} from './agentWorkerLiveLoop.mjs';
+import {
+  persistWorkItemUpdateToRepo,
+  readWorkItemsFromRepo,
+} from './intentTreeWorkItems.mjs';
+import { buildWorkerProviderCatalog } from './workGraphWorkerProvider.mjs';
+
+const AGENT_RUN_RESPONSE_SCHEMA = 'operator.agent-run.response.v1';
+
+export function resolveAgentRunProvider(provider) {
+  const value = String(provider ?? 'auto').trim().toLowerCase();
+
+  if (value === '' || value === 'auto') {
+    return undefined;
+  }
+
+  if (value === 'local' || value === 'openai' || value === 'openai-compatible') {
+    return value === 'openai-compatible' ? 'openai' : value;
+  }
+
+  throw new Error(`unsupported agent run provider: ${provider}`);
+}
+
+export function parseAgentRunRequestBody(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('agent run body must be a JSON object');
+  }
+
+  return body;
+}
+
+export function buildAgentRunResponse(result) {
+  return {
+    schema: AGENT_RUN_RESPONSE_SCHEMA,
+    ok: Boolean(result.ok),
+    error: result.error ?? null,
+    taskId: result.taskId ?? null,
+    steps: Array.isArray(result.steps) ? result.steps : [],
+    workerRunSummary: result.workerRunSummary ?? null,
+    workerOutput: result.workerOutput ?? null,
+    providerResult: result.providerResult ?? null,
+    transitionProposal: result.transitionProposal ?? null,
+    appliedTransition: result.appliedTransition ?? null,
+    transitionError: result.transitionError ?? null,
+    persistedBacklog: Boolean(result.persistedBacklog),
+    persistBacklogError: result.persistBacklogError ?? null,
+  };
+}
+
+export async function executeAgentRun(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const body = parseAgentRunRequestBody(options.body ?? {});
+  const items = await readWorkItemsFromRepo({ ...options, cwd });
+
+  const provider = resolveAgentRunProvider(body.provider);
+  const result = await runAgentWorkerLiveLoop(items, {
+    taskId: body.taskId,
+    provider,
+    enableFallback: body.enableFallback !== false,
+    workerInput: body.policyPreset === 'verification'
+      ? { policy: { mode: 'dry-run' } }
+      : { policy: { mode: 'dry-run' } },
+    recordedAt: options.recordedAt,
+  });
+
+  if (options.writeJournal !== false && result.workerRunSummary) {
+    await appendWorkerRunJournal(result.workerRunSummary, {
+      cwd,
+      journalPath: options.journalPath,
+    });
+  }
+
+  const persistBacklog = body.persistBacklog !== false && options.persistBacklog !== false;
+  let persistedBacklog = false;
+  let persistBacklogError = null;
+
+  if (
+    persistBacklog
+    && result.taskId
+    && result.appliedTransition
+    && !result.transitionError
+    && Array.isArray(result.finalItems)
+  ) {
+    const updatedItem = result.finalItems.find((item) => item.id === result.taskId);
+
+    if (updatedItem) {
+      try {
+        await persistWorkItemUpdateToRepo({
+          ...options,
+          cwd,
+          item: updatedItem,
+        });
+        persistedBacklog = true;
+      } catch (error) {
+        persistBacklogError = error instanceof Error ? error.message : String(error);
+      }
+    }
+  }
+
+  return buildAgentRunResponse({
+    ...result,
+    persistedBacklog,
+    persistBacklogError,
+  });
+}
+
+export function readWorkerProviderCatalogResponse() {
+  return buildWorkerProviderCatalog();
+}
+
+export async function readAgentRunJournalResponse(options = {}) {
+  const entries = await readWorkerRunJournal({
+    cwd: options.cwd,
+    journalPath: options.journalPath,
+  });
+  const limit = Number(options.limit ?? 20);
+
+  return {
+    schema: 'operator.agent-run.journal.v1',
+    entries: entries.slice(-limit).reverse(),
+  };
+}

package/vendor/src/agentToolLoopGuard.mjs

@@ -0,0 +1,88 @@
+/**
+ * Minimal port of ioHasC agentToolLoopKey loop guard for Work Graph eval/runtime hooks.
+ */
+
+export const AGENT_TOOL_LOOP_THRESHOLD = 3;
+
+function stableJsonFragment(value) {
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+
+  const type = typeof value;
+  if (type === 'boolean' || type === 'number') {
+    return JSON.stringify(value);
+  }
+  if (type === 'string') {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableJsonFragment(entry)).join(',')}]`;
+  }
+  if (type === 'object') {
+    const object = /** @type {Record<string, unknown>} */ (value);
+    const keys = Object.keys(object).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJsonFragment(object[key])}`).join(',')}}`;
+  }
+
+  return JSON.stringify(String(value));
+}
+
+export function agentToolLoopThresholdForTool(toolName, options = {}) {
+  const normalized = String(toolName ?? '').trim();
+  let base = AGENT_TOOL_LOOP_THRESHOLD;
+
+  if (normalized === 'claim_work_item' || normalized === 'get_work_item') {
+    base = 2;
+  } else if (normalized === 'get_pvrg_task_scope' || normalized === 'get_unified_linkage') {
+    base = 2;
+  } else if (normalized.startsWith('agentWorkGraph')) {
+    base = 2;
+  }
+
+  if (
+    options.isWeakModel === true
+    && typeof options.maxSameToolCallsWeak === 'number'
+    && options.maxSameToolCallsWeak >= 1
+  ) {
+    return Math.min(base, options.maxSameToolCallsWeak);
+  }
+
+  return base;
+}
+
+export function stableAgentToolLoopKey(toolName, rawArgs) {
+  const normalized = String(toolName ?? '').trim();
+  const args = rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)
+    ? rawArgs
+    : {};
+  return `${normalized}:${stableJsonFragment(args)}`;
+}
+
+export function formatAgentToolDuplicateInvocationLoopHint(toolName, loopStreak) {
+  return `⚠️ LOOP_HINT: инструмент «${toolName}» с теми же аргументами повторён ${loopStreak} раз за этот ход (включая вызовы не подряд). Измени аргументы, выбери другой инструмент или ответь текстом; не зацикливай один и тот же вызов.`;
+}
+
+export function createAgentToolLoopTracker(options = {}) {
+  const counts = new Map();
+
+  return {
+    record(toolName, rawArgs) {
+      const key = stableAgentToolLoopKey(toolName, rawArgs);
+      const nextCount = (counts.get(key) ?? 0) + 1;
+      counts.set(key, nextCount);
+      const threshold = agentToolLoopThresholdForTool(toolName, options);
+      const loopAborted = nextCount >= threshold;
+      return {
+        key,
+        loopStreak: nextCount,
+        threshold,
+        loopAborted,
+        loopHint: loopAborted ? formatAgentToolDuplicateInvocationLoopHint(toolName, nextCount) : null,
+      };
+    },
+    snapshot() {
+      return Object.fromEntries(counts.entries());
+    },
+  };
+}