@cleocode/runtime 2026.5.130 → 2026.5.131

package/dist/gateway/index.js

@@ -0,0 +1,1220 @@
+import {
+  defineSubsystem
+} from "../chunk-WSQQ5DQL.js";
+import {
+  MCP_TOOL_PREFIX,
+  OPERATIONS,
+  buildToolsList,
+  callTool,
+  deriveGatewayMatrix,
+  exposedOperations,
+  getActiveDomains,
+  getByDomain,
+  getByGateway,
+  getByTier,
+  getCounts,
+  getGatewayDomains,
+  operationToMcpTool,
+  operationToToolName,
+  resolve,
+  startMcpServer,
+  toolNameToOperationKey,
+  validateRequiredParams
+} from "../chunk-R4XBXUQN.js";
+import {
+  LineBuffer,
+  buildErrorFrame,
+  decodeLine,
+  encodeFrame,
+  routeFrame,
+  startRpcServer
+} from "../chunk-5ZXRYEQ5.js";
+import {
+  SSE_HEADERS,
+  createSseStream,
+  encodeSseFrame,
+  encodeStreamEvent,
+  parseHttpRoute,
+  routeUnary,
+  startHttpServer,
+  statusForResponse
+} from "../chunk-YZBIPGMH.js";
+
+// src/gateway/dispatcher.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { getLogger, getProjectRoot } from "@cleocode/core";
+
+// src/gateway/meta.ts
+import { randomUUID } from "crypto";
+function createDispatchMeta(gateway, domain, operation, startTime, source = "cli", requestId, sessionId, originSessionId, executionSessionId) {
+  return {
+    gateway,
+    domain,
+    operation,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    duration_ms: Date.now() - startTime,
+    source,
+    requestId: requestId ?? randomUUID(),
+    ...sessionId != null && { sessionId },
+    ...originSessionId != null && { originSessionId },
+    ...executionSessionId != null && { executionSessionId }
+  };
+}
+
+// src/gateway/pipeline.ts
+function compose(middlewares) {
+  if (middlewares.length === 0) {
+    return async (_req, next) => next();
+  }
+  return async (request, next) => {
+    let index = -1;
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times in middleware");
+      }
+      index = i;
+      let fn = middlewares[i];
+      if (i === middlewares.length) {
+        fn = async (_req, nxt) => nxt();
+      }
+      if (!fn) {
+        return next();
+      }
+      return fn(request, async () => {
+        if (i === middlewares.length) {
+          return next();
+        }
+        return dispatch(i + 1);
+      });
+    }
+    return dispatch(0);
+  };
+}
+
+// src/gateway/dispatcher.ts
+var DIALECTIC_RATE_LIMIT_MS = 1e4;
+var _dialecticLastEvalMs = /* @__PURE__ */ new Map();
+function ensureRequestSessionLineage(request) {
+  request.executionSessionId ??= process.env.CLEO_EXECUTION_SESSION_ID ?? process.env.CLEO_SESSION_EXECUTION_ID ?? randomUUID2();
+  request.originSessionId ??= process.env.CLEO_ORIGIN_SESSION_ID ?? process.env.CLEO_SESSION_ORIGIN_ID ?? request.sessionId ?? request.executionSessionId;
+}
+function isDialecticEvalAllowed(sessionId) {
+  const last = _dialecticLastEvalMs.get(sessionId) ?? 0;
+  const now = Date.now();
+  if (now - last < DIALECTIC_RATE_LIMIT_MS) {
+    return false;
+  }
+  _dialecticLastEvalMs.set(sessionId, now);
+  return true;
+}
+var Dispatcher = class {
+  handlers;
+  pipeline;
+  constructor(config) {
+    this.handlers = config.handlers;
+    this.pipeline = config.middlewares?.length ? compose(config.middlewares) : (_req, next) => next();
+  }
+  async dispatch(request) {
+    const startTime = Date.now();
+    ensureRequestSessionLineage(request);
+    const resolved = resolve(request.gateway, request.domain, request.operation);
+    if (!resolved) {
+      return {
+        meta: createDispatchMeta(
+          request.gateway,
+          request.domain,
+          request.operation,
+          startTime,
+          request.source,
+          request.requestId,
+          request.sessionId,
+          request.originSessionId,
+          request.executionSessionId
+        ),
+        success: false,
+        error: {
+          code: "E_INVALID_OPERATION",
+          message: `Unknown operation: ${request.gateway}:${request.domain}.${request.operation}`
+        }
+      };
+    }
+    const missing = validateRequiredParams(resolved.def, request.params);
+    if (missing.length > 0) {
+      return {
+        meta: createDispatchMeta(
+          request.gateway,
+          resolved.domain,
+          resolved.operation,
+          startTime,
+          request.source,
+          request.requestId,
+          request.sessionId,
+          request.originSessionId,
+          request.executionSessionId
+        ),
+        success: false,
+        error: {
+          code: "E_MISSING_PARAMS",
+          message: `Missing required parameters: ${missing.join(", ")}`,
+          details: { missing }
+        }
+      };
+    }
+    const handler = this.handlers.get(resolved.domain);
+    if (!handler) {
+      return {
+        meta: createDispatchMeta(
+          request.gateway,
+          resolved.domain,
+          resolved.operation,
+          startTime,
+          request.source,
+          request.requestId,
+          request.sessionId,
+          request.originSessionId,
+          request.executionSessionId
+        ),
+        success: false,
+        error: {
+          code: "E_NO_HANDLER",
+          message: `No handler for domain: ${resolved.domain}`
+        }
+      };
+    }
+    const terminal = async () => {
+      if (request.gateway === "query") {
+        return handler.query(resolved.operation, request.params);
+      } else {
+        return handler.mutate(resolved.operation, request.params);
+      }
+    };
+    const response = await this.pipeline(request, terminal);
+    response.meta.duration_ms = Date.now() - startTime;
+    response.meta.requestId = request.requestId;
+    response.meta.source = request.source;
+    if (request.sessionId) {
+      response.meta.sessionId = request.sessionId;
+    }
+    if (request.originSessionId) {
+      response.meta.originSessionId = request.originSessionId;
+    }
+    if (request.executionSessionId) {
+      response.meta.executionSessionId = request.executionSessionId;
+    }
+    if (response.success && request.gateway === "mutate" && request.sessionId && isDialecticEvalAllowed(request.sessionId)) {
+      const capturedRequest = request;
+      const capturedSessionId = request.sessionId;
+      setImmediate(() => {
+        Promise.all([
+          import("@cleocode/core/memory/dialectic-evaluator.js"),
+          import("@cleocode/core/store/nexus-sqlite.js"),
+          import("@cleocode/core/store/memory-sqlite.js")
+        ]).then(async ([{ evaluateDialectic, applyInsights }, { getNexusDb }, { getBrainDb }]) => {
+          const projectRoot = getProjectRoot();
+          const turn = {
+            userMessage: `cleo ${capturedRequest.domain} ${capturedRequest.operation} ${JSON.stringify(capturedRequest.params ?? {})}`,
+            systemResponse: `Operation succeeded in domain "${capturedRequest.domain}".`,
+            activePeerId: capturedRequest.params?.["peerId"] ?? "global",
+            sessionId: capturedSessionId
+          };
+          const insights = await evaluateDialectic(turn);
+          const [nexusDb, brainDb] = await Promise.all([getNexusDb(), getBrainDb()]);
+          await applyInsights(insights, nexusDb, brainDb, {
+            sessionId: capturedSessionId,
+            activePeerId: turn.activePeerId,
+            projectRoot
+          });
+        }).catch((err) => {
+          const log = getLogger("dialectic-hook");
+          log.warn({ err }, "dialectic-evaluator failed");
+        });
+      });
+    }
+    return response;
+  }
+};
+
+// src/gateway/background-jobs.ts
+import {
+  BackgroundJobManager,
+  DurableJobStore
+} from "@cleocode/core/store/background-jobs.js";
+
+// src/gateway/daemon-subsystem.ts
+import { getLogger as getLogger2 } from "@cleocode/core";
+function gatewaySubsystemName(scope) {
+  return `gateway-${scope}`;
+}
+function defineGatewaySubsystem(opts) {
+  if (opts.rpc === void 0 && opts.http === void 0) {
+    throw new TypeError(
+      "defineGatewaySubsystem: at least one transport (rpc and/or http) must be configured"
+    );
+  }
+  const name = gatewaySubsystemName(opts.scope);
+  const log = getLogger2(name);
+  let live;
+  return defineSubsystem({
+    name,
+    async start() {
+      let rpc;
+      try {
+        if (opts.rpc !== void 0) {
+          rpc = await startRpcServer(opts.handler, opts.rpc);
+        }
+        let http;
+        if (opts.http !== void 0) {
+          http = await startHttpServer(opts.handler, opts.http);
+        }
+        const context = { pid: process.pid, rpc, http };
+        live = context;
+        log.info(
+          { scope: opts.scope, rpc: rpc?.socketPath, httpPort: http?.port },
+          "gateway subsystem started"
+        );
+        return context;
+      } catch (cause) {
+        if (rpc !== void 0) {
+          await rpc.close().catch(() => void 0);
+        }
+        live = void 0;
+        throw cause;
+      }
+    },
+    healthProbe() {
+      if (live === void 0) {
+        const stopped = "stopped";
+        return {
+          child_id: name,
+          pid: 0,
+          state: stopped,
+          restart_count: 0,
+          detail: `scope=${opts.scope} not started`
+        };
+      }
+      const transports = [];
+      if (live.rpc !== void 0) transports.push(`rpc=${live.rpc.socketPath}`);
+      if (live.http !== void 0) {
+        transports.push(`http=${live.http.host}:${live.http.port}`);
+      }
+      const running = "running";
+      return {
+        child_id: name,
+        pid: live.pid,
+        state: running,
+        restart_count: 0,
+        detail: `scope=${opts.scope} ${transports.join(" ")}`.trim()
+      };
+    },
+    async shutdown(context) {
+      if (context.http !== void 0) {
+        await context.http.close().catch((err) => {
+          log.warn({ err }, "gateway http close failed");
+        });
+      }
+      if (context.rpc !== void 0) {
+        await context.rpc.close().catch((err) => {
+          log.warn({ err }, "gateway rpc close failed");
+        });
+      }
+      live = void 0;
+      log.info({ scope: opts.scope }, "gateway subsystem stopped");
+    }
+  });
+}
+
+// src/gateway/engine.ts
+import {
+  addTaskWithSessionScope,
+  completeTaskStrict,
+  configGet,
+  configListPresets,
+  configSet,
+  configSetPreset,
+  coreBatchValidate,
+  coreCoherenceCheck,
+  coreComplianceRecord,
+  coreComplianceSummary,
+  coreComplianceViolations,
+  coreTestCoverage,
+  coreTestRun,
+  coreTestStatus,
+  coreValidateManifest,
+  coreValidateOutput,
+  coreValidateProtocol,
+  coreValidateSchema,
+  coreValidateTask,
+  ensureInitialized,
+  filterEntries,
+  getVersion,
+  initProject,
+  isAutoInitEnabled,
+  lifecycleCheck,
+  lifecycleGateFail,
+  lifecycleGatePass,
+  lifecycleGates,
+  lifecycleHistory,
+  lifecyclePrerequisites,
+  lifecycleProgress,
+  lifecycleReset,
+  lifecycleSkip,
+  lifecycleStatus,
+  mapCodebase,
+  memoryBrainStats,
+  memoryContradictions,
+  memoryDecisionFind,
+  memoryDecisionStore,
+  memoryFetch,
+  memoryFind,
+  memoryGraphAdd,
+  memoryGraphContext,
+  memoryGraphNeighbors,
+  memoryGraphRelated,
+  memoryGraphRemove,
+  memoryGraphShow,
+  memoryGraphStatsFull,
+  memoryGraphTrace,
+  memoryLearningFind,
+  memoryLearningStats,
+  memoryLearningStore,
+  memoryLink,
+  memoryObserve,
+  memoryPatternFind,
+  memoryPatternStats,
+  memoryPatternStore,
+  memoryQualityReport,
+  memoryReasonSimilar,
+  memoryReasonWhy,
+  memorySearchHybrid,
+  memoryShow,
+  memorySuperseded,
+  memoryTimeline,
+  memoryUnlink,
+  orchestrateAnalyze,
+  orchestrateBootstrap,
+  orchestrateCheck,
+  orchestrateContext,
+  orchestrateCriticalPath,
+  orchestrateHandoff,
+  orchestrateNext,
+  orchestrateParallelEnd,
+  orchestrateParallelStart,
+  orchestratePlan,
+  orchestrateReady,
+  orchestrateReport,
+  orchestrateSkillInject,
+  orchestrateSpawn,
+  orchestrateSpawnExecute,
+  orchestrateStartup,
+  orchestrateStatus,
+  orchestrateUnblockOpportunities,
+  orchestrateValidate,
+  orchestrateWaves,
+  phaseAdvance,
+  phaseComplete,
+  phaseDelete,
+  phaseList,
+  phaseRename,
+  phaseSet,
+  phaseShow,
+  phaseStart,
+  pipelineManifestAppend,
+  pipelineManifestArchive,
+  pipelineManifestFind,
+  pipelineManifestList,
+  pipelineManifestPending,
+  pipelineManifestShow,
+  pipelineManifestStats,
+  queryCommonHooks,
+  queryHookProviders,
+  readManifestEntries,
+  releaseCancel,
+  releaseCommit,
+  releaseGateCheck,
+  releaseGatesRun,
+  releaseIvtrAutoSuggest,
+  releaseList,
+  releaseOpen,
+  releasePlan,
+  releasePrepare,
+  releasePrStatus,
+  releasePush,
+  releaseReconcileV2,
+  releaseRollback,
+  releaseRollbackFull,
+  releaseShow,
+  releaseTag,
+  sessionAdopt,
+  sessionArchive,
+  sessionBriefing,
+  sessionChainShow,
+  sessionCleanup,
+  sessionComputeDebrief,
+  sessionComputeHandoff,
+  sessionContextDrift,
+  sessionContextInject,
+  sessionDebriefShow,
+  sessionDecisionLog,
+  sessionEnd,
+  sessionFind,
+  sessionGc,
+  sessionHandoff,
+  sessionHistory,
+  sessionList,
+  sessionRecordAssumption,
+  sessionRecordDecision,
+  sessionResume,
+  sessionShow,
+  sessionStart,
+  sessionStats,
+  sessionStatus,
+  sessionSuspend,
+  sessionSwitch,
+  systemHooksMatrix,
+  taskAnalyze,
+  taskArchive,
+  taskBatchValidate,
+  taskBlockers,
+  taskCancel,
+  taskClaim,
+  taskComplete,
+  taskComplexityEstimate,
+  taskCurrentGet,
+  taskDelete,
+  taskDepends,
+  taskDeps,
+  taskDepsCycles,
+  taskDepsOverview,
+  taskDepsTree,
+  taskDepsValidate,
+  taskExists,
+  taskExport,
+  taskFind,
+  taskHistory,
+  taskImpact,
+  taskImport,
+  taskLabelList,
+  taskLabelShow,
+  taskLint,
+  taskList,
+  taskNext,
+  taskPlan,
+  taskPromote,
+  taskRelates,
+  taskRelatesAdd,
+  taskRelatesAddBatch,
+  taskRelatesFind,
+  taskRelatesRemove,
+  taskReopen,
+  taskReorder,
+  taskReparent,
+  taskRestore,
+  taskShow,
+  taskShowIvtrHistory,
+  taskShowOperation,
+  taskShowWithHistory,
+  taskSlice,
+  taskStart,
+  taskStats,
+  taskStop,
+  taskSyncLinks,
+  taskSyncLinksRemove,
+  taskSyncReconcile,
+  tasksAddBatchOp,
+  taskTree,
+  taskUnarchive,
+  taskUnclaim,
+  taskUpdate,
+  taskWorkHistory,
+  validateChangelog,
+  validateGateVerify,
+  validateProtocolArchitectureDecision,
+  validateProtocolArtifactPublish,
+  validateProtocolConsensus,
+  validateProtocolContribution,
+  validateProtocolDecomposition,
+  validateProtocolImplementation,
+  validateProtocolProvenance,
+  validateProtocolRelease,
+  validateProtocolResearch,
+  validateProtocolSpecification,
+  validateProtocolTesting,
+  validateProtocolValidation
+} from "@cleocode/core/internal";
+
+// src/gateway/template-parser.ts
+import {
+  generateTemplateConfig as coreGenerateTemplateConfig,
+  getTemplateForSubcommand as coreGetTemplateForSubcommand,
+  parseIssueTemplates as coreParseIssueTemplates,
+  templates
+} from "@cleocode/core/internal";
+function adaptResult(result) {
+  if (result.success) {
+    if (result.data === void 0) {
+      return {
+        success: false,
+        error: { code: "E_INTERNAL", message: "Template parser succeeded with no data" }
+      };
+    }
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    error: result.error ? {
+      code: result.error.code,
+      message: result.error.message,
+      ...result.error.details ? { details: result.error.details } : {}
+    } : { code: "E_INTERNAL", message: "Unknown error" }
+  };
+}
+function parseIssueTemplates(projectRoot) {
+  return adaptResult(coreParseIssueTemplates(projectRoot));
+}
+function getTemplateForSubcommand(projectRoot, subcommand) {
+  return adaptResult(coreGetTemplateForSubcommand(projectRoot, subcommand));
+}
+async function generateTemplateConfig(projectRoot) {
+  return adaptResult(await coreGenerateTemplateConfig(projectRoot));
+}
+function validateLabels(labels, repoLabels) {
+  return adaptResult(templates.validateLabels(labels, repoLabels));
+}
+
+// src/gateway/engine-error.ts
+import {
+  engineError as coreEngineError,
+  getLogger as getLogger3
+} from "@cleocode/core";
+
+// src/gateway/exit-codes.ts
+var _inverseCache = null;
+function getInverseMap() {
+  if (_inverseCache) return _inverseCache;
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(STRING_TO_EXIT)) {
+    if (!map.has(value)) {
+      map.set(value, key);
+    }
+  }
+  _inverseCache = map;
+  return map;
+}
+function mapNumericExitCodeToString(numericCode) {
+  if (numericCode === void 0) return void 0;
+  return getInverseMap().get(numericCode);
+}
+
+// src/gateway/engine-error.ts
+import { engineSuccess } from "@cleocode/core";
+var STRING_TO_EXIT = {
+  // General Errors (1-9)
+  E_GENERAL: 1,
+  E_GENERAL_ERROR: 1,
+  E_INVALID_INPUT: 2,
+  E_MISSING_PARAMS: 2,
+  E_INVALID_OPERATION: 2,
+  E_FILE_ERROR: 3,
+  E_NOT_FOUND: 4,
+  E_DEPENDENCY: 5,
+  E_DEPENDENCY_ERROR: 5,
+  E_VALIDATION: 6,
+  E_VALIDATION_FAILED: 6,
+  E_VALIDATION_ERROR: 6,
+  E_RETRYABLE: 7,
+  E_LOCK_TIMEOUT: 7,
+  E_CONFIG_ERROR: 8,
+  // Hierarchy Errors (10-19)
+  E_PARENT_NOT_FOUND: 10,
+  E_DEPTH_EXCEEDED: 11,
+  E_SIBLING_LIMIT: 12,
+  E_INVALID_PARENT_TYPE: 13,
+  E_INVALID_PARENT: 13,
+  E_CIRCULAR_DEP: 14,
+  E_CIRCULAR_REFERENCE: 14,
+  E_ORPHAN_DETECTED: 15,
+  E_HAS_CHILDREN: 16,
+  E_TASK_COMPLETED: 17,
+  // ExitCode.TASK_COMPLETED — canonical value from @cleocode/contracts
+  E_CASCADE_FAILED: 18,
+  E_HAS_DEPENDENTS: 19,
+  // Concurrency Errors (20-29)
+  E_CHECKSUM_MISMATCH: 20,
+  E_CONCURRENT_MODIFICATION: 21,
+  E_ID_COLLISION: 22,
+  // Session Errors (30-39)
+  E_SESSION_EXISTS: 30,
+  E_SESSION_CONFLICT: 30,
+  E_SESSION_NOT_FOUND: 31,
+  E_SCOPE_CONFLICT: 32,
+  E_SCOPE_INVALID: 33,
+  E_TASK_NOT_IN_SCOPE: 34,
+  E_TASK_CLAIMED: 35,
+  E_SESSION_REQUIRED: 36,
+  E_SESSION_CLOSE_BLOCKED: 37,
+  E_ACTIVE_TASK_REQUIRED: 38,
+  E_NOTES_REQUIRED: 39,
+  // Verification Errors (40-47)
+  E_VERIFICATION_INIT_FAILED: 40,
+  E_GATE_UPDATE_FAILED: 41,
+  E_INVALID_GATE: 42,
+  E_INVALID_AGENT: 43,
+  E_MAX_ROUNDS_EXCEEDED: 44,
+  E_GATE_DEPENDENCY: 45,
+  E_VERIFICATION_LOCKED: 46,
+  E_ROUND_MISMATCH: 47,
+  // T1590 — Acceptance-criteria immutability after implementation stage
+  E_AC_LOCKED: 48,
+  // Context Safeguard (50-54)
+  E_CONTEXT_WARNING: 50,
+  E_CONTEXT_CAUTION: 51,
+  E_CONTEXT_CRITICAL: 52,
+  E_CONTEXT_EMERGENCY: 53,
+  E_CONTEXT_STALE: 54,
+  // Orchestrator / Protocol Errors (60-67)
+  E_PROTOCOL_MISSING: 60,
+  E_PROTOCOL_RESEARCH: 60,
+  E_INVALID_RETURN_MESSAGE: 61,
+  E_PROTOCOL_CONSENSUS: 61,
+  E_MANIFEST_ENTRY_MISSING: 62,
+  E_PROTOCOL_SPECIFICATION: 62,
+  E_SPAWN_VALIDATION_FAILED: 63,
+  E_PROTOCOL_DECOMPOSITION: 63,
+  E_AUTONOMOUS_BOUNDARY: 64,
+  E_PROTOCOL_IMPLEMENTATION: 64,
+  E_HANDOFF_REQUIRED: 65,
+  E_PROTOCOL_CONTRIBUTION: 65,
+  E_RESUME_FAILED: 66,
+  E_PROTOCOL_RELEASE: 66,
+  E_CONCURRENT_SESSION: 67,
+  E_PROTOCOL_GENERIC: 67,
+  // Nexus Errors (70-79)
+  E_NEXUS_NOT_INITIALIZED: 70,
+  E_NEXUS_PROJECT_NOT_FOUND: 71,
+  E_NEXUS_PERMISSION_DENIED: 72,
+  E_NEXUS_INVALID_SYNTAX: 73,
+  E_NEXUS_SYNC_FAILED: 74,
+  E_NEXUS_REGISTRY_CORRUPT: 75,
+  E_NEXUS_PROJECT_EXISTS: 76,
+  E_NEXUS_QUERY_FAILED: 77,
+  E_NEXUS_GRAPH_ERROR: 78,
+  // Lifecycle Enforcement (80-84)
+  E_LIFECYCLE_GATE_FAILED: 80,
+  E_AUDIT_MISSING: 81,
+  E_CIRCULAR_VALIDATION: 82,
+  E_LIFECYCLE_TRANSITION_INVALID: 83,
+  E_IVTR_INCOMPLETE: 83,
+  E_PROVENANCE_REQUIRED: 84,
+  // T1162: lifecycle scope guard — maps to ExitCode.TASK_NOT_IN_SCOPE (34)
+  // because a subagent attempting to mutate a parent epic's lifecycle is
+  // operating outside the scope granted by its session.
+  E_LIFECYCLE_SCOPE_DENIED: 34,
+  // Artifact Publish (85-89)
+  E_ARTIFACT_TYPE_UNKNOWN: 85,
+  E_ARTIFACT_VALIDATION_FAILED: 86,
+  E_ARTIFACT_BUILD_FAILED: 87,
+  E_ARTIFACT_PUBLISH_FAILED: 88,
+  E_ARTIFACT_ROLLBACK_FAILED: 89,
+  // Provenance (90-94)
+  E_PROVENANCE_CONFIG_INVALID: 90,
+  E_SIGNING_KEY_MISSING: 91,
+  E_SIGNATURE_INVALID: 92,
+  E_DIGEST_MISMATCH: 93,
+  E_ATTESTATION_INVALID: 94,
+  // Special Codes (100+) - NOT errors
+  E_NO_DATA: 100,
+  E_ALREADY_EXISTS: 101,
+  E_NO_CHANGE: 102,
+  E_TESTS_SKIPPED: 103,
+  // Adapter Errors (95-99)
+  E_ADAPTER_NOT_FOUND: 95,
+  E_ADAPTER_INIT_FAILED: 96,
+  E_ADAPTER_HOOK_FAILED: 97,
+  E_ADAPTER_SPAWN_FAILED: 98,
+  E_ADAPTER_INSTALL_FAILED: 99,
+  // Common engine-specific aliases
+  E_NOT_INITIALIZED: 3,
+  E_NO_HANDLER: 1,
+  E_INTERNAL: 1,
+  E_LIST_FAILED: 3,
+  E_READ_FAILED: 3,
+  E_WRITE_FAILED: 3,
+  E_PARSE_ERROR: 2,
+  E_TEMPLATE_ERROR: 2
+};
+function logLevel(exitCode) {
+  if (exitCode === 0 || exitCode >= 100) return "debug";
+  if (exitCode === 1 || exitCode === 3) return "error";
+  return "warn";
+}
+function engineError(code, message, options) {
+  const resolvedExitCode = options?.exitCode ?? STRING_TO_EXIT[code] ?? 1;
+  const level = logLevel(resolvedExitCode);
+  const isVitest = process.env["VITEST"] === "true";
+  if (!isVitest) {
+    const logger = getLogger3("engine");
+    logger[level](
+      { code, exitCode: resolvedExitCode, ...options?.details && { details: options.details } },
+      message
+    );
+  }
+  return coreEngineError(code, message, { ...options, exitCode: resolvedExitCode });
+}
+function cleoErrorToEngineError(err, fallbackCode, fallbackMessage, meta) {
+  if (typeof err === "string") {
+    const exitCode2 = STRING_TO_EXIT[fallbackCode] ?? 1;
+    return engineError(fallbackCode, err, {
+      exitCode: exitCode2,
+      problemDetails: {
+        type: `https://cleocode.dev/errors/${fallbackCode}`,
+        title: fallbackCode,
+        status: exitCode2,
+        detail: err,
+        ...meta?.requestId !== void 0 ? { instance: meta.requestId } : {}
+      }
+    });
+  }
+  if (err !== null && typeof err !== "object") {
+    const exitCode2 = STRING_TO_EXIT[fallbackCode] ?? 1;
+    const message2 = String(err);
+    return engineError(fallbackCode, message2, {
+      exitCode: exitCode2,
+      problemDetails: {
+        type: `https://cleocode.dev/errors/${fallbackCode}`,
+        title: fallbackCode,
+        status: exitCode2,
+        detail: message2,
+        ...meta?.requestId !== void 0 ? { instance: meta.requestId } : {}
+      }
+    });
+  }
+  const e = err;
+  const code = mapNumericExitCodeToString(e.code) ?? fallbackCode;
+  const message = e.message ?? fallbackMessage;
+  const exitCode = STRING_TO_EXIT[code] ?? 1;
+  return engineError(code, message, {
+    exitCode,
+    ...e.fix !== void 0 && { fix: e.fix },
+    ...e.details !== void 0 && { details: e.details },
+    ...e.alternatives !== void 0 && { alternatives: e.alternatives },
+    problemDetails: {
+      type: `https://cleocode.dev/errors/${code}`,
+      title: code,
+      status: exitCode,
+      detail: message,
+      ...meta?.requestId !== void 0 ? { instance: meta.requestId } : {}
+    }
+  });
+}
+
+// src/gateway/job-manager-accessor.ts
+var _instance = null;
+function setJobManager(manager) {
+  _instance = manager;
+}
+function getJobManager() {
+  return _instance;
+}
+
+// src/gateway/nexus-decorator.ts
+import { getNexusDescriptor, NEXUS_SCOPE_MAP } from "@cleocode/contracts";
+function resolveBindingSource(descriptor, params) {
+  if (!descriptor.requiresProject) return "none";
+  if (typeof params["projectId"] === "string" && params["projectId"]) {
+    return "arg-project-id";
+  }
+  if (typeof params["path"] === "string" && params["path"]) {
+    return "arg-path";
+  }
+  if (typeof params["_resolvedFrom"] === "string") {
+    return params["_resolvedFrom"] === "cwd" ? "cwd" : "registry";
+  }
+  return "cwd";
+}
+function resolveIndexFreshness(params) {
+  const fromParams = params["_indexFreshness"];
+  if (fromParams === "fresh" || fromParams === "stale") return fromParams;
+  return "unknown";
+}
+function canonicalCommandFor(op) {
+  return `cleo nexus ${op}`;
+}
+function validateSuggestedNext(suggestions) {
+  for (const s of suggestions) {
+    if (!(s.op in NEXUS_SCOPE_MAP)) {
+      throw new TypeError(
+        `[nexus-decorator] suggestedNext.op "${s.op}" is not a known NEXUS_SCOPE_MAP entry. Add it to packages/contracts/src/operations/nexus-scope-map.ts first.`
+      );
+    }
+  }
+}
+function formatSuggestedNext(s) {
+  const argParts = Object.entries(s.args).map(([k, v]) => `--${k} ${String(v)}`).join(" ");
+  const cmd = `cleo nexus ${s.op}${argParts ? ` ${argParts}` : ""}`;
+  const confirm = s.requiresConfirmation ? "confirm before running" : "no confirmation needed";
+  return `${cmd} (${s.effect}, ${confirm}) \u2014 ${s.reason}`;
+}
+function stampNexusMeta(response, operation, params, isTopLevel = true) {
+  if (!(operation in NEXUS_SCOPE_MAP)) {
+    return response;
+  }
+  const descriptor = getNexusDescriptor(operation);
+  const bindingSource = resolveBindingSource(descriptor, params);
+  const projectId = typeof params["projectId"] === "string" ? params["projectId"] : void 0;
+  const projectName = typeof params["_projectName"] === "string" ? params["_projectName"] : void 0;
+  const projectPath = typeof params["_projectPath"] === "string" ? params["_projectPath"] : void 0;
+  const registryPath = typeof params["_registryPath"] === "string" ? params["_registryPath"] : void 0;
+  const counterpartProjectId = descriptor.scope === "cross" || descriptor.scope === "hybrid" ? typeof params["counterpartProjectId"] === "string" ? params["counterpartProjectId"] : void 0 : void 0;
+  const indexFreshness = descriptor.indexSensitive && isTopLevel ? resolveIndexFreshness(params) : void 0;
+  const legacyAliasFor = typeof params["_legacyAliasFor"] === "string" ? params["_legacyAliasFor"] : void 0;
+  const nexusMeta = {
+    scope: descriptor.scope,
+    effect: descriptor.effect,
+    ...projectId !== void 0 && { projectId },
+    ...projectName !== void 0 && { projectName },
+    ...projectPath !== void 0 && { projectPath },
+    ...registryPath !== void 0 && { registryPath },
+    bindingSource,
+    ...counterpartProjectId !== void 0 && { counterpartProjectId },
+    ...indexFreshness !== void 0 && { indexFreshness },
+    canonicalCommand: canonicalCommandFor(operation),
+    ...legacyAliasFor !== void 0 && { legacyAliasFor }
+  };
+  return {
+    ...response,
+    meta: {
+      ...response.meta,
+      _nexus: nexusMeta,
+      // Stamp top-level deprecated field for alias shims (T9147)
+      ...legacyAliasFor !== void 0 && {
+        deprecated: {
+          since: "v2026.6.5",
+          removeIn: "v2026.8.0",
+          replacement: `cleo graph ${operation}`
+        }
+      }
+    }
+  };
+}
+function pickDecoratorMetaExtensions(responseMeta) {
+  if (!responseMeta) return {};
+  const out = {};
+  if (responseMeta["_nexus"] !== void 0) out["_nexus"] = responseMeta["_nexus"];
+  if (responseMeta["deprecated"] !== void 0) out["deprecated"] = responseMeta["deprecated"];
+  if (responseMeta.sessionId !== void 0) out["sessionId"] = responseMeta.sessionId;
+  if (responseMeta.originSessionId !== void 0) {
+    out["originSessionId"] = responseMeta.originSessionId;
+  }
+  if (responseMeta.executionSessionId !== void 0) {
+    out["executionSessionId"] = responseMeta.executionSessionId;
+  }
+  if (responseMeta["suggestedNext"] !== void 0) {
+    out["suggestedNext"] = responseMeta["suggestedNext"];
+  }
+  return out;
+}
+function buildNexusMetaExtensions(operation, params = {}) {
+  const synthetic = {
+    success: true,
+    data: void 0,
+    meta: {
+      gateway: "query",
+      domain: "nexus",
+      operation,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration_ms: 0,
+      source: "cli",
+      requestId: ""
+    }
+  };
+  const stamped = stampNexusMeta(synthetic, operation, params);
+  return pickDecoratorMetaExtensions(stamped.meta);
+}
+
+// src/gateway/paths.ts
+var CLEO_DIR_NAME = ".cleo";
+var WORKFLOWS_SUBDIR = "workflows";
+var BRAIN_DB_FILENAME = "brain.db";
+
+// src/gateway/index.ts
+function createGatewayHandler(config) {
+  const dispatcher = new Dispatcher(config);
+  return { handle: (req) => dispatcher.dispatch(req) };
+}
+export {
+  BRAIN_DB_FILENAME,
+  BackgroundJobManager,
+  CLEO_DIR_NAME,
+  Dispatcher,
+  DurableJobStore,
+  LineBuffer,
+  MCP_TOOL_PREFIX,
+  OPERATIONS,
+  SSE_HEADERS,
+  STRING_TO_EXIT,
+  WORKFLOWS_SUBDIR,
+  addTaskWithSessionScope,
+  buildErrorFrame,
+  buildNexusMetaExtensions,
+  buildToolsList,
+  callTool,
+  cleoErrorToEngineError,
+  completeTaskStrict,
+  compose,
+  configGet,
+  configListPresets,
+  configSet,
+  configSetPreset,
+  createDispatchMeta,
+  createGatewayHandler,
+  createSseStream,
+  decodeLine,
+  defineGatewaySubsystem,
+  deriveGatewayMatrix,
+  encodeFrame,
+  encodeSseFrame,
+  encodeStreamEvent,
+  engineError,
+  engineSuccess,
+  ensureInitialized,
+  exposedOperations,
+  filterEntries as filterManifestEntries,
+  formatSuggestedNext,
+  gatewaySubsystemName,
+  generateTemplateConfig,
+  getActiveDomains,
+  getByDomain,
+  getByGateway,
+  getByTier,
+  getCounts,
+  getGatewayDomains,
+  getJobManager,
+  getTemplateForSubcommand,
+  getVersion,
+  initProject,
+  isAutoInitEnabled,
+  lifecycleCheck,
+  lifecycleGateFail,
+  lifecycleGatePass,
+  lifecycleGates,
+  lifecycleHistory,
+  lifecyclePrerequisites,
+  lifecycleProgress,
+  lifecycleReset,
+  lifecycleSkip,
+  lifecycleStatus,
+  mapCodebase,
+  mapNumericExitCodeToString,
+  memoryBrainStats,
+  memoryContradictions,
+  memoryDecisionFind,
+  memoryDecisionStore,
+  memoryFetch,
+  memoryFind,
+  memoryGraphAdd,
+  memoryGraphContext,
+  memoryGraphNeighbors,
+  memoryGraphRelated,
+  memoryGraphRemove,
+  memoryGraphShow,
+  memoryGraphStatsFull,
+  memoryGraphTrace,
+  memoryLearningFind,
+  memoryLearningStats,
+  memoryLearningStore,
+  memoryLink,
+  memoryObserve,
+  memoryPatternFind,
+  memoryPatternStats,
+  memoryPatternStore,
+  memoryQualityReport,
+  memoryReasonSimilar,
+  memoryReasonWhy,
+  memorySearchHybrid,
+  memoryShow,
+  memorySuperseded,
+  memoryTimeline,
+  memoryUnlink,
+  operationToMcpTool,
+  operationToToolName,
+  orchestrateAnalyze,
+  orchestrateBootstrap,
+  orchestrateCheck,
+  orchestrateContext,
+  orchestrateCriticalPath,
+  orchestrateHandoff,
+  orchestrateNext,
+  orchestrateParallelEnd,
+  orchestrateParallelStart,
+  orchestratePlan,
+  orchestrateReady,
+  orchestrateReport,
+  orchestrateSkillInject,
+  orchestrateSpawn,
+  orchestrateSpawnExecute,
+  orchestrateStartup,
+  orchestrateStatus,
+  orchestrateUnblockOpportunities,
+  orchestrateValidate,
+  orchestrateWaves,
+  parseHttpRoute,
+  parseIssueTemplates,
+  phaseAdvance,
+  phaseComplete,
+  phaseDelete,
+  phaseList,
+  phaseRename,
+  phaseSet,
+  phaseShow,
+  phaseStart,
+  pickDecoratorMetaExtensions,
+  pipelineManifestAppend,
+  pipelineManifestArchive,
+  pipelineManifestFind,
+  pipelineManifestList,
+  pipelineManifestPending,
+  pipelineManifestShow,
+  pipelineManifestStats,
+  queryCommonHooks,
+  queryHookProviders,
+  readManifestEntries,
+  releaseCancel,
+  releaseCommit,
+  releaseGateCheck,
+  releaseGatesRun,
+  releaseIvtrAutoSuggest,
+  releaseList,
+  releaseOpen,
+  releasePlan,
+  releasePrStatus,
+  releasePrepare,
+  releasePush,
+  releaseReconcileV2,
+  releaseRollback,
+  releaseRollbackFull,
+  releaseShow,
+  releaseTag,
+  resolve,
+  routeFrame,
+  routeUnary,
+  sessionAdopt,
+  sessionArchive,
+  sessionBriefing,
+  sessionChainShow,
+  sessionCleanup,
+  sessionComputeDebrief,
+  sessionComputeHandoff,
+  sessionContextDrift,
+  sessionContextInject,
+  sessionDebriefShow,
+  sessionDecisionLog,
+  sessionEnd,
+  sessionFind,
+  sessionGc,
+  sessionHandoff,
+  sessionHistory,
+  sessionList,
+  sessionRecordAssumption,
+  sessionRecordDecision,
+  sessionResume,
+  sessionShow,
+  sessionStart,
+  sessionStats,
+  sessionStatus,
+  sessionSuspend,
+  sessionSwitch,
+  setJobManager,
+  stampNexusMeta,
+  startHttpServer,
+  startMcpServer,
+  startRpcServer,
+  statusForResponse,
+  systemHooksMatrix,
+  taskAnalyze,
+  taskArchive,
+  taskBatchValidate,
+  taskBlockers,
+  taskCancel,
+  taskClaim,
+  taskComplete,
+  taskComplexityEstimate,
+  taskCurrentGet,
+  taskDelete,
+  taskDepends,
+  taskDeps,
+  taskDepsCycles,
+  taskDepsOverview,
+  taskDepsTree,
+  taskDepsValidate,
+  taskExists,
+  taskExport,
+  taskFind,
+  taskHistory,
+  taskImpact,
+  taskImport,
+  taskLabelList,
+  taskLabelShow,
+  taskLint,
+  taskList,
+  taskNext,
+  taskPlan,
+  taskPromote,
+  taskRelates,
+  taskRelatesAdd,
+  taskRelatesAddBatch,
+  taskRelatesFind,
+  taskRelatesRemove,
+  taskReopen,
+  taskReorder,
+  taskReparent,
+  taskRestore,
+  taskShow,
+  taskShowIvtrHistory,
+  taskShowOperation,
+  taskShowWithHistory,
+  taskSlice,
+  taskStart,
+  taskStats,
+  taskStop,
+  taskSyncLinks,
+  taskSyncLinksRemove,
+  taskSyncReconcile,
+  taskTree,
+  taskUnarchive,
+  taskUnclaim,
+  taskUpdate,
+  taskWorkHistory,
+  tasksAddBatchOp,
+  toolNameToOperationKey,
+  coreBatchValidate as validateBatchValidate,
+  validateChangelog,
+  coreCoherenceCheck as validateCoherenceCheck,
+  coreComplianceRecord as validateComplianceRecord,
+  coreComplianceSummary as validateComplianceSummary,
+  coreComplianceViolations as validateComplianceViolations,
+  validateGateVerify,
+  validateLabels,
+  coreValidateManifest as validateManifestOp,
+  coreValidateOutput as validateOutput,
+  coreValidateProtocol as validateProtocol,
+  validateProtocolArchitectureDecision,
+  validateProtocolArtifactPublish,
+  validateProtocolConsensus,
+  validateProtocolContribution,
+  validateProtocolDecomposition,
+  validateProtocolImplementation,
+  validateProtocolProvenance,
+  validateProtocolRelease,
+  validateProtocolResearch,
+  validateProtocolSpecification,
+  validateProtocolTesting,
+  validateProtocolValidation,
+  validateRequiredParams,
+  coreValidateSchema as validateSchemaOp,
+  validateSuggestedNext,
+  coreValidateTask as validateTaskOp,
+  coreTestCoverage as validateTestCoverage,
+  coreTestRun as validateTestRun,
+  coreTestStatus as validateTestStatus
+};
+//# sourceMappingURL=index.js.map