agentic-orchestrator 0.1.6 → 0.1.8

package/packages/web-dashboard/src/lib/multi-project-config.ts

@@ -3,7 +3,13 @@ import os from 'node:os';
 import path from 'node:path';
 import YAML from 'yaml';
 
-const MULTI_PROJECT_CONFIG_PATH = ['agentic', 'orchestrator', 'multi-project.yaml'] as const;
+const MULTI_PROJECT_CONFIG_PATH = [
+  'config',
+  'agentic',
+  'orchestrator',
+  'multi-project.yaml',
+] as const;
+const LEGACY_MULTI_PROJECT_CONFIG_PATH = ['agentic', 'orchestrator', 'multi-project.yaml'] as const;
 
 export interface MultiProjectDashboardConfig {
   defaults?: {
@@ -78,39 +84,54 @@ function parseConfig(raw: string, repoRoot: string): MultiProjectDashboardConfig
         path: absoluteProjectPath,
         policy: policyPath,
         gates: gatesPath,
-        dashboard_port: typeof project.dashboard_port === 'number' ? project.dashboard_port : undefined
+        dashboard_port:
+          typeof project.dashboard_port === 'number' ? project.dashboard_port : undefined,
       };
     });
 
   return {
     defaults: candidate.defaults,
-    projects
+    projects,
   };
 }
 
-export async function readMultiProjectConfig(repoRoot: string): Promise<MultiProjectDashboardConfig | null> {
+export async function readMultiProjectConfig(
+  repoRoot: string,
+): Promise<MultiProjectDashboardConfig | null> {
   const configPath = path.join(repoRoot, ...MULTI_PROJECT_CONFIG_PATH);
+  const legacyConfigPath = path.join(repoRoot, ...LEGACY_MULTI_PROJECT_CONFIG_PATH);
   try {
     const raw = await readFile(configPath, 'utf8');
     return parseConfig(raw, repoRoot);
   } catch {
-    return null;
+    try {
+      const raw = await readFile(legacyConfigPath, 'utf8');
+      return parseConfig(raw, repoRoot);
+    } catch {
+      return null;
+    }
   }
 }
 
 export async function multiProjectConfigExists(repoRoot: string): Promise<boolean> {
   const configPath = path.join(repoRoot, ...MULTI_PROJECT_CONFIG_PATH);
+  const legacyConfigPath = path.join(repoRoot, ...LEGACY_MULTI_PROJECT_CONFIG_PATH);
   try {
     await access(configPath);
     return true;
   } catch {
-    return false;
+    try {
+      await access(legacyConfigPath);
+      return true;
+    } catch {
+      return false;
+    }
   }
 }
 
 export function getProjectByName(
   config: MultiProjectDashboardConfig,
-  name: string
+  name: string,
 ): MultiProjectDashboardConfig['projects'][number] | null {
   return config.projects.find((project) => project.name === name) ?? null;
 }

package/packages/web-dashboard/src/lib/orchestrator-tools.ts

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { getAopRoot } from './aop-client.js';
 
 const STATUS = {
-  BLOCKED: 'blocked'
+  BLOCKED: 'blocked',
 } as const;
 
 const TOOLS = {
@@ -12,7 +12,7 @@ const TOOLS = {
   FEATURE_STATE_GET: 'feature.state_get',
   FEATURE_STATE_PATCH: 'feature.state_patch',
   FEATURE_LOG_APPEND: 'feature.log_append',
-  FEATURE_SEND_MESSAGE: 'feature.send_message'
+  FEATURE_SEND_MESSAGE: 'feature.send_message',
 } as const;
 
 interface ToolResponse<TData = Record<string, unknown>> {
@@ -33,7 +33,11 @@ interface ToolClientIdentity {
 }
 
 interface ToolClient {
-  call(toolName: string, args: Record<string, unknown>, identity: ToolClientIdentity): Promise<ToolResponse>;
+  call(
+    toolName: string,
+    args: Record<string, unknown>,
+    identity: ToolClientIdentity,
+  ): Promise<ToolResponse>;
 }
 
 interface ToolingRuntime {
@@ -49,11 +53,15 @@ interface KernelLike {
 interface RuntimeBridge {
   AopKernel: new (repoRoot: string) => KernelLike;
   NullWorkerProvider: new (selection: unknown) => unknown;
-  resolveProviderSelection: (input: { cli: Record<string, string | undefined>; env: NodeJS.ProcessEnv; agentsConfig?: unknown }) => unknown;
+  resolveProviderSelection: (input: {
+    cli: Record<string, string | undefined>;
+    env: NodeJS.ProcessEnv;
+    agentsConfig?: unknown;
+  }) => unknown;
   createToolingRuntime: (
     repoRoot: string,
     kernel: KernelLike,
-    options: { generateToolsMarkdown: boolean }
+    options: { generateToolsMarkdown: boolean },
   ) => Promise<ToolingRuntime>;
   createOperationId?: (toolName: string, featureId?: string) => string;
 }
@@ -72,7 +80,7 @@ function makeClaims(): ToolClientIdentity {
     run_id: `run:dashboard:${stamp}`,
     actor_type: 'orchestrator',
     actor_id: 'dashboard',
-    session_id: `dashboard:${randomUUID()}`
+    session_id: `dashboard:${randomUUID()}`,
   };
 }
 
@@ -93,16 +101,19 @@ function normalizeError(error: unknown, fallbackCode = 'internal_error'): ToolRe
       error: {
         code: typeof maybe.code === 'string' ? maybe.code : fallbackCode,
         message: typeof maybe.message === 'string' ? maybe.message : 'Operation failed',
-        details: maybe.details && typeof maybe.details === 'object' ? (maybe.details as Record<string, unknown>) : undefined
-      }
+        details:
+          maybe.details && typeof maybe.details === 'object'
+            ? (maybe.details as Record<string, unknown>)
+            : undefined,
+      },
     };
   }
   return {
     ok: false,
     error: {
       code: fallbackCode,
-      message: typeof error === 'string' ? error : 'Operation failed'
-    }
+      message: typeof error === 'string' ? error : 'Operation failed',
+    },
   };
 }
 
