agentic-orchestrator 0.1.3 → 0.1.4

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;
+  }
+}

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

@@ -4,6 +4,7 @@ import { runGit } from '../../core/git.js';
 import { ERROR_CODES } from '../../core/error-codes.js';
 import { fail } from '../../core/response.js';
 import { GATE_RESULT, STATUS } from '../../core/constants.js';
+import { resolveDepBlocked } from './dependency-scheduler-service.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyRecord = Record<string, any>;
@@ -51,12 +52,58 @@ export class MergeService {
     this.port = port;
   }
 
+  private async cleanupMergedFeatureArtifacts(featureId: string): Promise<void> {
+    const repoRoot = this.port.getRepoRoot();
+    const worktreePath = this.port.worktreePath(featureId);
+
+    const removeWorktreeResult = await runGit(repoRoot, ['worktree', 'remove', '--force', worktreePath]);
+    if (removeWorktreeResult.code !== 0) {
+      // Best-effort cleanup; merged state must remain intact even if git cleanup fails.
+      console.warn(
+        `[aop] auto-cleanup worktree removal failed for ${featureId}: ${removeWorktreeResult.stderr.trim() || `exit ${removeWorktreeResult.code}`}`
+      );
+    }
+
+    const removeBranchResult = await runGit(repoRoot, ['branch', '-D', featureId]);
+    if (removeBranchResult.code !== 0) {
+      // Best-effort cleanup; branch may already be removed.
+      console.warn(
+        `[aop] auto-cleanup branch removal failed for ${featureId}: ${removeBranchResult.stderr.trim() || `exit ${removeBranchResult.code}`}`
+      );
+    }
+
+    await fs.rm(this.port.featurePath(featureId), { recursive: true, force: true });
+  }
+
+  private scheduleFeatureCleanup(featureId: string, gracePeriodSeconds: number): void {
+    const delayMs = Math.max(0, Math.floor(gracePeriodSeconds * 1000));
+    const timeout = setTimeout(() => {
+      void this.cleanupMergedFeatureArtifacts(featureId).catch((error) => {
+        console.warn(
+          `[aop] auto-cleanup failed for ${featureId}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }, delayMs);
+    if (typeof timeout.unref === 'function') {
+      timeout.unref();
+    }
+  }
+
   async featureReadyToMerge(
     featureId: string,
     commitMessage: string,
     mergeStrategy: string,
     userApprovalToken: string | null
-  ): Promise<{ data: { feature_id: string; merge_sha: string; merge_strategy: string; status: string } }> {
+  ): Promise<{
+    data: {
+      feature_id: string;
+      merge_sha: string;
+      merge_strategy: string;
+      status: string;
+      retained_for_cleanup?: boolean;
+      cleanup_grace_period_seconds?: number;
+    };
+  }> {
     const policy = this.port.getPolicySnapshot();
     const state = await this.port.readState(featureId);
 
@@ -227,19 +274,36 @@ export class MergeService {
       runtimeSessions.feature_sessions = featureSessions;
       index.runtime_sessions = runtimeSessions;
 
+      // N4: Promote features that were blocked waiting for this feature to merge
+      resolveDepBlocked(index, featureId);
+
       index.version += 1;
       index.updated_at = nowIso();
       await this.port.writeIndex(index);
     });
 
-    await fs.rm(this.port.featurePath(featureId), { recursive: true, force: true });
+    const cleanupPolicy = asRecord(policy.cleanup);
+    const autoAfterMerge = cleanupPolicy.auto_after_merge === true;
+    const gracePeriodSeconds =
+      typeof cleanupPolicy.grace_period_seconds === 'number' && Number.isFinite(cleanupPolicy.grace_period_seconds)
+        ? cleanupPolicy.grace_period_seconds
+        : 3600;
+    const shouldCleanupNow = autoAfterMerge && gracePeriodSeconds <= 0;
+
+    if (shouldCleanupNow) {
+      await this.cleanupMergedFeatureArtifacts(featureId);
+    } else if (autoAfterMerge) {
+      this.scheduleFeatureCleanup(featureId, gracePeriodSeconds);
+    }
 
     return {
       data: {
         feature_id: featureId,
         merge_sha: mergeSha,
         merge_strategy: mergeStrategy,
-        status: STATUS.MERGED
+        status: STATUS.MERGED,
+        retained_for_cleanup: !shouldCleanupNow,
+        cleanup_grace_period_seconds: gracePeriodSeconds
       }
     };
   }