agentic-orchestrator 0.1.4 → 0.1.6

package/apps/control-plane/src/application/services/policy-loader-service.ts

@@ -0,0 +1,115 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import type { SchemaValidator } from '../../core/schemas.js';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+export interface LoadPolicyResult {
+  userPolicy: Record<string, unknown>;
+  mergedPolicy: Record<string, unknown>;
+}
+
+function resolveBundledDefaultsPath(startDir: string): string | null {
+  let current = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(current, 'agentic', 'orchestrator', 'defaults', 'policy.defaults.yaml');
+    if (fsSync.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+const BUNDLED_DEFAULTS_PATH = resolveBundledDefaultsPath(MODULE_DIR);
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function clone(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(clone);
+  }
+  if (isObject(value)) {
+    const out: Record<string, unknown> = {};
+    for (const key of Object.keys(value)) {
+      out[key] = clone(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * Deep-merges `user` over `defaults` according to ADP-3 semantics:
+ * - scalar in user → replaces default scalar
+ * - object in both → recursive merge
+ * - array in user → replaces default array wholesale
+ * - undefined user fields → inherit from defaults
+ */
+export function mergePolicy(defaults: unknown, user: unknown): unknown {
+  if (Array.isArray(user)) {
+    return user.map(clone);
+  }
+  if (isObject(defaults) && isObject(user)) {
+    const out: Record<string, unknown> = clone(defaults) as Record<string, unknown>;
+    for (const key of Object.keys(user)) {
+      const userVal = user[key];
+      if (userVal === undefined) {
+        continue;
+      }
+      out[key] = key in out ? mergePolicy(out[key], userVal) : clone(userVal);
+    }
+    return out;
+  }
+  return clone(user);
+}
+
+/**
+ * Loads and composes a canonical policy by:
+ * 1. Reading bundled `policy.defaults.yaml`
+ * 2. Reading the user's `policy.yaml` at `policyPath`
+ * 3. Deep-merging user overrides over defaults (ADP-3 semantics)
+ * 4. Validating the merged result against `policy.schema.json`
+ *
+ * Throws with a descriptive error if defaults cannot be located, if either
+ * file cannot be read, or if the merged result fails schema validation.
+ */
+export async function loadComposedPolicy(
+  _repoRoot: string,
+  policyPath: string,
+  schemaRegistry: SchemaValidator
+): Promise<LoadPolicyResult> {
+  if (!BUNDLED_DEFAULTS_PATH) {
+    throw new Error(
+      'policy_defaults_not_found: bundled defaults artifact could not be located; ' +
+        'ensure agentic/orchestrator/defaults/policy.defaults.yaml exists in the AOP installation'
+    );
+  }
+
+  const defaultsText = await fs.readFile(BUNDLED_DEFAULTS_PATH, 'utf8');
+  const defaults = YAML.parse(defaultsText) as Record<string, unknown>;
+
+  const userText = await fs.readFile(policyPath, 'utf8');
+  const userPolicy = (YAML.parse(userText) as Record<string, unknown> | null) ?? {};
+
+  const mergedPolicy = mergePolicy(defaults, userPolicy) as Record<string, unknown>;
+
+  const validation = await schemaRegistry.validate('policy.schema.json', mergedPolicy);
+  if (!validation.valid) {
+    const messages = validation.errors.map((e) => e.message ?? String(e)).join('; ');
+    throw new Error(
+      `invalid_policy_yaml: ${messages} ` +
+        `(merged from ${policyPath} over bundled defaults; check policy.yaml for invalid overrides)`
+    );
+  }
+
+  return { userPolicy, mergedPolicy };
+}

package/apps/control-plane/src/cli/aop.ts

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { runCli } from '../interfaces/cli/bootstrap.js';
 import type { RuntimeContext } from './types.js';
 
@@ -9,8 +12,39 @@ export async function main(
   return await runCli(argv, runtime);
 }
 
+function normalizePathCandidates(value: string): Set<string> {
+  const candidates = new Set<string>();
+  const resolved = path.resolve(value);
+  candidates.add(resolved);
+  try {
+    candidates.add(fs.realpathSync.native(resolved));
+  } catch {
+    // Keep resolved path fallback when realpath is unavailable.
+  }
+  return candidates;
+}
+
 export function isDirectExecution(importMetaUrl: string, argv1: string | undefined): boolean {
-  return importMetaUrl === `file://${argv1 ?? ''}`;
+  if (!argv1) {
+    return false;
+  }
+
+  let importMetaPath: string;
+  try {
+    importMetaPath = fileURLToPath(importMetaUrl);
+  } catch {
+    return false;
+  }
+
+  const modulePathCandidates = normalizePathCandidates(importMetaPath);
+  const argvPathCandidates = normalizePathCandidates(argv1);
+
+  for (const candidate of modulePathCandidates) {
+    if (argvPathCandidates.has(candidate)) {
+      return true;
+    }
+  }
+  return false;
 }
 
 export function runAsEntrypoint(

package/apps/control-plane/src/cli/cli-argument-parser.ts

@@ -120,6 +120,10 @@ export class CliArgumentParser {
         options.auto = true;
         continue;
       }
+      if (token === '--advanced-policy') {
+        options.advanced_policy = true;
+        continue;
+      }
       if (token === '--force') {
         options.force = true;
         continue;

package/apps/control-plane/src/cli/help-command-handler.ts

@@ -71,7 +71,8 @@ const COMMAND_HELP: Record<CliCommand, CommandHelp> = {
     description: 'Initialise agentic orchestrator configuration in the current directory.',
     flags: [
       { flag: '--auto', description: 'Run non-interactively with defaults' },
-      { flag: '--force', description: 'Overwrite existing configuration' }
+      { flag: '--force', description: 'Overwrite existing configuration' },
+      { flag: '--advanced-policy', description: 'Generate full explicit policy.yaml with all advanced controls (default: lean policy)' }
     ]
   },
   [CliCommand.Dashboard]: {

package/apps/control-plane/src/cli/init-command-handler.ts

@@ -7,14 +7,20 @@ import { stdin as input, stdout as output } from 'node:process';
 import { fileURLToPath } from 'node:url';
 import YAML from 'yaml';
 import { SchemaRegistry } from '../core/schemas.js';
+import { loadComposedPolicy } from '../application/services/policy-loader-service.js';
+import { AGENT_PROVIDER_SLOT, SCM_PROVIDER_SLOT, globalAdapterRegistry } from '../application/adapters/adapter-registry.js';
 
 const execFileAsync = promisify(execFile);
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const TEMPLATE_ROOT = path.resolve(MODULE_DIR, '../../../../agentic/orchestrator');
+const DEFAULT_AGENT_PROVIDER = 'custom';
+const DEFAULT_AGENT_MODEL = 'local-default';
+const DEFAULT_SCM_PROVIDER = 'github';
 
 export interface InitOptions {
   auto?: boolean;
   force?: boolean;
+  advanced_policy?: boolean;
 }
 
 type TestFramework = 'vitest' | 'jest' | 'pytest' | 'maven' | 'gradle';
@@ -34,6 +40,9 @@ interface WizardConfig {
   maxParallelGateRuns: number;
   dashboardPort: number;
   framework: TestFramework;
+  defaultProvider: string;
+  defaultModel: string;
+  scmProvider: string;
   notifications: {
     desktop: boolean;
     slack: boolean;
@@ -159,7 +168,34 @@ function escapeYamlString(value: string): string {
   return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 }
 
-function generatePolicyYaml(context: GitContext, wizard: WizardConfig): string {
+function generateLeanPolicyYaml(wizard: WizardConfig): string {
+  const notificationsEnabled = wizard.notifications.desktop || wizard.notifications.slack || wizard.notifications.webhook;
+  return `version: 1
+worktree:
+  base_branch: ${wizard.baseBranch}
+supervisor:
+  max_parallel_gate_runs: ${wizard.maxParallelGateRuns}
+dashboard:
+  enabled: true
+  port: ${wizard.dashboardPort}
+merge_policy:
+  require_user_approval: true
+notifications:
+  enabled: ${notificationsEnabled}
+  channels:
+    desktop:
+      enabled: ${wizard.notifications.desktop}
+    slack:
+      enabled: ${wizard.notifications.slack}
+      webhook: "${escapeYamlString(wizard.notifications.slackWebhook)}"
+      channel: "#aop-alerts"
+    webhook:
+      enabled: ${wizard.notifications.webhook}
+      url: "${escapeYamlString(wizard.notifications.webhookUrl)}"
+`;
+}
+
+function generateFullPolicyYaml(context: GitContext, wizard: WizardConfig): string {
   const notificationsEnabled = wizard.notifications.desktop || wizard.notifications.slack || wizard.notifications.webhook;
   return `version: 1
 commit_policy:
@@ -186,7 +222,6 @@ locks:
     multiplier: 2
     jitter_ms: 150
 protected_areas:
-  - agentic/orchestrator/schemas
   - agentic/orchestrator/policy.yaml
 required_modes:
   - fast
@@ -353,7 +388,7 @@ capabilities:
 `;
 }
 
-function generateAgentsYaml(): string {
+function generateAgentsYaml(wizard: WizardConfig): string {
   return `version: 1
 roles:
   planner:
@@ -364,17 +399,25 @@ roles:
     system_prompt_path: agentic/orchestrator/prompts/qa.system.md
 missing_prompt_behavior: ignore
 runtime:
-  default_provider: custom
-  default_model: local-default
+  default_provider: ${wizard.defaultProvider}
+  default_model: ${wizard.defaultModel}
   provider_config_env: AOP_PROVIDER_CONFIG_ENV
   role_provider_overrides: {}
 `;
 }
 
-function generateAdaptersYaml(): string {
-  return `notification-channel: desktop
-activity-detector: claude-jsonl
-scm-provider: github
+function generateAdaptersYaml(wizard: WizardConfig): string {
+  const notificationChannel = wizard.notifications.desktop
+    ? 'desktop'
+    : wizard.notifications.slack
+      ? 'slack'
+      : wizard.notifications.webhook
+        ? 'webhook'
+        : 'desktop';
+  const activityDetector = resolveActivityDetector(wizard.defaultProvider);
+  return `notification-channel: ${notificationChannel}
+activity-detector: ${activityDetector}
+scm-provider: ${wizard.scmProvider}
 `;
 }
 
@@ -410,18 +453,56 @@ function parseNotificationChannels(raw: string): { desktop: boolean; slack: bool
   };
 }
 
+function parseAdapterName(raw: string, supportedNames: ReadonlySet<string>, fallback: string): string {
+  const value = raw.trim();
+  if (supportedNames.has(value)) {
+    return value;
+  }
+  return fallback;
+}
+
+function resolveActivityDetector(defaultProvider: string): string {
+  if (defaultProvider === 'claude') {
+    return 'claude-jsonl';
+  }
+  if (defaultProvider === 'codex') {
+    return 'codex-rpc';
+  }
+  return 'process-heuristic';
+}
+
 async function askWithDefault(prompt: PromptSession, label: string, defaultValue: string): Promise<string> {
   const raw = (await prompt.question(`${label} [${defaultValue}]: `)).trim();
   return raw.length > 0 ? raw : defaultValue;
 }
 
 async function collectWizardConfig(
-  defaults: { branch: string; framework: TestFramework },
+  defaults: {
+    branch: string;
+    framework: TestFramework;
+    defaultProvider: string;
+    defaultModel: string;
+    defaultScmProvider: string;
+  },
   promptFactory: () => PromptSession
 ): Promise<WizardConfig> {
   const prompt = promptFactory();
   try {
+    const supportedProviders = new Set(globalAdapterRegistry.list(AGENT_PROVIDER_SLOT.name).map((adapter) => adapter.name));
+    const supportedScmProviders = new Set(globalAdapterRegistry.list(SCM_PROVIDER_SLOT.name).map((adapter) => adapter.name));
+
     const baseBranch = await askWithDefault(prompt, 'Worktree base branch', defaults.branch);
+    const defaultProviderRaw = await askWithDefault(
+      prompt,
+      `Default agent provider (${Array.from(supportedProviders).join('|')})`,
+      defaults.defaultProvider
+    );
+    const defaultModel = await askWithDefault(prompt, 'Default model', defaults.defaultModel);
+    const scmProviderRaw = await askWithDefault(
+      prompt,
+      `SCM provider (${Array.from(supportedScmProviders).join('|')})`,
+      defaults.defaultScmProvider
+    );
     const maxParallelGateRunsRaw = await askWithDefault(prompt, 'Max parallel gate runs', '3');
     const dashboardPortRaw = await askWithDefault(prompt, 'Dashboard port', '3000');
     const channelsRaw = await askWithDefault(
@@ -448,6 +529,9 @@ async function collectWizardConfig(
 
     return {
       baseBranch,
+      defaultProvider: parseAdapterName(defaultProviderRaw, supportedProviders, defaults.defaultProvider),
+      defaultModel,
+      scmProvider: parseAdapterName(scmProviderRaw, supportedScmProviders, defaults.defaultScmProvider),
       maxParallelGateRuns: parseInteger(maxParallelGateRunsRaw, 3, 1, 64),
       dashboardPort: parseInteger(dashboardPortRaw, 3000, 1, 65535),
       framework: parseFramework(frameworkRaw, defaults.framework),
@@ -465,7 +549,7 @@ async function collectWizardConfig(
 }
 
 async function loadTemplateFiles(
-  subdir: 'prompts' | 'schemas',
+  subdir: 'prompts',
   matcher: (filename: string) => boolean
 ): Promise<Array<{ rel: string; content: string }>> {
   const sourceDir = path.join(TEMPLATE_ROOT, subdir);
@@ -499,6 +583,9 @@ export class InitCommandHandler {
     const wizard = options.auto
       ? {
           baseBranch: gitContext.defaultBranch,
+          defaultProvider: DEFAULT_AGENT_PROVIDER,
+          defaultModel: DEFAULT_AGENT_MODEL,
+          scmProvider: DEFAULT_SCM_PROVIDER,
           maxParallelGateRuns: 3,
           dashboardPort: 3000,
           framework,
@@ -513,7 +600,10 @@ export class InitCommandHandler {
       : await collectWizardConfig(
           {
             branch: gitContext.defaultBranch,
-            framework
+            framework,
+            defaultProvider: DEFAULT_AGENT_PROVIDER,
+            defaultModel: DEFAULT_AGENT_MODEL,
+            defaultScmProvider: DEFAULT_SCM_PROVIDER
           },
           this.promptFactory
         );
@@ -521,19 +611,20 @@ export class InitCommandHandler {
     const orchestratorDir = path.join(this.repoRoot, 'agentic', 'orchestrator');
     await fs.mkdir(orchestratorDir, { recursive: true });
 
+    const policyContent = options.advanced_policy
+      ? generateFullPolicyYaml({ ...gitContext, defaultBranch: wizard.baseBranch }, wizard)
+      : generateLeanPolicyYaml(wizard);
+
     const configFiles: Array<{ rel: string; content: string }> = [
       {
         rel: 'agentic/orchestrator/policy.yaml',
-        content: generatePolicyYaml({ ...gitContext, defaultBranch: wizard.baseBranch }, wizard)
+        content: policyContent
       },
       { rel: 'agentic/orchestrator/gates.yaml', content: generateGatesYaml(wizard.framework) },
-      { rel: 'agentic/orchestrator/agents.yaml', content: generateAgentsYaml() },
-      { rel: 'agentic/orchestrator/adapters.yaml', content: generateAdaptersYaml() }
-    ];
-    const templateFiles = [
-      ...(await loadTemplateFiles('prompts', (filename) => filename.endsWith('.md'))),
-      ...(await loadTemplateFiles('schemas', (filename) => filename.endsWith('.json')))
+      { rel: 'agentic/orchestrator/agents.yaml', content: generateAgentsYaml(wizard) },
+      { rel: 'agentic/orchestrator/adapters.yaml', content: generateAdaptersYaml(wizard) }
     ];
+    const templateFiles = await loadTemplateFiles('prompts', (filename) => filename.endsWith('.md'));
     const writableFiles = [...configFiles, ...templateFiles];
 
     const created: string[] = [];
@@ -566,14 +657,25 @@ export class InitCommandHandler {
 
     const validationWarnings: string[] = [];
     const schemaRegistry = new SchemaRegistry(this.repoRoot);
-    const validationTargets: Array<{ schema: string; rel: string }> = [
-      { schema: 'policy.schema.json', rel: 'agentic/orchestrator/policy.yaml' },
+
+    // Validate policy.yaml via composition loader (merges user policy over bundled defaults
+    // then validates the merged result against the full schema).
+    const policyRel = 'agentic/orchestrator/policy.yaml';
+    if (!skipped.includes(policyRel)) {
+      try {
+        await loadComposedPolicy(this.repoRoot, path.join(this.repoRoot, policyRel), schemaRegistry);
+      } catch (err) {
+        validationWarnings.push(`Failed to validate ${policyRel}: ${String(err)}`);
+      }
+    }
+
+    const nonPolicyTargets: Array<{ schema: string; rel: string }> = [
       { schema: 'gates.schema.json', rel: 'agentic/orchestrator/gates.yaml' },
       { schema: 'agents.schema.json', rel: 'agentic/orchestrator/agents.yaml' },
       { schema: 'adapters.schema.json', rel: 'agentic/orchestrator/adapters.yaml' }
     ];
 
-    for (const { schema, rel } of validationTargets) {
+    for (const { schema, rel } of nonPolicyTargets) {
       if (skipped.includes(rel)) {
         continue;
       }
@@ -590,6 +692,17 @@ export class InitCommandHandler {
       }
     }
 
+    const policyMode = options.advanced_policy ? 'full (advanced)' : 'lean (common controls only)';
+    const nextSteps = [
+      `Generated policy.yaml in ${policyMode} mode`,
+      'Review generated files in agentic/orchestrator/{policy,gates,agents,adapters}.yaml',
+      'Verify prompts under agentic/orchestrator/prompts/',
+      'Run: aop run -fi <spec.md> to start orchestrating features'
+    ];
+    if (!options.advanced_policy) {
+      nextSteps.push('To generate a full explicit policy with all advanced controls, re-run: aop init --advanced-policy --force');
+    }
+
     return {
       ok: true,
       data: {
@@ -598,11 +711,7 @@ export class InitCommandHandler {
         updated,
         skipped,
         validation_warnings: validationWarnings,
-        next_steps: [
-          'Review generated files in agentic/orchestrator/{policy,gates,agents,adapters}.yaml',
-          'Verify prompts under agentic/orchestrator/prompts/ and schemas under agentic/orchestrator/schemas/',
-          'Run: aop run -fi <spec.md> to start orchestrating features'
-        ]
+        next_steps: nextSteps
       }
     };
   }

package/apps/control-plane/src/cli/retry-command-handler.ts

@@ -54,10 +54,7 @@ export class RetryCommandHandler {
 
     const force = options.force === true;
     let retryCountReset = false;
-    let retryExecuted: boolean;
     let forcedRetryExecuted = false;
-    let retryMode: string | null;
-    let retryOutcome: string | null;
 
     const current = await callCliTool(this.toolClient, this.runId, TOOLS.FEATURE_STATE_GET, {
       feature_id: featureId
@@ -118,10 +115,10 @@ export class RetryCommandHandler {
       profile: null,
       mode: inferredMode
     });
-    retryMode = inferredMode;
+    const retryExecuted = true;
+    const retryMode = inferredMode;
     const gateData = gate.data as { overall?: string };
-    retryOutcome = typeof gateData.overall === 'string' ? gateData.overall : null;
-    retryExecuted = true;
+    const retryOutcome = typeof gateData.overall === 'string' ? gateData.overall : null;
 
     return {
       ok: true,

package/apps/control-plane/src/cli/types.ts

@@ -33,6 +33,7 @@ export interface CliOptions {
   summary?: boolean;
   auto?: boolean;
   force?: boolean;
+  advanced_policy?: boolean;
   project?: string;
   all?: boolean;
   port?: number;

package/apps/control-plane/src/core/git.ts

@@ -27,7 +27,6 @@ export class NodeCommandRunner implements CommandRunner {
   async run(cmd: string, args: string[], options: RunCommandOptions = {}): Promise<CommandResult> {
     return await new Promise((resolve) => {
       let child;
-      let spawnError: Error | null = null;
 
       try {
         child = spawn(cmd, args, {
@@ -36,12 +35,11 @@ export class NodeCommandRunner implements CommandRunner {
           stdio: ['pipe', 'pipe', 'pipe']
         });
       } catch (err) {
-        spawnError = err as Error;
         return resolve({
           code: 127,
           signal: null,
           stdout: '',
-          stderr: spawnError.message,
+          stderr: (err as Error).message,
           timeout: false
         });
       }

package/apps/control-plane/src/core/kernel.ts

@@ -32,6 +32,7 @@ import { CollisionQueueService } from '../application/services/collision-queue-s
 import { FeatureDeletionService, type FeatureDeleteResult } from '../application/services/feature-deletion-service.js';
 import { CostTrackingService } from '../application/services/cost-tracking-service.js';
 import { PerformanceAnalyticsService, type FeatureOutcome } from '../application/services/performance-analytics-service.js';
+import { loadComposedPolicy } from '../application/services/policy-loader-service.js';
 import {
   ACTIVITY_DETECTOR_SLOT,
   NOTIFICATION_CHANNEL_SLOT,
@@ -344,12 +345,8 @@ export class AopKernel {
       throw new Error(`invalid_gates_yaml:${JSON.stringify(gates.validation.errors)}`);
     }
 
-    const policy = await loadAndValidateYaml(this.schemaRegistry, 'policy.schema.json', policyPath);
-    if (!policy.validation.valid) {
-      throw new Error(`invalid_policy_yaml:${JSON.stringify(policy.validation.errors)}`);
-    }
-
-    const parsedPolicy = policy.parsed as PolicyConfigSnapshot;
+    const { mergedPolicy } = await loadComposedPolicy(this.repoRoot, policyPath, this.schemaRegistry);
+    const parsedPolicy = mergedPolicy as PolicyConfigSnapshot;
     const implementation = readObjectField(parsedPolicy, 'implementation');
     const testing = readObjectField(parsedPolicy, 'testing');
 

package/apps/control-plane/src/core/schemas.ts

@@ -1,5 +1,7 @@
+import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import YAML from 'yaml';
 import Ajv2020Import from 'ajv/dist/2020.js';
 import type { AnySchema, ErrorObject, ValidateFunction } from 'ajv';
@@ -30,6 +32,26 @@ type AjvLike = {
 
 const RFC3339_DATE_TIME =
   /^(\d{4})-(\d{2})-(\d{2})T([0-2]\d):([0-5]\d):([0-5]\d)(\.\d{1,9})?(Z|([+-])([0-2]\d):([0-5]\d))$/;
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+function resolveBundledSchemaRoot(startDir: string): string | null {
+  let current = path.resolve(startDir);
+
+  while (true) {
+    const candidate = path.join(current, 'agentic', 'orchestrator', 'schemas', 'policy.schema.json');
+    if (fsSync.existsSync(candidate)) {
+      return path.dirname(candidate);
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+const BUNDLED_SCHEMA_ROOT = resolveBundledSchemaRoot(MODULE_DIR);
 
 function isStrictRfc3339DateTime(value: string): boolean {
   if (typeof value !== 'string') {
@@ -72,11 +94,13 @@ function isStrictRfc3339DateTime(value: string): boolean {
 
 export class SchemaRegistry implements SchemaValidator {
   readonly repoRoot: string;
+  readonly schemaRoot: string;
   private readonly ajv: AjvLike;
   private readonly validators: Map<SchemaId, ValidateFunction>;
 
   constructor(repoRoot: string) {
     this.repoRoot = repoRoot;
+    this.schemaRoot = this.resolveSchemaRoot();
     const Ajv2020Ctor = Ajv2020Import as unknown as new (options?: Record<string, unknown>) => AjvLike;
     this.ajv = new Ajv2020Ctor({ allErrors: true, strict: false });
     this.ajv.addFormat?.('date-time', {
@@ -86,8 +110,19 @@ export class SchemaRegistry implements SchemaValidator {
     this.validators = new Map();
   }
 
+  private resolveSchemaRoot(): string {
+    const repoSchemaRoot = path.join(this.repoRoot, 'agentic', 'orchestrator', 'schemas');
+    if (fsSync.existsSync(path.join(repoSchemaRoot, 'policy.schema.json'))) {
+      return repoSchemaRoot;
+    }
+    if (BUNDLED_SCHEMA_ROOT) {
+      return BUNDLED_SCHEMA_ROOT;
+    }
+    return repoSchemaRoot;
+  }
+
   schemaPath(name: SchemaId): string {
-    return path.join(this.repoRoot, 'agentic', 'orchestrator', 'schemas', name);
+    return path.join(this.schemaRoot, name);
   }
 
   async loadSchema(name: SchemaId): Promise<ValidateFunction> {

package/apps/control-plane/src/interfaces/cli/bootstrap.ts

@@ -157,7 +157,7 @@ export async function runCli(
 
     if (options.command === CliCommand.Init) {
       const handler = new InitCommandHandler(repoRoot);
-      const payload = await handler.execute({ auto: options.auto, force: options.force });
+      const payload = await handler.execute({ auto: options.auto, force: options.force, advanced_policy: options.advanced_policy });
       printPayload(payload);
       return 0;
     }