@@ -140,11 +151,12 @@ async function getRuntime(repoRoot: string): Promise<DashboardToolRuntime> {
   await kernel.ensureLoaded();
 
   try {
-    const agentsConfig = typeof kernel.getAgentsConfig === 'function' ? kernel.getAgentsConfig() : undefined;
+    const agentsConfig =
+      typeof kernel.getAgentsConfig === 'function' ? kernel.getAgentsConfig() : undefined;
     const selection = bridge.resolveProviderSelection({
       cli: {},
       env: process.env,
-      agentsConfig
+      agentsConfig,
     });
     kernel.setProvider(new bridge.NullWorkerProvider(selection));
   } catch {
@@ -153,15 +165,17 @@ async function getRuntime(repoRoot: string): Promise<DashboardToolRuntime> {
         provider: 'custom',
         model: 'dashboard-default',
         provider_config_env: null,
-        provider_config_ref: null
-      })
+        provider_config_ref: null,
+      }),
     );
   }
 
-  const tooling = await bridge.createToolingRuntime(repoRoot, kernel, { generateToolsMarkdown: false });
+  const tooling = await bridge.createToolingRuntime(repoRoot, kernel, {
+    generateToolsMarkdown: false,
+  });
   const runtime = {
     client: tooling.inProcessClient,
-    createOperationId: bridge.createOperationId ?? defaultCreateOperationId
+    createOperationId: bridge.createOperationId ?? defaultCreateOperationId,
   };
   runtimeCacheByRoot.set(repoRoot, runtime);
   return runtime;
@@ -170,7 +184,7 @@ async function getRuntime(repoRoot: string): Promise<DashboardToolRuntime> {
 export async function callOrchestratorTool<TData = Record<string, unknown>>(
   toolName: string,
   args: Record<string, unknown>,
-  options: { mutating?: boolean; featureId?: string; repoRoot?: string } = {}
+  options: { mutating?: boolean; featureId?: string; repoRoot?: string } = {},
 ): Promise<ToolResponse<TData>> {
   try {
     const repoRoot = options.repoRoot ?? getAopRoot();
@@ -193,7 +207,7 @@ export async function approveFeatureReview(
   approvalToken: string,
   mergeStrategy = 'merge_commit',
   commitMessage?: string,
-  repoRoot?: string
+  repoRoot?: string,
 ): Promise<ToolResponse> {
   return await callOrchestratorTool(
     TOOLS.FEATURE_READY_TO_MERGE,
@@ -201,17 +215,21 @@ export async function approveFeatureReview(
       feature_id: featureId,
       commit_message: commitMessage ?? `feat(${featureId}): merge via dashboard approval`,
       merge_strategy: mergeStrategy,
-      user_approval_token: approvalToken
+      user_approval_token: approvalToken,
     },
-    { mutating: true, featureId, repoRoot }
+    { mutating: true, featureId, repoRoot },
   );
 }
 
-export async function denyFeatureReview(featureId: string, reason: string, repoRoot?: string): Promise<ToolResponse> {
+export async function denyFeatureReview(
+  featureId: string,
+  reason: string,
+  repoRoot?: string,
+): Promise<ToolResponse> {
   const state = await callOrchestratorTool<{ front_matter: { version: number } }>(
     TOOLS.FEATURE_STATE_GET,
     { feature_id: featureId },
-    { repoRoot }
+    { repoRoot },
   );
   if (!state.ok || !state.data) {
     return state;
@@ -226,11 +244,11 @@ export async function denyFeatureReview(featureId: string, reason: string, repoR
       patch: {
         front_matter: {
           status: STATUS.BLOCKED,
-          status_reason: `Dashboard review denied: ${reason}`
-        }
-      }
+          status_reason: `Dashboard review denied: ${reason}`,
+        },
+      },
     },
-    { mutating: true, featureId, repoRoot }
+    { mutating: true, featureId, repoRoot },
   );
   if (!patchResult.ok) {
     return patchResult;
@@ -244,24 +262,29 @@ export async function denyFeatureReview(featureId: string, reason: string, repoR
         type: 'dashboard_review',
         decision: 'deny',
         reason,
-        reviewed_at: new Date().toISOString()
-      })
+        reviewed_at: new Date().toISOString(),
+      }),
     },
