@besales/ops-framework 0.1.0

package/bin/lib/bootstrap-utils.mjs

@@ -0,0 +1,542 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveProjectContext } from './project-config.mjs';
+
+export const DEFAULT_OPS_ROOT = 'ops';
+export const DEFAULT_PIPELINE_ROOT = 'ops/agent-pipeline';
+export const DEFAULT_TASKS_DIR = 'ops/agent-pipeline/tasks';
+export const DEFAULT_MEMORY_DIR = 'ops/agent-pipeline/memory';
+export const DEFAULT_CACHE_DIR = 'ops/agent-pipeline/cache';
+export const DEFAULT_CONFIG_DIR = 'ops/agent-pipeline/config';
+export const DEFAULT_PLAYBOOKS_DIR = 'ops/agent-pipeline/playbooks';
+export const DEFAULT_AGENTS_CONFIG = 'ops/agent-pipeline/config/agents.json';
+export const TASK_ID_PATTERN = /^TASK-\d{3}-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export const REQUIRED_MEMORY_FILES = [
+  'project-context-digest.md',
+  'module-boundaries.md',
+  'standards-digest.md',
+  'recurring-failures.md',
+  'domain-glossary.md',
+  'checker-rubric.md',
+];
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, '..', '..');
+
+export function initProject({
+  projectRoot = process.cwd(),
+  projectName = path.basename(path.resolve(projectRoot)),
+  opsRoot = DEFAULT_OPS_ROOT,
+  installScripts = false,
+  frameworkPackage = null,
+  frameworkVersion = null,
+  force = false,
+} = {}) {
+  const normalizedProjectRoot = path.resolve(projectRoot);
+  const normalizedOpsRoot = normalizeRelativePath(opsRoot, 'ops root');
+  const paths = buildProjectPaths({ projectRoot: normalizedProjectRoot, opsRoot: normalizedOpsRoot });
+  const changes = [];
+
+  ensureDirectory(paths.opsRoot, changes);
+  ensureDirectory(paths.pipelineRoot, changes);
+  ensureDirectory(paths.tasksRoot, changes);
+  ensureDirectory(paths.memoryRoot, changes);
+  ensureDirectory(paths.cacheRoot, changes);
+  ensureDirectory(paths.configRoot, changes);
+  ensureDirectory(paths.playbooksRoot, changes);
+
+  writeFileIfAllowed(paths.projectConfig, buildProjectConfig({ projectName, opsRoot: normalizedOpsRoot }), {
+    force,
+    changes,
+  });
+  writeFileIfAllowed(paths.agentsConfig, readDefaultAgentsConfig(), {
+    force,
+    changes,
+  });
+  writeFileIfAllowed(path.join(paths.playbooksRoot, 'README.md'), buildProjectPlaybooksReadme(), {
+    force,
+    changes,
+  });
+
+  for (const fileName of REQUIRED_MEMORY_FILES) {
+    writeFileIfAllowed(path.join(paths.memoryRoot, fileName), buildMemoryFile(fileName, projectName), {
+      force,
+      changes,
+    });
+  }
+
+  if (installScripts) {
+    upsertPackageScripts({
+      packageJsonPath: path.join(normalizedProjectRoot, 'package.json'),
+      packageSpec: buildFrameworkPackageSpec({ frameworkPackage, frameworkVersion }),
+      changes,
+    });
+  }
+
+  return {
+    projectRoot: normalizedProjectRoot,
+    projectName,
+    opsRoot: normalizedOpsRoot,
+    paths,
+    changes,
+  };
+}
+
+export function buildFrameworkPackageSpec({ frameworkPackage = null, frameworkVersion = null } = {}) {
+  const ownPackageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  const packageName = frameworkPackage || ownPackageJson.name || '@besales/ops-framework';
+  const version = frameworkVersion || ownPackageJson.version;
+  return version ? `${packageName}@${version}` : packageName;
+}
+
+export function buildOpsScripts(packageSpec) {
+  const run = (command) => `corepack yarn dlx ${packageSpec} ${command}`;
+  return {
+    ops: `corepack yarn dlx ${packageSpec}`,
+    'agent:build-check-context': run('build-check-context'),
+    'agent:validate-check-artifacts': run('validate-check-artifacts'),
+    'agent:manifest': run('manifest'),
+    'agent:preflight': run('preflight'),
+    'agent:transition': run('transition'),
+    'agent:estimate-llm-input': run('estimate-llm-input'),
+    'agent:quality-gates': run('quality-gates'),
+    'agent:run-check': run('run-check'),
+    'agent:run-verify': run('run-verify'),
+    'agent:hash-task-artifacts': run('hash-task-artifacts'),
+    'agent:build-execution-ledger': run('build-execution-ledger'),
+    'agent:task-metrics': run('task-metrics'),
+    'agent:run-plan-check-loop': run('run-plan-check-loop'),
+    'agent:supervisor-turn': run('supervisor-turn'),
+    'agent:intake-feedback': run('intake-feedback'),
+    'agent:intake-execution-feedback': run('intake-execution-feedback'),
+    'agent:guard-task': run('guard-task'),
+    'agent:memory-candidates': run('memory-candidates'),
+    'agent:learning-index': run('learning-index'),
+    'agent:learning-review': run('learning-review'),
+    'agent:update-memory': run('update-memory'),
+    'agent:learning-audit': run('learning-audit'),
+    'agent:learning-report': run('learning-report'),
+    'agent:test': run('test/self-test'),
+  };
+}
+
+function upsertPackageScripts({ packageJsonPath, packageSpec, changes }) {
+  if (!fs.existsSync(packageJsonPath)) {
+    changes.push({
+      path: packageJsonPath,
+      kind: 'file',
+      status: 'existing',
+      note: 'package.json not found; ops scripts not installed',
+    });
+    return;
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  packageJson.scripts = {
+    ...(packageJson.scripts || {}),
+    ...buildOpsScripts(packageSpec),
+  };
+  fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+  changes.push({ path: packageJsonPath, kind: 'file', status: 'overwritten' });
+}
+
+export function createTask({
+  projectRoot = process.cwd(),
+  taskId,
+  title,
+  owner = 'Supervisor',
+  force = false,
+} = {}) {
+  if (!TASK_ID_PATTERN.test(taskId || '')) {
+    throw new Error(`Task id must match ${TASK_ID_PATTERN}: ${taskId || '<missing>'}`);
+  }
+  const normalizedProjectRoot = path.resolve(projectRoot);
+  const projectContext = resolveProjectContext({ cwd: normalizedProjectRoot });
+  const tasksRoot = projectContext.configPath
+    ? projectContext.tasksRoot
+    : buildProjectPaths({ projectRoot: normalizedProjectRoot, opsRoot: DEFAULT_OPS_ROOT }).tasksRoot;
+  const paths = { tasksRoot };
+  const taskDir = path.join(paths.tasksRoot, taskId);
+  const taskTitle = title || humanizeTaskId(taskId);
+  const changes = [];
+
+  ensureDirectory(paths.tasksRoot, changes);
+  ensureDirectory(taskDir, changes);
+
+  const files = new Map([
+    ['brief.md', buildBrief({ taskTitle })],
+    ['research.md', buildResearch()],
+    ['plan.md', buildPlan()],
+    ['status.md', buildStatus({ taskId, owner })],
+    ['orchestration-log.md', buildOrchestrationLog({ taskId })],
+  ]);
+
+  for (const [fileName, content] of files.entries()) {
+    writeFileIfAllowed(path.join(taskDir, fileName), content, { force, changes });
+  }
+
+  return {
+    projectRoot: normalizedProjectRoot,
+    taskId,
+    taskDir,
+    changes,
+  };
+}
+
+export function summarizeChanges(changes) {
+  const summary = {
+    created: 0,
+    overwritten: 0,
+    existing: 0,
+  };
+  for (const change of changes) {
+    summary[change.status] += 1;
+  }
+  return summary;
+}
+
+export function assertPortableGeneratedConfig({ projectConfigContent, agentsConfigContent }) {
+  const combined = `${projectConfigContent}\n${agentsConfigContent}`;
+  const forbiddenPatterns = [
+    /\/Users\//,
+    /\/private\/tmp\//,
+    new RegExp(['Leak', 'Engine'].join('')),
+    new RegExp(['Delivery', 'Os'].join('')),
+    new RegExp(['Personal', 'Blog'].join('')),
+    /\.env/,
+    /access[_-]?token/i,
+    /api[_-]?key/i,
+    /secret[_-]?(key|value)?/i,
+  ];
+
+  for (const pattern of forbiddenPatterns) {
+    if (pattern.test(combined)) {
+      throw new Error(`Generated config is not portable; matched ${pattern}`);
+    }
+  }
+}
+
+function buildProjectPaths({ projectRoot, opsRoot }) {
+  const pipelineRoot = `${opsRoot}/agent-pipeline`;
+  return {
+    opsRoot: path.join(projectRoot, opsRoot),
+    pipelineRoot: path.join(projectRoot, pipelineRoot),
+    tasksRoot: path.join(projectRoot, pipelineRoot, 'tasks'),
+    memoryRoot: path.join(projectRoot, pipelineRoot, 'memory'),
+    cacheRoot: path.join(projectRoot, pipelineRoot, 'cache'),
+    configRoot: path.join(projectRoot, pipelineRoot, 'config'),
+    playbooksRoot: path.join(projectRoot, pipelineRoot, 'playbooks'),
+    projectConfig: path.join(projectRoot, opsRoot, 'project.ops.yaml'),
+    agentsConfig: path.join(projectRoot, pipelineRoot, 'config', 'agents.json'),
+  };
+}
+
+function normalizeRelativePath(value, label) {
+  if (!value || path.isAbsolute(value) || value.includes('..')) {
+    throw new Error(`${label} must be a project-relative path without '..': ${value || '<missing>'}`);
+  }
+  return value.replace(/^\.\/+/, '').replace(/\/+$/, '') || DEFAULT_OPS_ROOT;
+}
+
+function ensureDirectory(dirPath, changes) {
+  if (fs.existsSync(dirPath)) {
+    changes.push({ path: dirPath, kind: 'dir', status: 'existing' });
+    return;
+  }
+  fs.mkdirSync(dirPath, { recursive: true });
+  changes.push({ path: dirPath, kind: 'dir', status: 'created' });
+}
+
+function writeFileIfAllowed(filePath, content, { force, changes }) {
+  const normalizedContent = content.endsWith('\n') ? content : `${content}\n`;
+  if (fs.existsSync(filePath) && !force) {
+    changes.push({ path: filePath, kind: 'file', status: 'existing' });
+    return;
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const status = fs.existsSync(filePath) ? 'overwritten' : 'created';
+  fs.writeFileSync(filePath, normalizedContent);
+  changes.push({ path: filePath, kind: 'file', status });
+}
+
+function buildProjectConfig({ projectName, opsRoot }) {
+  return [
+    `name: ${sanitizeYamlScalar(projectName)}`,
+    'ops:',
+    `  legacyPipelineDir: ${opsRoot}/agent-pipeline`,
+    `  tasksDir: ${opsRoot}/agent-pipeline/tasks`,
+    `  memoryDir: ${opsRoot}/agent-pipeline/memory`,
+    `  cacheDir: ${opsRoot}/agent-pipeline/cache`,
+    `  playbooksDir: ${opsRoot}/agent-pipeline/playbooks`,
+    'agents:',
+    `  configFile: ${opsRoot}/agent-pipeline/config/agents.json`,
+    'risk:',
+    '  uiRoots:',
+    '    # - apps/web',
+    '  backendRoots:',
+    '    # - apps/api',
+    '  workerRoots:',
+    '    # - apps/workers',
+    '',
+  ].join('\n');
+}
+
+function readDefaultAgentsConfig() {
+  const content = fs.readFileSync(path.join(packageRoot, 'config', 'default-agents.json'), 'utf8');
+  const parsed = JSON.parse(content);
+  return `${JSON.stringify(parsed, null, 2)}\n`;
+}
+
+function buildMemoryFile(fileName, projectName) {
+  const title = fileName.replace(/\.md$/, '').split('-').map(capitalize).join(' ');
+  return [
+    `# ${title}`,
+    '',
+    `Project: ${projectName}`,
+    '',
+    'Bootstrap placeholder. Update this file with project-specific memory as the project evolves.',
+    '',
+  ].join('\n');
+}
+
+function buildProjectPlaybooksReadme() {
+  return [
+    '# Project Playbooks',
+    '',
+    'Shared playbooks live in the Ops Framework package.',
+    '',
+    'Project playbooks live here and should contain project-specific routes, commands, services, environments and provider quirks.',
+    '',
+    'When a project playbook has the same file name as a shared playbook, it extends the shared playbook as a project overlay.',
+    '',
+    'Do not copy secrets or local machine paths into project playbooks.',
+    '',
+  ].join('\n');
+}
+
+function buildBrief({ taskTitle }) {
+  return [
+    '# Brief',
+    '',
+    '## Задача',
+    '',
+    taskTitle,
+    '',
+    '## Зачем это нужно',
+    '',
+    'Проверить, что Ops Framework bootstrap работает в этом проекте.',
+    '',
+    '## Критерии успеха',
+    '',
+    '- Task artifacts созданы в project-owned `ops/**`.',
+    '- Framework lifecycle commands запускаются из project root.',
+    '',
+    '## Ограничения',
+    '',
+    '- Не трогать runtime-код проекта без отдельного approval.',
+    '',
+    '## Что точно вне scope',
+    '',
+    '- Deploy, DB migrations, provider integrations.',
+    '',
+    '## Что дал человек-владелец',
+    '',
+    '- Bootstrap smoke task.',
+    '',
+    '## Открытые вопросы',
+    '',
+    '- Нет.',
+    '',
+  ].join('\n');
+}
+
+function buildResearch() {
+  return [
+    '# Research',
+    '',
+    '## Цель исследования',
+    '',
+    'Подтвердить bootstrap-ready состояние проекта.',
+    '',
+    '## Подтвержденные repo findings',
+    '',
+    '- Project-owned ops structure создана локально.',
+    '',
+    '## Затронутые модули и файлы',
+    '',
+    '- `ops/**`',
+    '',
+    '## Риски и ограничения',
+    '',
+    '- Runtime-код не меняется.',
+    '',
+    '## Открытые вопросы',
+    '',
+    '- Нет.',
+    '',
+    '## Рекомендации для planning',
+    '',
+    '- Использовать docs-only/local-only проверку.',
+    '',
+  ].join('\n');
+}
+
+function buildPlan() {
+  return [
+    '# Plan',
+    '',
+    '## Цель',
+    '',
+    'Проверить минимальный lifecycle Ops Framework в новом проекте.',
+    '',
+    '## Опора на research',
+    '',
+    '- Project-owned ops structure создана.',
+    '',
+    '## Допущения',
+    '',
+    '- Проверка docs-only/local-only.',
+    '',
+    '## Затронутые модули и файлы',
+    '',
+    '- `ops/**`',
+    '',
+    '## Risk tier and execution budget',
+    '',
+    '- Risk tier: `R1`',
+    '- Speed mode: `Fast`',
+    '- Approved execution target: project-owned `ops/**`.',
+    '- Fast-loop allowed inside this slice: task artifact updates only.',
+    '- Requires return to Plan/Check if product code, secrets, data storage or external integrations become involved.',
+    '',
+    '## Checker Context Hints',
+    '',
+    '- Required repo files for Checker to inspect: `ops/**`.',
+    '- Prior relevant failures: none.',
+    '- Exact questions Checker must answer: bootstrap artifacts stay project-owned.',
+    '- Relevant playbooks: checker-context, complexity-performance.',
+    '',
+    '## Шаги реализации',
+    '',
+    '1. Собрать check context.',
+    '2. Проверить manifest/preflight.',
+    '',
+    '## Риски и открытые вопросы',
+    '',
+    '- Нет.',
+    '',
+    '## План проверки',
+    '',
+    '### Verification ladder',
+    '',
+    '- Micro-verify during Execute: manifest/preflight/build-check-context.',
+    '- Slice-verify before completion: generated artifacts remain under project-owned `ops/**`.',
+    '- External Verify required before closeout: `no`, docs-only smoke.',
+    '',
+    '## Что требует human approval',
+    '',
+    '- Любые изменения вне project-owned `ops/**`.',
+    '',
+  ].join('\n');
+}
+
+function buildStatus({ taskId, owner }) {
+  return [
+    '# Status',
+    '',
+    '## Task ID',
+    '',
+    `\`${taskId}\``,
+    '',
+    '## Текущий этап',
+    '',
+    'Brief',
+    '',
+    '## Текущий owner',
+    '',
+    `\`${owner}\``,
+    '',
+    '## Latest routing decision',
+    '',
+    '`task_created_by_ops_agent_new_task`',
+    '',
+    '## Plan SHA',
+    '',
+    '`not_started`',
+    '',
+    '## Memory SHA',
+    '',
+    '`not_started`',
+    '',
+    '## Latest check verdict',
+    '',
+    '`not_started`',
+    '',
+    '## Latest check result',
+    '',
+    '- `check.result.json`: missing',
+    '',
+    '## Latest check resolution',
+    '',
+    '- `check-resolution.md`: not_required',
+    '',
+    '## Human Gate summary',
+    '',
+    '- `human-gate-summary.md`: not_required',
+    '',
+    '## Feedback intake',
+    '',
+    '- `feedback.md`: no_events',
+    '',
+    '## Latest verify verdict',
+    '',
+    '`not_started`',
+    '',
+    '## Latest verify result',
+    '',
+    '- `verify.result.json`: missing',
+    '',
+    '## Последнее действие supervisor',
+    '',
+    'Task artifacts created by `ops-agent new-task`.',
+    '',
+    '## Что ожидается на выходе текущего этапа',
+    '',
+    'Fill task brief or run bootstrap smoke validation.',
+    '',
+    '## Нужен ли сейчас human approval',
+    '',
+    'no',
+    '',
+    '## Следующий шаг',
+    '',
+    'Continue framework lifecycle.',
+    '',
+  ].join('\n');
+}
+
+function buildOrchestrationLog({ taskId }) {
+  return [
+    '# Orchestration Log',
+    '',
+    '## Entries',
+    '',
+    `- \`${new Date().toISOString()}\` — task \`${taskId}\` created by \`ops-agent new-task\`.`,
+    '',
+  ].join('\n');
+}
+
+function humanizeTaskId(taskId) {
+  return taskId.replace(/^TASK-\d{3}-/, '').split('-').map(capitalize).join(' ');
+}
+
+function capitalize(value) {
+  return value ? `${value[0].toUpperCase()}${value.slice(1)}` : value;
+}
+
+function sanitizeYamlScalar(value) {
+  return String(value || 'Project').replace(/[^A-Za-z0-9_-]/g, '-');
+}

package/bin/lib/bootstrap-utils.test.mjs

@@ -0,0 +1,156 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  assertPortableGeneratedConfig,
+  buildOpsScripts,
+  createTask,
+  initProject,
+  REQUIRED_MEMORY_FILES,
+} from './bootstrap-utils.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const opsAgentBin = path.resolve(__dirname, '..', 'ops-agent.mjs');
+const tempDirs = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('bootstrap utilities', () => {
+  it('initializes a project-owned ops structure without overwriting existing files', () => {
+    const root = makeTempProject();
+    const first = initProject({ projectRoot: root, projectName: 'FixtureProject' });
+    const projectConfigPath = path.join(root, 'ops', 'project.ops.yaml');
+    const originalConfig = fs.readFileSync(projectConfigPath, 'utf8');
+
+    fs.writeFileSync(projectConfigPath, `${originalConfig}# custom note\n`);
+    const second = initProject({ projectRoot: root, projectName: 'FixtureProject' });
+
+    expect(first.changes.some((change) => change.status === 'created')).toBe(true);
+    expect(second.changes.some((change) => change.status === 'overwritten')).toBe(false);
+    expect(fs.readFileSync(projectConfigPath, 'utf8')).toContain('# custom note');
+    for (const fileName of REQUIRED_MEMORY_FILES) {
+      expect(fs.existsSync(path.join(root, 'ops', 'agent-pipeline', 'memory', fileName))).toBe(true);
+    }
+    expect(fs.existsSync(path.join(root, 'ops', 'agent-pipeline', 'playbooks', 'README.md'))).toBe(true);
+  });
+
+  it('creates portable project config and agents config', () => {
+    const root = makeTempProject();
+    initProject({ projectRoot: root, projectName: 'PortableProject' });
+
+    const projectConfigContent = fs.readFileSync(path.join(root, 'ops', 'project.ops.yaml'), 'utf8');
+    const agentsConfigContent = fs.readFileSync(path.join(root, 'ops', 'agent-pipeline', 'config', 'agents.json'), 'utf8');
+
+    expect(projectConfigContent).toContain('tasksDir: ops/agent-pipeline/tasks');
+    expect(projectConfigContent).toContain('memoryDir: ops/agent-pipeline/memory');
+    expect(projectConfigContent).toContain('# - apps/web');
+    expect(agentsConfigContent).toContain('${CODEX_CLI_COMMAND}');
+    expect(() => assertPortableGeneratedConfig({ projectConfigContent, agentsConfigContent })).not.toThrow();
+  });
+
+  it('can install dlx-based package scripts without adding package dependencies', () => {
+    const root = makeTempProject();
+    fs.writeFileSync(path.join(root, 'package.json'), `${JSON.stringify({
+      name: 'fixture-project',
+      private: true,
+      scripts: {
+        test: 'echo ok',
+      },
+      dependencies: {
+        leftpad: '1.0.0',
+      },
+    }, null, 2)}\n`);
+
+    initProject({
+      projectRoot: root,
+      projectName: 'ScriptProject',
+      installScripts: true,
+      frameworkPackage: '@besales/ops-framework',
+      frameworkVersion: '0.1.0',
+    });
+
+    const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    expect(packageJson.scripts.test).toBe('echo ok');
+    expect(packageJson.scripts.ops).toBe('corepack yarn dlx @besales/ops-framework@0.1.0');
+    expect(packageJson.scripts['agent:run-verify']).toBe('corepack yarn dlx @besales/ops-framework@0.1.0 run-verify');
+    expect(packageJson.dependencies.leftpad).toBe('1.0.0');
+    expect(packageJson.devDependencies?.['@besales/ops-framework']).toBeUndefined();
+  });
+
+  it('creates a minimal task artifact set', () => {
+    const root = makeTempProject();
+    initProject({ projectRoot: root, projectName: 'TaskProject' });
+
+    const result = createTask({
+      projectRoot: root,
+      taskId: 'TASK-000-bootstrap-smoke',
+      title: 'Bootstrap smoke',
+    });
+
+    expect(result.taskDir).toBe(path.join(root, 'ops', 'agent-pipeline', 'tasks', 'TASK-000-bootstrap-smoke'));
+    for (const fileName of ['brief.md', 'research.md', 'plan.md', 'status.md', 'orchestration-log.md']) {
+      expect(fs.existsSync(path.join(result.taskDir, fileName))).toBe(true);
+    }
+  });
+
+  it('respects a custom ops root from project config when creating tasks', () => {
+    const root = makeTempProject();
+    initProject({ projectRoot: root, projectName: 'CustomProject', opsRoot: '.ops' });
+
+    const result = createTask({
+      projectRoot: root,
+      taskId: 'TASK-001-custom-root',
+      title: 'Custom root',
+    });
+
+    expect(result.taskDir).toBe(path.join(root, '.ops', 'agent-pipeline', 'tasks', 'TASK-001-custom-root'));
+    expect(fs.existsSync(path.join(root, '.ops', 'agent-pipeline', 'tasks', 'TASK-001-custom-root', 'brief.md'))).toBe(true);
+    expect(fs.existsSync(path.join(root, 'ops', 'agent-pipeline', 'tasks', 'TASK-001-custom-root'))).toBe(false);
+  });
+
+  it('supports fixture lifecycle through the ops-agent bin', () => {
+    const root = makeTempProject();
+
+    expect(runOpsAgent(root, ['init', '--project-name', 'FixtureProject']).status).toBe(0);
+    expect(runOpsAgent(root, ['init', '--project-name', 'FixtureProject']).status).toBe(0);
+    expect(runOpsAgent(root, ['new-task', 'TASK-000-bootstrap-smoke', '--title', 'Bootstrap smoke']).status).toBe(0);
+    expect(runOpsAgent(root, ['manifest', 'TASK-000-bootstrap-smoke', '--json']).status).toBe(0);
+    expect(runOpsAgent(root, ['preflight', 'TASK-000-bootstrap-smoke', '--target', 'check']).status).toBe(0);
+    expect(runOpsAgent(root, ['build-check-context', 'TASK-000-bootstrap-smoke']).status).toBe(0);
+
+    const taskDir = path.join(root, 'ops', 'agent-pipeline', 'tasks', 'TASK-000-bootstrap-smoke');
+    expect(fs.existsSync(path.join(taskDir, 'check-context.json'))).toBe(true);
+    expect(fs.existsSync(path.join(taskDir, 'checker-context-pack.md'))).toBe(true);
+  });
+});
+
+describe('buildOpsScripts', () => {
+  it('generates the standard project script surface', () => {
+    const scripts = buildOpsScripts('@besales/ops-framework@0.1.0');
+
+    expect(scripts.ops).toBe('corepack yarn dlx @besales/ops-framework@0.1.0');
+    expect(scripts['agent:quality-gates']).toBe('corepack yarn dlx @besales/ops-framework@0.1.0 quality-gates');
+    expect(scripts['agent:test']).toBe('corepack yarn dlx @besales/ops-framework@0.1.0 test/self-test');
+  });
+});
+
+function makeTempProject() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-bootstrap-'));
+  tempDirs.push(root);
+  return root;
+}
+
+function runOpsAgent(cwd, args) {
+  return spawnSync(process.execPath, [opsAgentBin, ...args], {
+    cwd,
+    encoding: 'utf8',
+  });
+}