agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/src/application/services/feature-deletion-service.ts

@@ -146,6 +146,8 @@ export interface FeatureDeletionServicePort {
   withIndexLock<T>(operation: () => Promise<T>): Promise<T>;
   readIndex(): Promise<AnyRecord>;
   writeIndex(index: AnyRecord): Promise<void>;
+  readRunLease(): Promise<RuntimeSessionsSnapshot>;
+  writeRunLease(data: RuntimeSessionsSnapshot): Promise<void>;
   normalizeRuntimeSessions(value: unknown, at?: string): RuntimeSessionsSnapshot;
   isRunLeaseFresh(runtimeSessions: RuntimeSessionsSnapshot): boolean;
   locksRelease(resource: string, featureId: string): Promise<unknown>;
@@ -222,7 +224,7 @@ export class FeatureDeletionService {
     const stateHeldLocks = readHeldLocksFromState(stateFrontMatter);
 
     const indexSnapshot = await this.port.readIndex();
-    const runtimeSessions = this.port.normalizeRuntimeSessions(indexSnapshot.runtime_sessions);
+    const runtimeSessions = await this.port.readRunLease();
     if (this.hasFreshRunLease(runtimeSessions)) {
       throw {
         normalizedResponse: fail(ERROR_CODES.RUN_ALREADY_ACTIVE, 'Cannot delete feature while a run lease is active', {
@@ -293,7 +295,6 @@ export class FeatureDeletionService {
     const indexUpdate = await this.port.withIndexLock(async () => {
       const index = await this.port.readIndex();
       let changed = false;
-      let blockedQueueRemoved: number;
       let runtimeSessionRemoved = false;
 
       const active = asStringArray(index.active);
@@ -322,7 +323,7 @@ export class FeatureDeletionService {
         const record = asRecord(entry);
         return record.feature_id !== featureId;
       });
-      blockedQueueRemoved = blockedQueue.length - nextBlockedQueue.length;
+      const blockedQueueRemoved = blockedQueue.length - nextBlockedQueue.length;
       if (blockedQueueRemoved > 0) {
         index.blocked_queue = nextBlockedQueue;
         changed = true;
@@ -347,15 +348,15 @@ export class FeatureDeletionService {
       }
       index.lock_leases = lockLeases;
 
-      const nextRuntimeSessions = this.port.normalizeRuntimeSessions(index.runtime_sessions);
-      const featureSessions = normalizeFeatureSessions(nextRuntimeSessions);
+      const currentRunLease = await this.port.readRunLease();
+      const featureSessions = normalizeFeatureSessions(currentRunLease);
       if (Object.prototype.hasOwnProperty.call(featureSessions, featureId)) {
         delete featureSessions[featureId];
-        nextRuntimeSessions.feature_sessions = featureSessions as RuntimeSessionsSnapshot['feature_sessions'];
+        currentRunLease.feature_sessions = featureSessions as RuntimeSessionsSnapshot['feature_sessions'];
+        await this.port.writeRunLease(currentRunLease);
         runtimeSessionRemoved = true;
         changed = true;
       }
-      index.runtime_sessions = nextRuntimeSessions;
 
       if (changed) {
         const version = typeof index.version === 'number' ? index.version : 0;

package/apps/control-plane/src/application/services/gate-interpolation-service.ts

@@ -0,0 +1,15 @@
+export interface InterpolationContext {
+  base_branch: string;
+  feature_id: string;
+  worktree_path?: string;
+}
+
+export function interpolateGateCommands(commands: string[], context: InterpolationContext): string[] {
+  return commands.map((token) =>
+    token.replaceAll('{base_branch}', context.base_branch).replaceAll('{feature_id}', context.feature_id)
+  );
+}
+
+export function isIncrementalMode(mode: string): boolean {
+  return mode === 'fast';
+}

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

@@ -2,9 +2,11 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { pathExists } from '../../core/fs.js';
 import { runGateMode } from '../../core/gates.js';
+import type { GateProfile, GateStep } from '../../core/gates.js';
 import { ERROR_CODES } from '../../core/error-codes.js';
 import { fail } from '../../core/response.js';
 import { GATE_RESULT, STATUS } from '../../core/constants.js';
+import { interpolateGateCommands, isIncrementalMode } from './gate-interpolation-service.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyRecord = Record<string, any>;
@@ -118,12 +120,37 @@ export class GateService {
     const profile = this.gateProfileAndMode(effectiveProfileName, mode);
     const repoRoot = this.port.getRepoRoot();
 
+    const policySnapshot = this.port.getPolicySnapshot();
+    const worktreeConfig = policySnapshot['worktree'] as { base_branch?: string } | undefined;
+    const baseBranch = worktreeConfig?.base_branch ?? 'main';
+
+    const profileAsGate = profile as unknown as GateProfile;
+    const originalModeSteps = profileAsGate.modes?.[mode] ?? [];
+    const hasBaseBranchTemplate =
+      isIncrementalMode(mode) &&
+      originalModeSteps.some((step) => step.cmd.some((token) => token.includes('{base_branch}')));
+
+    let effectiveProfile: AnyRecord = profile;
+    if (isIncrementalMode(mode)) {
+      const interpolatedSteps: GateStep[] = originalModeSteps.map((step) => ({
+        ...step,
+        cmd: interpolateGateCommands(step.cmd, { base_branch: baseBranch, feature_id: featureId })
+      }));
+      effectiveProfile = {
+        ...profile,
+        modes: {
+          ...(profileAsGate.modes ?? {}),
+          [mode]: interpolatedSteps
+        }
+      };
+    }
+
     const runResult = (await runGateMode({
       featureId,
       mode,
       profileName: effectiveProfileName,
-      profile,
-      policy: this.port.getPolicySnapshot() as Parameters<typeof runGateMode>[0]['policy'],
+      profile: effectiveProfile,
+      policy: policySnapshot as Parameters<typeof runGateMode>[0]['policy'],
       worktreePath: this.port.worktreePath(featureId),
       logDirectory: this.port.logsPath(featureId),
       evidenceDirectory: this.port.evidencePath(featureId)
@@ -150,6 +177,15 @@ export class GateService {
       })
     );
 
+    if (hasBaseBranchTemplate) {
+      const skippedInfo = { skipped_reason: 'incremental_mode' as const, base_branch: baseBranch };
+      for (const evidenceFile of [runResult.evidence_path, runResult.latest_path]) {
+        const raw = await fs.readFile(evidenceFile, 'utf8');
+        const parsed = JSON.parse(raw) as Record<string, unknown>;
+        await fs.writeFile(evidenceFile, `${JSON.stringify({ ...parsed, ...skippedInfo }, null, 2)}\n`, 'utf8');
+      }
+    }
+
     if (runResult.overall === 'fail' && runResult.coverage_status === 'fail') {
       throw {
         normalizedResponse: fail(

package/apps/control-plane/src/application/services/instance-isolation-service.ts

@@ -0,0 +1,18 @@
+import { stableHash } from '../../core/fs.js';
+
+/**
+ * Computes a deterministic 12-character instance ID from a config file path.
+ * This ensures two orchestrator checkouts with different config paths get
+ * independent run-lease files and dashboard ports.
+ */
+export function computeInstanceId(configPath: string): string {
+  return stableHash(configPath).substring(0, 12);
+}
+
+/**
+ * Returns the canonical config path for the default single-instance case.
+ * Used when no explicit --config flag is provided.
+ */
+export function defaultConfigPath(repoRoot: string): string {
+  return `${repoRoot}/agentic/orchestrator/policy.yaml`;
+}

package/apps/control-plane/src/application/services/issue-tracker-service.ts

@@ -0,0 +1,469 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export interface Issue {
+  id: string;
+  title: string;
+  body: string;
+  status: string;
+  url: string;
+}
+
+export interface IssueTracker {
+  getIssue(issueId: string): Promise<Issue>;
+  updateIssueStatus(issueId: string, status: string): Promise<void>;
+  addComment(issueId: string, comment: string): Promise<void>;
+}
+
+export interface IssueTrackerConfig {
+  enabled?: boolean;
+  type: string;
+  config?: Record<string, string>;
+}
+
+// --- GitHub adapter (via gh CLI) ---
+
+export type GhRunner = (args: string[]) => Promise<{ stdout: string; exitCode: number }>;
+export type HttpRunner = (url: string, init: RequestInit) => Promise<{ status: number; ok: boolean; body: string }>;
+
+export function createGhRunner(fn?: GhRunner): GhRunner {
+  if (fn !== undefined) {
+    return fn;
+  }
+  return async (args: string[]) => {
+    try {
+      const { stdout } = await execFileAsync('gh', args, { timeout: 15_000 });
+      return { stdout, exitCode: 0 };
+    } catch (err: unknown) {
+      const e = err as Record<string, unknown>;
+      if (e['code'] === 'ENOENT' || e['code'] === 127) {
+        return { stdout: '', exitCode: 127 };
+      }
+      const exitCode = typeof e['code'] === 'number' ? e['code'] : 1;
+      return { stdout: '', exitCode };
+    }
+  };
+}
+
+export function createHttpRunner(fn?: HttpRunner): HttpRunner {
+  if (fn !== undefined) {
+    return fn;
+  }
+  return async (url: string, init: RequestInit) => {
+    try {
+      const response = await fetch(url, init);
+      return {
+        status: response.status,
+        ok: response.ok,
+        body: await response.text()
+      };
+    } catch {
+      return { status: 0, ok: false, body: '' };
+    }
+  };
+}
+
+function tryParseJson(value: string): Record<string, unknown> | null {
+  if (!value) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (parsed && typeof parsed === 'object') {
+      return parsed as Record<string, unknown>;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export class GitHubIssueTracker implements IssueTracker {
+  private readonly repo: string | undefined;
+  private readonly ghRunner: GhRunner;
+
+  constructor(config: Record<string, string> = {}, ghRunner?: GhRunner) {
+    this.repo = config['repo'];
+    this.ghRunner = ghRunner ?? createGhRunner();
+  }
+
+  async getIssue(issueId: string): Promise<Issue> {
+    const repoArgs = this.repo ? ['--repo', this.repo] : [];
+    const result = await this.ghRunner([
+      'issue', 'view', issueId,
+      ...repoArgs,
+      '--json', 'number,title,body,state,url'
+    ]);
+    if (result.exitCode !== 0 || !result.stdout) {
+      return { id: issueId, title: '', body: '', status: 'unknown', url: '' };
+    }
+    const parsed = JSON.parse(result.stdout) as {
+      number: number;
+      title: string;
+      body: string;
+      state: string;
+      url: string;
+    };
+    return {
+      id: String(parsed.number),
+      title: parsed.title,
+      body: parsed.body,
+      status: parsed.state.toLowerCase(),
+      url: parsed.url
+    };
+  }
+
+  async updateIssueStatus(issueId: string, status: string): Promise<void> {
+    const repoArgs = this.repo ? ['--repo', this.repo] : [];
+    const stateArg = status === 'closed' || status === 'merged' ? 'closed' : 'open';
+    await this.ghRunner(['issue', 'edit', issueId, ...repoArgs, '--state', stateArg]);
+  }
+
+  async addComment(issueId: string, comment: string): Promise<void> {
+    const repoArgs = this.repo ? ['--repo', this.repo] : [];
+    await this.ghRunner(['issue', 'comment', issueId, ...repoArgs, '--body', comment]);
+  }
+}
+
+interface LinearIssueNode {
+  id: string;
+  identifier: string;
+  title: string;
+  description: string;
+  url: string;
+  state: {
+    name: string;
+  } | null;
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value : '';
+}
+
+function lowerCaseStatus(value: string): string {
+  return value ? value.toLowerCase() : 'unknown';
+}
+
+function normalizeAopStatus(status: string): string {
+  return status.trim().toLowerCase().replace(/[^a-z0-9]+/g, '_');
+}
+
+function mapDefaultLinearStatus(status: string): string | null {
+  const normalized = normalizeAopStatus(status);
+  if (normalized === 'merged' || normalized === 'closed') {
+    return 'done';
+  }
+  if (normalized === 'blocked' || normalized === 'failed') {
+    return 'blocked';
+  }
+  if (normalized === 'planning') {
+    return 'backlog';
+  }
+  if (normalized === 'qa' || normalized === 'ready_to_merge') {
+    return 'in_review';
+  }
+  if (normalized === 'building') {
+    return 'in_progress';
+  }
+  return 'in_progress';
+}
+
+function mapDefaultJiraTransition(status: string): string {
+  const normalized = normalizeAopStatus(status);
+  if (normalized === 'merged' || normalized === 'closed') {
+    return 'done';
+  }
+  if (normalized === 'planning') {
+    return 'to do';
+  }
+  if (normalized === 'blocked' || normalized === 'failed') {
+    return 'blocked';
+  }
+  return 'in progress';
+}
+
+// --- Linear adapter (GraphQL HTTP) ---
+export class LinearIssueTracker implements IssueTracker {
+  private readonly token: string;
+  private readonly baseUrl: string;
+  private readonly config: Record<string, string>;
+  private readonly httpRunner: HttpRunner;
+
+  constructor(config: Record<string, string> = {}, httpRunner?: HttpRunner) {
+    this.token = config['token'] ?? '';
+    this.baseUrl = config['base_url'] ?? 'https://api.linear.app/graphql';
+    this.config = config;
+    this.httpRunner = createHttpRunner(httpRunner);
+  }
+
+  private async graphQl<TData>(query: string, variables: Record<string, unknown>): Promise<TData | null> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json'
+    };
+    if (this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`;
+    }
+    const result = await this.httpRunner(this.baseUrl, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ query, variables })
+    });
+    if (!result.ok || !result.body) {
+      return null;
+    }
+    const parsed = tryParseJson(result.body);
+    if (!parsed) {
+      return null;
+    }
+    if (Array.isArray(parsed['errors']) && parsed['errors'].length > 0) {
+      return null;
+    }
+    const data = parsed['data'];
+    if (data && typeof data === 'object') {
+      return data as TData;
+    }
+    return null;
+  }
+
+  private static parseIssueNode(value: unknown): LinearIssueNode | null {
+    if (!value || typeof value !== 'object') {
+      return null;
+    }
+    const raw = value as Record<string, unknown>;
+    const stateRaw = raw['state'];
+    return {
+      id: readString(raw['id']),
+      identifier: readString(raw['identifier']),
+      title: readString(raw['title']),
+      description: readString(raw['description']),
+      url: readString(raw['url']),
+      state:
+        stateRaw && typeof stateRaw === 'object'
+          ? {
+              name: readString((stateRaw as Record<string, unknown>)['name'])
+            }
+          : null
+    };
+  }
+
+  private async resolveIssueNode(issueId: string): Promise<LinearIssueNode | null> {
+    const byIdentifier = await this.graphQl<{ issueByIdentifier?: unknown }>(
+      'query AopIssueByIdentifier($identifier: String!) { issueByIdentifier(identifier: $identifier) { id identifier title description url state { name } } }',
+      { identifier: issueId }
+    );
+    const identifierIssue = LinearIssueTracker.parseIssueNode(byIdentifier?.issueByIdentifier);
+    if (identifierIssue) {
+      return identifierIssue;
+    }
+
+    const byId = await this.graphQl<{ issue?: unknown }>(
+      'query AopIssueById($id: String!) { issue(id: $id) { id identifier title description url state { name } } }',
+      { id: issueId }
+    );
+    return LinearIssueTracker.parseIssueNode(byId?.issue);
+  }
+
+  private resolveStateId(status: string): string | null {
+    const normalized = normalizeAopStatus(status);
+    const explicit = this.config[`state_id_${normalized}`];
+    if (explicit && explicit.length > 0) {
+      return explicit;
+    }
+    const defaultKey = mapDefaultLinearStatus(status);
+    if (!defaultKey) {
+      return null;
+    }
+    const defaultMapped = this.config[`state_id_${defaultKey}`];
+    return defaultMapped && defaultMapped.length > 0 ? defaultMapped : null;
+  }
+
+  async getIssue(issueId: string): Promise<Issue> {
+    const issue = await this.resolveIssueNode(issueId).catch(() => null);
+    if (!issue) {
+      return { id: issueId, title: '', body: '', status: 'unknown', url: '' };
+    }
+    return {
+      id: issue.identifier || issue.id || issueId,
+      title: issue.title,
+      body: issue.description,
+      status: lowerCaseStatus(issue.state?.name ?? ''),
+      url: issue.url
+    };
+  }
+
+  async updateIssueStatus(issueId: string, status: string): Promise<void> {
+    const issue = await this.resolveIssueNode(issueId).catch(() => null);
+    if (!issue?.id) {
+      return;
+    }
+    const stateId = this.resolveStateId(status);
+    if (!stateId) {
+      return;
+    }
+    await this.graphQl(
+      'mutation AopIssueUpdate($id: String!, $stateId: String!) { issueUpdate(id: $id, input: { stateId: $stateId }) { success } }',
+      { id: issue.id, stateId }
+    );
+  }
+
+  async addComment(issueId: string, comment: string): Promise<void> {
+    const issue = await this.resolveIssueNode(issueId).catch(() => null);
+    if (!issue?.id) {
+      return;
+    }
+    await this.graphQl(
+      'mutation AopCommentCreate($issueId: String!, $body: String!) { commentCreate(input: { issueId: $issueId, body: $body }) { success } }',
+      { issueId: issue.id, body: comment }
+    );
+  }
+}
+
+function toJiraDescription(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (!value || typeof value !== 'object') {
+    return '';
+  }
+  return JSON.stringify(value);
+}
+
+// --- Jira adapter (REST HTTP) ---
+export class JiraIssueTracker implements IssueTracker {
+  private readonly baseUrl: string;
+  private readonly token: string;
+  private readonly email: string;
+  private readonly config: Record<string, string>;
+  private readonly httpRunner: HttpRunner;
+
+  constructor(config: Record<string, string> = {}, httpRunner?: HttpRunner) {
+    this.baseUrl = (config['base_url'] ?? config['url'] ?? '').replace(/\/+$/, '');
+    this.token = config['token'] ?? '';
+    this.email = config['email'] ?? config['user'] ?? '';
+    this.config = config;
+    this.httpRunner = createHttpRunner(httpRunner);
+  }
+
+  private authHeader(): string | null {
+    if (this.email && this.token) {
+      return `Basic ${Buffer.from(`${this.email}:${this.token}`, 'utf8').toString('base64')}`;
+    }
+    if (this.token) {
+      return `Bearer ${this.token}`;
+    }
+    return null;
+  }
+
+  private async requestJson<T>(
+    endpoint: string,
+    method: 'GET' | 'POST',
+    body?: Record<string, unknown>
+  ): Promise<T | null> {
+    if (!this.baseUrl) {
+      return null;
+    }
+    const headers: Record<string, string> = {
+      Accept: 'application/json'
+    };
+    const authHeader = this.authHeader();
+    if (authHeader) {
+      headers['Authorization'] = authHeader;
+    }
+    if (body !== undefined) {
+      headers['Content-Type'] = 'application/json';
+    }
+    const result = await this.httpRunner(`${this.baseUrl}${endpoint}`, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    if (!result.ok || !result.body) {
+      return null;
+    }
+    const parsed = tryParseJson(result.body);
+    return parsed as T | null;
+  }
+
+  private resolveTransitionName(status: string): string {
+    const normalized = normalizeAopStatus(status);
+    const explicit = this.config[`transition_${normalized}`];
+    if (explicit && explicit.length > 0) {
+      return explicit.toLowerCase();
+    }
+    return mapDefaultJiraTransition(status);
+  }
+
+  async getIssue(issueId: string): Promise<Issue> {
+    const payload = await this.requestJson<{
+      key?: string;
+      fields?: {
+        summary?: unknown;
+        description?: unknown;
+        status?: {
+          name?: unknown;
+        };
+      };
+    }>(`/rest/api/2/issue/${encodeURIComponent(issueId)}?fields=summary,description,status`, 'GET');
+    if (!payload) {
+      return { id: issueId, title: '', body: '', status: 'unknown', url: '' };
+    }
+    const fields = payload.fields ?? {};
+    return {
+      id: readString(payload.key) || issueId,
+      title: readString(fields.summary),
+      body: toJiraDescription(fields.description),
+      status: lowerCaseStatus(readString(fields.status?.name)),
+      url: this.baseUrl ? `${this.baseUrl}/browse/${issueId}` : ''
+    };
+  }
+
+  async updateIssueStatus(issueId: string, status: string): Promise<void> {
+    const transitionsPayload = await this.requestJson<{ transitions?: Array<{ id?: string; name?: string }> }>(
+      `/rest/api/2/issue/${encodeURIComponent(issueId)}/transitions`,
+      'GET'
+    );
+    const transitions = transitionsPayload?.transitions ?? [];
+    const targetName = this.resolveTransitionName(status);
+    const transition = transitions.find(
+      (item) => typeof item.name === 'string' && item.name.toLowerCase() === targetName
+    );
+    if (!transition?.id) {
+      return;
+    }
+    await this.requestJson(
+      `/rest/api/2/issue/${encodeURIComponent(issueId)}/transitions`,
+      'POST',
+      { transition: { id: transition.id } }
+    );
+  }
+
+  async addComment(issueId: string, comment: string): Promise<void> {
+    await this.requestJson(
+      `/rest/api/2/issue/${encodeURIComponent(issueId)}/comment`,
+      'POST',
+      { body: comment }
+    );
+  }
+}
+
+// --- Factory ---
+export function createIssueTracker(
+  config: IssueTrackerConfig | undefined,
+  ghRunner?: GhRunner,
+  httpRunner?: HttpRunner
+): IssueTracker | undefined {
+  if (!config) {return undefined;}
+  if (config.enabled === false) {return undefined;}
+  switch (config.type) {
+    case 'github':
+      return new GitHubIssueTracker(config.config ?? {}, ghRunner);
+    case 'linear':
+      return new LinearIssueTracker(config.config ?? {}, httpRunner);
+    case 'jira':
+      return new JiraIssueTracker(config.config ?? {}, httpRunner);
+    default:
+      return undefined;
+  }
+}