-    { mutating: true, featureId, repoRoot }
+    { mutating: true, featureId, repoRoot },
   );
 
   return patchResult;
 }
 
-export async function requestFeatureChanges(featureId: string, message: string, repoRoot?: string): Promise<ToolResponse> {
-  const normalized = message.trim().length > 0 ? message.trim() : 'Please address reviewer feedback and re-run QA.';
+export async function requestFeatureChanges(
+  featureId: string,
+  message: string,
+  repoRoot?: string,
+): Promise<ToolResponse> {
+  const normalized =
+    message.trim().length > 0 ? message.trim() : 'Please address reviewer feedback and re-run QA.';
   const send = await callOrchestratorTool(
     TOOLS.FEATURE_SEND_MESSAGE,
     {
       feature_id: featureId,
-      message: `Reviewer requested changes:\n${normalized}`
+      message: `Reviewer requested changes:\n${normalized}`,
     },
-    { mutating: true, featureId, repoRoot }
+    { mutating: true, featureId, repoRoot },
   );
   if (send.ok) {
     return send;
@@ -276,9 +299,9 @@ export async function requestFeatureChanges(featureId: string, message: string,
         decision: 'request_changes',
         message: normalized,
         reviewed_at: new Date().toISOString(),
-        dispatch_fallback: true
-      })
+        dispatch_fallback: true,
+      }),
     },
-    { mutating: true, featureId, repoRoot }
+    { mutating: true, featureId, repoRoot },
   );
 }

package/packages/web-dashboard/tsconfig.json

@@ -3,11 +3,7 @@
   "compilerOptions": {
     "target": "ES2017",
     "baseUrl": ".",
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
+    "lib": ["dom", "dom.iterable", "esnext"],
     "jsx": "preserve",
     "module": "esnext",
     "moduleResolution": "bundler",
@@ -16,9 +12,7 @@
     "strict": true,
     "skipLibCheck": true,
     "paths": {
-      "@/*": [
-        "./src/*"
-      ]
+      "@/*": ["./src/*"]
     },
     "incremental": true,
     "isolatedModules": true,
@@ -35,7 +29,5 @@
     ".next/types/**/*.ts",
     "next.config.js"
   ],
-  "exclude": [
-    "node_modules"
-  ]
+  "exclude": ["node_modules"]
 }

package/scripts/nx-safe.mjs

@@ -1,29 +1,29 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
-import process from "node:process";
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import process from 'node:process';
 
 const require = createRequire(import.meta.url);
-const nxCliPath = require.resolve("nx/bin/nx.js");
+const nxCliPath = require.resolve('nx/bin/nx.js');
 
 const env = {
   ...process.env,
-  NX_DAEMON: process.env.NX_DAEMON ?? "false",
-  NX_ISOLATE_PLUGINS: process.env.NX_ISOLATE_PLUGINS ?? "false"
+  NX_DAEMON: process.env.NX_DAEMON ?? 'false',
+  NX_ISOLATE_PLUGINS: process.env.NX_ISOLATE_PLUGINS ?? 'false',
 };
 
 const child = spawn(process.execPath, [nxCliPath, ...process.argv.slice(2)], {
-  stdio: "inherit",
-  env
+  stdio: 'inherit',
+  env,
 });
 
-child.on("error", (error) => {
+child.on('error', (error) => {
   const message = error instanceof Error ? error.message : String(error);
   console.error(`[nx-safe] Failed to execute Nx CLI: ${message}`);
   process.exit(1);
 });
 
-child.on("exit", (code, signal) => {
+child.on('exit', (code, signal) => {
   if (signal) {
     process.kill(process.pid, signal);
     return;

package/spec-files/completed/agentic_orchestrator_cli_delete_command_spec.md

@@ -71,6 +71,7 @@ aop delete --feature-id <feature_id> [options]
 ### 3.4 Response Contract
 
 On success:
+
 - `ok: true`
 - `data.command: "delete"`
 - `data.feature_id`
@@ -86,6 +87,7 @@ On success:
   - `runtime_session_assignment_removed`
 
 On failure:
+
 - standard normalized error envelope already used by CLI.
 
 ---
@@ -153,16 +155,19 @@ Add new tool: `feature.delete`
 ### 6.2 Schemas
 
 Add:
+
 - `agentic/orchestrator/tools/schemas/input/feature.delete.input.schema.json`
 - `agentic/orchestrator/tools/schemas/output/feature.delete.output.schema.json`
 
 Input MUST include:
+
 - `operation_id`
 - `feature_id`
 - execution mode fields (`dry_run`/`confirm` or equivalent)
 - cleanup toggles (`remove_worktree`, `remove_branch`)
 
 Output MUST include:
+
 - target `feature_id`
 - mode (`dry_run`)
 - deterministic summary fields listed in Section 3.4.