@saptools/service-flow 0.1.64 → 0.1.66

package/dist/cli.js

@@ -1,9 +1,14 @@
 #!/usr/bin/env node
 import {
+  ANALYZER_VERSION,
+  VERSION,
   classifyODataPathIntent,
+  classifyOutboundCallsInSource,
   clearRepoFacts,
+  compactTrace,
   containsSupportedOutboundCall,
   discoverRepositories,
+  factLifecycleDiagnostic,
   getWorkspace,
   handlerMethodIsExecutable,
   implementationHintSuggestions,
@@ -19,6 +24,7 @@ import {
   listRepositories,
   loadPackageJsonSnapshot,
   loadRepositorySourceContext,
+  migrate,
   normalizeODataOperationInvocationPath,
   normalizePath,
   parseCdsFile,
@@ -30,15 +36,16 @@ import {
   parseServiceBindings,
   parseVars,
   projectBoundedInOrder,
+  redactValue,
   reposByName,
   selectorRepoAmbiguousDiagnostic,
   trace,
   upsertRepository,
   upsertWorkspace
-} from "./chunk-TBH33OYC.js";
+} from "./chunk-TOVX4WYH.js";
 
 // src/cli.ts
-import { Command } from "commander";
+import { Command, Option } from "commander";
 
 // src/config/defaults.ts
 var DEFAULT_IGNORES = [
@@ -108,212 +115,6 @@ function createWorkspaceConfig(rootPath, dbPath, ignore = [...DEFAULT_IGNORES])
 // src/db/connection.ts
 import fs2 from "fs";
 import path2 from "path";
-
-// src/db/schema.ts
-var schemaTablesSql = `
-CREATE TABLE IF NOT EXISTS workspaces (id INTEGER PRIMARY KEY, root_path TEXT UNIQUE NOT NULL, db_path TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
-CREATE TABLE IF NOT EXISTS repositories (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, name TEXT NOT NULL, absolute_path TEXT NOT NULL, relative_path TEXT NOT NULL, package_name TEXT, package_version TEXT, dependencies_json TEXT DEFAULT '{}', kind TEXT NOT NULL, is_git_repo INTEGER NOT NULL, last_indexed_at TEXT, index_status TEXT DEFAULT 'pending', error_count INTEGER DEFAULT 0, fingerprint TEXT, fact_generation INTEGER NOT NULL DEFAULT 0, graph_generation INTEGER NOT NULL DEFAULT 0, graph_stale_reason TEXT, graph_stale_at TEXT, fact_analyzer_version TEXT, UNIQUE(workspace_id, absolute_path), FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS files (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, relative_path TEXT NOT NULL, extension TEXT NOT NULL, sha256 TEXT NOT NULL, size_bytes INTEGER NOT NULL, last_indexed_at TEXT NOT NULL, UNIQUE(repo_id, relative_path), FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS cds_requires (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, alias TEXT NOT NULL, kind TEXT, model TEXT, destination TEXT, service_path TEXT, request_timeout INTEGER, raw_json TEXT NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS cds_services (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, namespace TEXT, service_name TEXT NOT NULL, qualified_name TEXT NOT NULL, service_path TEXT NOT NULL, is_extend INTEGER NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, extension_local_ref TEXT, extension_imported_symbol TEXT, extension_local_alias TEXT, extension_module_specifier TEXT, extension_import_kind TEXT, extension_base_service_id INTEGER, extension_base_status TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(extension_base_service_id) REFERENCES cds_services(id) ON DELETE SET NULL);
-CREATE TABLE IF NOT EXISTS cds_operations (id INTEGER PRIMARY KEY, service_id INTEGER NOT NULL, operation_type TEXT NOT NULL, operation_name TEXT NOT NULL, operation_path TEXT NOT NULL, params_json TEXT NOT NULL, return_type TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, provenance TEXT NOT NULL DEFAULT 'direct', base_operation_id INTEGER, FOREIGN KEY(service_id) REFERENCES cds_services(id) ON DELETE CASCADE, FOREIGN KEY(base_operation_id) REFERENCES cds_operations(id) ON DELETE SET NULL);
-CREATE TABLE IF NOT EXISTS symbols (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, file_id INTEGER, kind TEXT NOT NULL, name TEXT NOT NULL, qualified_name TEXT NOT NULL, exported INTEGER NOT NULL, start_line INTEGER NOT NULL, end_line INTEGER NOT NULL, start_offset INTEGER, end_offset INTEGER, source_file TEXT, exported_name TEXT, evidence_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS handler_classes (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, class_name TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
-CREATE TABLE IF NOT EXISTS handler_methods (id INTEGER PRIMARY KEY, handler_class_id INTEGER NOT NULL, method_name TEXT NOT NULL, decorator_kind TEXT NOT NULL, decorator_value TEXT, decorator_raw_expression TEXT NOT NULL, decorator_resolution_json TEXT NOT NULL DEFAULT '{}', source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS handler_registrations (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, handler_class_id INTEGER, class_name TEXT, import_source TEXT, registration_file TEXT NOT NULL, registration_line INTEGER NOT NULL, registration_kind TEXT NOT NULL, confidence REAL NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE SET NULL);
-CREATE TABLE IF NOT EXISTS service_bindings (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, variable_name TEXT NOT NULL, alias TEXT, alias_expr TEXT, destination_expr TEXT, service_path_expr TEXT, is_dynamic INTEGER NOT NULL, placeholders_json TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, helper_chain_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
-CREATE TABLE IF NOT EXISTS outbound_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, source_symbol_id INTEGER, call_type TEXT NOT NULL, service_binding_id INTEGER, method TEXT, operation_path_expr TEXT, query_entity TEXT, event_name_expr TEXT, payload_summary TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, confidence REAL NOT NULL, unresolved_reason TEXT, local_service_name TEXT, local_service_lookup TEXT, alias_chain_json TEXT, evidence_json TEXT, external_target_kind TEXT, external_target_id TEXT, external_target_label TEXT, external_target_dynamic INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(source_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL, FOREIGN KEY(service_binding_id) REFERENCES service_bindings(id) ON DELETE SET NULL);
-CREATE TABLE IF NOT EXISTS symbol_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, caller_symbol_id INTEGER NOT NULL, callee_symbol_id INTEGER, callee_expression TEXT NOT NULL, import_source TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, status TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, unresolved_reason TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(caller_symbol_id) REFERENCES symbols(id) ON DELETE CASCADE, FOREIGN KEY(callee_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
-CREATE TABLE IF NOT EXISTS graph_edges (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, edge_type TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'unresolved', from_kind TEXT NOT NULL, from_id TEXT NOT NULL, to_kind TEXT NOT NULL, to_id TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, is_dynamic INTEGER NOT NULL, unresolved_reason TEXT, generation INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS index_runs (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, started_at TEXT NOT NULL, finished_at TEXT, status TEXT NOT NULL, repo_count INTEGER NOT NULL, file_count INTEGER NOT NULL, diagnostic_count INTEGER NOT NULL, error_message TEXT, owner_pid INTEGER, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS diagnostics (id INTEGER PRIMARY KEY, repo_id INTEGER, file_id INTEGER, severity TEXT NOT NULL, code TEXT NOT NULL, message TEXT NOT NULL, source_file TEXT, source_line INTEGER, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE SET NULL);
-`;
-var schemaIndexesSql = `
-CREATE INDEX IF NOT EXISTS idx_repo_name ON repositories(name);
-CREATE INDEX IF NOT EXISTS idx_service_path ON cds_services(service_path);
-CREATE INDEX IF NOT EXISTS idx_extension_import ON cds_services(extension_module_specifier, extension_imported_symbol, is_extend);
-CREATE INDEX IF NOT EXISTS idx_operation_name ON cds_operations(operation_name, operation_path);
-CREATE INDEX IF NOT EXISTS idx_operation_base ON cds_operations(base_operation_id);
-CREATE INDEX IF NOT EXISTS idx_calls_repo ON outbound_calls(repo_id, call_type);
-CREATE INDEX IF NOT EXISTS idx_symbol_calls_caller ON symbol_calls(repo_id, caller_symbol_id);
-CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(kind, name, path, repo);
-`;
-var schemaSql = `${schemaTablesSql}
-${schemaIndexesSql}`;
-
-// src/db/migrations.ts
-var CURRENT_SCHEMA_VERSION = 11;
-var columns = {
-  handler_methods: [
-    { name: "decorator_resolution_json", ddl: "ALTER TABLE handler_methods ADD COLUMN decorator_resolution_json TEXT NOT NULL DEFAULT '{}'" }
-  ],
-  service_bindings: [
-    { name: "helper_chain_json", ddl: "ALTER TABLE service_bindings ADD COLUMN helper_chain_json TEXT" },
-    { name: "alias_expr", ddl: "ALTER TABLE service_bindings ADD COLUMN alias_expr TEXT" }
-  ],
-  repositories: [
-    { name: "fingerprint", ddl: "ALTER TABLE repositories ADD COLUMN fingerprint TEXT" },
-    { name: "fact_generation", ddl: "ALTER TABLE repositories ADD COLUMN fact_generation INTEGER NOT NULL DEFAULT 0" },
-    { name: "graph_generation", ddl: "ALTER TABLE repositories ADD COLUMN graph_generation INTEGER NOT NULL DEFAULT 0" },
-    { name: "graph_stale_reason", ddl: "ALTER TABLE repositories ADD COLUMN graph_stale_reason TEXT" },
-    { name: "graph_stale_at", ddl: "ALTER TABLE repositories ADD COLUMN graph_stale_at TEXT" },
-    { name: "fact_analyzer_version", ddl: "ALTER TABLE repositories ADD COLUMN fact_analyzer_version TEXT DEFAULT 'legacy'" }
-  ],
-  graph_edges: [
-    { name: "status", ddl: "ALTER TABLE graph_edges ADD COLUMN status TEXT NOT NULL DEFAULT 'unresolved'" },
-    { name: "generation", ddl: "ALTER TABLE graph_edges ADD COLUMN generation INTEGER NOT NULL DEFAULT 0" }
-  ],
-  handler_registrations: [
-    { name: "class_name", ddl: "ALTER TABLE handler_registrations ADD COLUMN class_name TEXT" },
-    { name: "import_source", ddl: "ALTER TABLE handler_registrations ADD COLUMN import_source TEXT" }
-  ],
-  symbols: [
-    { name: "start_offset", ddl: "ALTER TABLE symbols ADD COLUMN start_offset INTEGER" },
-    { name: "end_offset", ddl: "ALTER TABLE symbols ADD COLUMN end_offset INTEGER" },
-    { name: "source_file", ddl: "ALTER TABLE symbols ADD COLUMN source_file TEXT" },
-    { name: "exported_name", ddl: "ALTER TABLE symbols ADD COLUMN exported_name TEXT" },
-    { name: "evidence_json", ddl: "ALTER TABLE symbols ADD COLUMN evidence_json TEXT" }
-  ],
-  cds_services: [
-    { name: "extension_local_ref", ddl: "ALTER TABLE cds_services ADD COLUMN extension_local_ref TEXT" },
-    { name: "extension_imported_symbol", ddl: "ALTER TABLE cds_services ADD COLUMN extension_imported_symbol TEXT" },
-    { name: "extension_local_alias", ddl: "ALTER TABLE cds_services ADD COLUMN extension_local_alias TEXT" },
-    { name: "extension_module_specifier", ddl: "ALTER TABLE cds_services ADD COLUMN extension_module_specifier TEXT" },
-    { name: "extension_import_kind", ddl: "ALTER TABLE cds_services ADD COLUMN extension_import_kind TEXT" },
-    { name: "extension_base_service_id", ddl: "ALTER TABLE cds_services ADD COLUMN extension_base_service_id INTEGER" },
-    { name: "extension_base_status", ddl: "ALTER TABLE cds_services ADD COLUMN extension_base_status TEXT" }
-  ],
-  cds_operations: [
-    { name: "provenance", ddl: "ALTER TABLE cds_operations ADD COLUMN provenance TEXT NOT NULL DEFAULT 'direct'" },
-    { name: "base_operation_id", ddl: "ALTER TABLE cds_operations ADD COLUMN base_operation_id INTEGER" }
-  ],
-  outbound_calls: [
-    { name: "local_service_name", ddl: "ALTER TABLE outbound_calls ADD COLUMN local_service_name TEXT" },
-    { name: "local_service_lookup", ddl: "ALTER TABLE outbound_calls ADD COLUMN local_service_lookup TEXT" },
-    { name: "alias_chain_json", ddl: "ALTER TABLE outbound_calls ADD COLUMN alias_chain_json TEXT" },
-    { name: "evidence_json", ddl: "ALTER TABLE outbound_calls ADD COLUMN evidence_json TEXT" },
-    { name: "external_target_kind", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_kind TEXT" },
-    { name: "external_target_id", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_id TEXT" },
-    { name: "external_target_label", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_label TEXT" },
-    { name: "external_target_dynamic", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_dynamic INTEGER NOT NULL DEFAULT 0" }
-  ],
-  index_runs: [
-    { name: "error_message", ddl: "ALTER TABLE index_runs ADD COLUMN error_message TEXT" },
-    { name: "owner_pid", ddl: "ALTER TABLE index_runs ADD COLUMN owner_pid INTEGER" }
-  ]
-};
-function hasColumn(db, table, column) {
-  return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column);
-}
-function userVersion(db) {
-  const row = db.pragma("user_version")[0];
-  return Number(row?.user_version ?? 0);
-}
-function addMissingColumns(db) {
-  for (const [table, tableColumns] of Object.entries(columns)) {
-    for (const column of tableColumns) {
-      if (!hasColumn(db, table, column.name)) db.prepare(column.ddl).run();
-    }
-  }
-}
-function normalizeLegacyStatus(db) {
-  db.prepare("UPDATE graph_edges SET status=CASE WHEN edge_type='REMOTE_CALL_RESOLVES_TO_OPERATION' THEN 'resolved' WHEN edge_type IN ('HANDLER_RUNS_DB_QUERY','HANDLER_CALLS_EXTERNAL_HTTP','HANDLER_EMITS_EVENT','EVENT_CONSUMED_BY_HANDLER') THEN 'terminal' WHEN edge_type='DYNAMIC_EDGE_CANDIDATE' THEN 'dynamic' WHEN status='ambiguous' THEN 'ambiguous' ELSE status END").run();
-  db.prepare("UPDATE repositories SET graph_stale_reason='schema_migration_requires_relink', graph_stale_at=COALESCE(graph_stale_at, datetime('now')) WHERE EXISTS (SELECT 1 FROM graph_edges WHERE graph_edges.workspace_id=repositories.workspace_id) AND graph_generation=0").run();
-}
-function migrate(db) {
-  db.transaction(() => {
-    const version = userVersion(db);
-    if (version > CURRENT_SCHEMA_VERSION) throw new Error(`Unsupported future service-flow schema version ${version}`);
-    db.exec(schemaTablesSql);
-    addMissingColumns(db);
-    db.exec(schemaIndexesSql);
-    normalizeLegacyStatus(db);
-    const violations = db.pragma("foreign_key_check");
-    if (violations.length > 0) throw new Error("SQLite foreign_key_check failed during migration");
-    db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);
-  });
-}
-
-// package.json
-var package_default = {
-  name: "@saptools/service-flow",
-  version: "0.1.64",
-  description: "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
-  type: "module",
-  publishConfig: {
-    access: "public",
-    registry: "https://registry.npmjs.org/"
-  },
-  bin: {
-    "service-flow": "dist/cli.js"
-  },
-  main: "./dist/index.js",
-  types: "./dist/index.d.ts",
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    }
-  },
-  files: [
-    "CHANGELOG.md",
-    "README.md",
-    "TECHNICAL-NOTE.md",
-    "dist",
-    "src"
-  ],
-  engines: {
-    node: ">=24.0.0"
-  },
-  scripts: {
-    build: "tsup",
-    typecheck: "tsc --noEmit",
-    lint: "eslint src tests",
-    test: "vitest run tests/unit",
-    "test:unit": "vitest run tests/unit",
-    "test:e2e": "vitest run tests/e2e",
-    "test:e2e:fake": "vitest run tests/e2e"
-  },
-  keywords: [
-    "sap",
-    "cap",
-    "cds",
-    "btp",
-    "cli",
-    "service-graph",
-    "call-graph",
-    "sqlite",
-    "saptools"
-  ],
-  author: "Dong Tran",
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/dongitran/saptools.git",
-    directory: "packages/service-flow"
-  },
-  homepage: "https://github.com/dongitran/saptools/tree/main/packages/service-flow#readme",
-  bugs: {
-    url: "https://github.com/dongitran/saptools/issues"
-  },
-  dependencies: {
-    commander: "13.1.0",
-    picocolors: "1.1.1",
-    typescript: "5.9.3",
-    zod: "4.4.3"
-  },
-  devDependencies: {
-    "@vitest/coverage-v8": "3.2.4",
-    tsup: "8.5.1",
-    vitest: "3.2.4"
-  }
-};
-
-// src/version.ts
-var VERSION = package_default.version;
-var ANALYZER_VERSION = package_default.version;
-
-// src/db/connection.ts
 var sqliteWarningFilterInstalled = false;
 function installSqliteWarningFilter() {
   if (sqliteWarningFilterInstalled) return;
@@ -490,6 +291,52 @@ function exportDeclarations(source) {
 function isRelativeImport(value) {
   return Boolean(value?.startsWith("."));
 }
+function directHandlerReferenceTarget(expression, source, imports, namespaceImports) {
+  if (ts.isIdentifier(expression)) {
+    const importSource2 = imports.get(expression.text);
+    return {
+      calleeExpression: expression.text,
+      calleeLocalName: expression.text,
+      importSource: importSource2,
+      relation: importSource2 ? isRelativeImport(importSource2) ? "relative_import" : "package_import" : "indexed_local_symbol"
+    };
+  }
+  if (!ts.isPropertyAccessExpression(expression) || expression.questionDotToken || !ts.isIdentifier(expression.expression) || !ts.isIdentifier(expression.name))
+    return void 0;
+  const objectName = expression.expression.text;
+  const memberName = expression.name.text;
+  const importSource = imports.get(objectName);
+  if (namespaceImports.has(objectName)) return {
+    calleeExpression: expression.getText(source),
+    calleeLocalName: memberName,
+    importSource,
+    relation: "relative_import_namespace_member"
+  };
+  const qualifiedName = `${objectName}.${memberName}`;
+  return {
+    calleeExpression: qualifiedName,
+    calleeLocalName: qualifiedName,
+    importSource,
+    relation: importSource ? isRelativeImport(importSource) ? "relative_import" : "package_import" : "indexed_local_symbol"
+  };
+}
+function handlerReferenceTarget(expression, source, imports, namespaceImports) {
+  const direct = directHandlerReferenceTarget(
+    expression,
+    source,
+    imports,
+    namespaceImports
+  );
+  if (direct) return direct;
+  if (!ts.isCallExpression(expression) || expression.questionDotToken || expression.arguments.length !== 1) return void 0;
+  const inner = directHandlerReferenceTarget(
+    expression.arguments[0],
+    source,
+    imports,
+    namespaceImports
+  );
+  return inner ? { ...inner, wrapperFunction: expression.expression.getText(source) } : void 0;
+}
 function isObjectFunction(node) {
   return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
 }
@@ -655,6 +502,9 @@ async function parseExecutableSymbols(repoPath, filePath, context) {
   const calls = [];
   const imports = /* @__PURE__ */ new Map();
   const namespaceImports = /* @__PURE__ */ new Set();
+  const eventSubscriptionOffsets = new Set(
+    classifyOutboundCallsInSource(source, sourceFile).filter((call) => call.fact.callType === "async_subscribe").map((call) => `${call.node.getStart(source)}:${call.node.getEnd()}`)
+  );
   const exportNames = exportDeclarations(source);
   const objectExports = /* @__PURE__ */ new Set();
   const exportedClasses = /* @__PURE__ */ new Set();
@@ -771,6 +621,35 @@ async function parseExecutableSymbols(repoPath, filePath, context) {
         const name = `event:${eventName}:${startLine}`;
         symbols.push({ kind: "event_registration", localName: name, qualifiedName: `module:${sourceFile}#${name}`, sourceFile, startLine, endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: false, importExportEvidence: { source: "synthetic_event_registration", eventName: eventArg.text, registrationLine: startLine, receiver } });
       }
+      if (eventSubscriptionOffsets.has(`${node.getStart(source)}:${node.getEnd()}`)) {
+        const startLine = lineOf(source, node.getStart(source));
+        const handlerArgument = node.arguments[1];
+        const target = handlerArgument ? handlerReferenceTarget(
+          handlerArgument,
+          source,
+          imports,
+          namespaceImports
+        ) : void 0;
+        const anchor = nearest(symbols, startLine);
+        if (target && anchor) calls.push({
+          callerQualifiedName: anchor.qualifiedName,
+          calleeExpression: target.calleeExpression,
+          calleeLocalName: target.calleeLocalName,
+          importSource: target.importSource,
+          sourceFile,
+          sourceLine: startLine,
+          callSiteStartOffset: node.getStart(source),
+          callSiteEndOffset: node.getEnd(),
+          callRole: "event_subscribe_handler",
+          evidence: {
+            relation: target.relation,
+            caller: anchor.qualifiedName,
+            targetName: target.calleeLocalName,
+            ...target.wrapperFunction ? { wrapperFunction: target.wrapperFunction } : {},
+            factOrigin: "event_subscribe_handler_reference"
+          }
+        });
+      }
     }
     ts.forEachChild(node, visitEventRegistrationSymbols);
   };
@@ -825,7 +704,7 @@ async function parseExecutableSymbols(repoPath, filePath, context) {
         const ignored = loggerLike || terminalMember || ignoredFrameworkCall(callee);
         const resolvedTarget = provenThisMethod ? thisTarget : targetName;
         const keep = Boolean(resolvedTarget) && !ignored && (provenLocal || provenThisMethod || provenRelativeImport || provenClassInstance || provenPackageImport);
-        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: resolvedTarget, receiverLocalName: callee.member ? callee.local ?? callee.receiver : void 0, importSource, sourceFile, sourceLine: line, evidence: { relation: instance ? "class_instance_method" : proxy ? "relative_import_proxy_member" : packageImport ? "package_import" : namespaceMember ? "relative_import_namespace_member" : importSource ? "relative_import" : provenThisMethod ? "indexed_this_method" : "indexed_local_symbol", caller: caller.qualifiedName, targetName: resolvedTarget, instanceVariable: instance ? instance.propertyName ?? callee.local : void 0, className: instance?.className, methodName: instance ? callee.member : void 0, classImportSource: instance?.importSource, callArguments: argumentEvidence(node.arguments, source), proxyVariableName: proxy?.variableName, factory: proxy?.factory, factoryExpression: proxy?.factory, factoryImportSource: proxy?.importSource, candidateStrategy: instance ? instance.importSource ? "relative_import_class_instance_method" : "same_file_class_instance_method" : proxy ? "proxy_member_exact_export_or_unique_member" : void 0 } });
+        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: resolvedTarget, receiverLocalName: callee.member ? callee.local ?? callee.receiver : void 0, importSource, sourceFile, sourceLine: line, callSiteStartOffset: node.getStart(source), callSiteEndOffset: node.getEnd(), callRole: "ordinary_call", evidence: { relation: instance ? "class_instance_method" : proxy ? "relative_import_proxy_member" : packageImport ? "package_import" : namespaceMember ? "relative_import_namespace_member" : importSource ? "relative_import" : provenThisMethod ? "indexed_this_method" : "indexed_local_symbol", caller: caller.qualifiedName, targetName: resolvedTarget, instanceVariable: instance ? instance.propertyName ?? callee.local : void 0, className: instance?.className, methodName: instance ? callee.member : void 0, classImportSource: instance?.importSource, callArguments: argumentEvidence(node.arguments, source), proxyVariableName: proxy?.variableName, factory: proxy?.factory, factoryExpression: proxy?.factory, factoryImportSource: proxy?.importSource, candidateStrategy: instance ? instance.importSource ? "relative_import_class_instance_method" : "same_file_class_instance_method" : proxy ? "proxy_member_exact_export_or_unique_member" : void 0 } });
       }
     }
     ts.forEachChild(node, visitCalls);
@@ -1258,19 +1137,74 @@ function upperFirst(value) {
   return value ? `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}` : value;
 }
 
-// src/cli/doctor.ts
-function linkUpgradeWarnings(db) {
-  return [...schemaDriftDiagnostics(db, true), ...analyzerVersionDiagnostics(db, true)].filter((item) => ["schema_legacy_columns_present", "external_target_columns_missing_data", "reindex_required_after_upgrade", "reindex_required_after_analyzer_upgrade"].includes(String(item.code)));
+// src/cli/002-doctor-lifecycle.ts
+function linkUpgradeWarnings(db, workspaceId) {
+  const lifecycle = factLifecycleDiagnostic(db, workspaceId);
+  if (lifecycle) return [lifecycle];
+  return [
+    ...schemaDriftDiagnostics(db, true, workspaceId),
+    ...analyzerVersionDiagnostics(db, true, workspaceId)
+  ].filter((item) => [
+    "schema_legacy_columns_present",
+    "external_target_columns_missing_data",
+    "reindex_required_after_upgrade",
+    "reindex_required_after_analyzer_upgrade"
+  ].includes(String(item.code)));
+}
+function schemaDriftDiagnostics(db, strict, workspaceId) {
+  if (!strict) return [];
+  const columns = db.prepare("PRAGMA table_info(symbols)").all();
+  const legacy = columns.filter((row) => [
+    "external_target_kind",
+    "external_target_id",
+    "external_target_label",
+    "external_target_dynamic"
+  ].includes(String(row.name))).map((row) => row.name);
+  const missing = db.prepare(`SELECT c.id id,c.source_file sourceFile,
+    c.source_line sourceLine FROM outbound_calls c
+    JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type='external_http'
+      AND (? IS NULL OR r.workspace_id=?)
+      AND (c.external_target_id IS NULL OR c.external_target_label IS NULL
+        OR c.external_target_kind IS NULL) LIMIT 20`).all(
+    workspaceId,
+    workspaceId
+  );
+  const out = [];
+  if (legacy.length > 0) out.push({ severity: "warning", code: "schema_legacy_columns_present", message: "Legacy external-target columns are present on symbols; run service-flow clean --db-only, then init/index/link to rebuild with the current schema.", scope: "workspace", affectedColumns: legacy, remediation: "service-flow clean --db-only && service-flow init <workspace> && service-flow index && service-flow link" });
+  if (missing.length > 0) out.push({ severity: "warning", code: "external_target_columns_missing_data", message: "External HTTP calls are missing queryable external target metadata; reindex is required after upgrade.", scope: "workspace", affectedRows: missing, remediation: "service-flow index --force && service-flow link" });
+  if (legacy.length > 0 || missing.length > 0) out.push({ severity: "warning", code: "reindex_required_after_upgrade", message: "This database cannot be made equivalent to a fresh index by relink alone.", scope: "workspace", remediation: "Rebuild or force reindex the workspace, then run service-flow doctor --strict." });
+  return out;
+}
+function analyzerVersionDiagnostics(db, strict, workspaceId) {
+  if (!strict) return [];
+  const rows = db.prepare(`SELECT name,
+    COALESCE(fact_analyzer_version,'legacy') factAnalyzerVersion
+    FROM repositories WHERE index_status='indexed'
+      AND (? IS NULL OR workspace_id=?)
+      AND COALESCE(fact_analyzer_version,'legacy')<>?`).all(
+    workspaceId,
+    workspaceId,
+    ANALYZER_VERSION
+  );
+  if (rows.length === 0) return [];
+  return [{ severity: "warning", code: "reindex_required_after_analyzer_upgrade", message: "Repository facts were produced by an older or unknown analyzer; run service-flow index --force before relink to apply current parser semantics.", scope: "workspace", affectedRepositoryCount: rows.length, currentAnalyzerVersion: ANALYZER_VERSION, repositories: rows, remediation: "service-flow index --force && service-flow link" }];
 }
+
+// src/cli/doctor.ts
 function doctorDiagnostics(db, strict, options = {}) {
+  const lifecycle = factLifecycleDiagnostic(db, options.workspaceId);
+  if (lifecycle?.code === "schema_upgrade_required" || lifecycle?.code === "unsupported_future_schema")
+    return boundDoctorDiagnostics([lifecycle]);
   const diagnostics = db.prepare("SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics ORDER BY id").all();
   return boundDoctorDiagnostics([
+    ...lifecycle ? [lifecycle] : [],
     ...diagnostics,
     ...healthDiagnostics(db, strict),
     ...remoteTargetWithoutImplementationDiagnostics(db, strict, Boolean(options.detail)),
     ...localServiceDiagnostics(db, strict),
-    ...schemaDriftDiagnostics(db, strict),
-    ...analyzerVersionDiagnostics(db, strict),
+    ...schemaDriftDiagnostics(db, strict, options.workspaceId),
+    ...analyzerVersionDiagnostics(db, strict, options.workspaceId),
     ...parserQualityDiagnostics(db, strict, options)
   ]);
 }
@@ -1348,23 +1282,6 @@ function remoteTargetWithoutImplementationExamples(db, servicePath, operationPat
       AND NOT EXISTS (SELECT 1 FROM graph_edges impl WHERE impl.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND impl.from_kind='operation' AND impl.from_id=remote.to_id)
     ORDER BY r.name,c.source_file,c.source_line`).all(servicePath, operationPath);
 }
-function schemaDriftDiagnostics(db, strict) {
-  if (!strict) return [];
-  const columns2 = db.prepare("PRAGMA table_info(symbols)").all();
-  const legacy = columns2.filter((row) => ["external_target_kind", "external_target_id", "external_target_label", "external_target_dynamic"].includes(String(row.name))).map((row) => row.name);
-  const missing = db.prepare("SELECT id id,source_file sourceFile,source_line sourceLine FROM outbound_calls WHERE call_type='external_http' AND (external_target_id IS NULL OR external_target_label IS NULL OR external_target_kind IS NULL) LIMIT 20").all();
-  const out = [];
-  if (legacy.length > 0) out.push({ severity: "warning", code: "schema_legacy_columns_present", message: "Legacy external-target columns are present on symbols; run service-flow clean --db-only, then init/index/link to rebuild with the current schema.", scope: "workspace", affectedColumns: legacy, remediation: "service-flow clean --db-only && service-flow init <workspace> && service-flow index && service-flow link" });
-  if (missing.length > 0) out.push({ severity: "warning", code: "external_target_columns_missing_data", message: "External HTTP calls are missing queryable external target metadata; reindex is required after upgrade.", scope: "workspace", affectedRows: missing, remediation: "service-flow index --force && service-flow link" });
-  if (legacy.length > 0 || missing.length > 0) out.push({ severity: "warning", code: "reindex_required_after_upgrade", message: "This database cannot be made equivalent to a fresh index by relink alone.", scope: "workspace", remediation: "Rebuild or force reindex the workspace, then run service-flow doctor --strict." });
-  return out;
-}
-function analyzerVersionDiagnostics(db, strict) {
-  if (!strict) return [];
-  const rows = db.prepare("SELECT name,COALESCE(fact_analyzer_version,'legacy') factAnalyzerVersion FROM repositories WHERE index_status='indexed' AND COALESCE(fact_analyzer_version,'legacy')<>?").all(ANALYZER_VERSION);
-  if (rows.length === 0) return [];
-  return [{ severity: "warning", code: "reindex_required_after_analyzer_upgrade", message: "Repository facts were produced by an older or unknown analyzer; run service-flow index --force before relink to apply current parser semantics.", scope: "workspace", affectedRepositoryCount: rows.length, currentAnalyzerVersion: ANALYZER_VERSION, repositories: rows, remediation: "service-flow index --force && service-flow link" }];
-}
 function localServiceDiagnostics(db, strict) {
   const rows = db.prepare("SELECT e.status status,e.unresolved_reason reason,e.evidence_json evidenceJson FROM graph_edges e JOIN outbound_calls c ON e.from_kind='call' AND c.id=CAST(e.from_id AS INTEGER) WHERE c.call_type='local_service_call'").all();
   const implementationContext = rows.filter((row) => row.status === "resolved" && String(row.evidenceJson ?? "").includes("implementation_context_caller_ownership")).length;
@@ -2114,6 +2031,12 @@ function createStdoutWriter(stream, onUnexpectedError) {
   return writer;
 }
 
+// src/output/001-compact-json-output.ts
+function renderCompactJson(value) {
+  return `${JSON.stringify(redactValue(value))}
+`;
+}
+
 // src/cli/000-clean.ts
 import fs6 from "fs/promises";
 import path6 from "path";
@@ -2175,6 +2098,8 @@ async function markCleanClaimFailed(dbPath, runId, error) {
 
 // src/cli.ts
 var stdout = createStdoutWriter(process.stdout, fail);
+var TRACE_FORMATS = ["table", "json", "mermaid", "compact-json"];
+var GRAPH_FORMATS = ["mermaid", "json", "compact-json"];
 function writeStdout(value) {
   stdout.write(value);
 }
@@ -2252,6 +2177,72 @@ function selectRepository(db, selector, workspaceId) {
     )
   };
 }
+function traceFormatOption() {
+  return new Option("--format <format>", TRACE_FORMATS.join("|")).choices([...TRACE_FORMATS]).default("table");
+}
+function graphFormatOption() {
+  return new Option("--format <format>", GRAPH_FORMATS.join("|")).choices([...GRAPH_FORMATS]).default("mermaid");
+}
+function writeTraceOutput(db, start, options, format) {
+  if (format === "compact-json") {
+    writeStdout(renderCompactJson(compactTrace(db, start, options)));
+    return;
+  }
+  const result = trace(db, start, options);
+  writeStdout(renderDetailedTrace(result, format));
+}
+function renderDetailedTrace(result, format) {
+  if (format === "json") return renderTraceJson(result);
+  if (format === "mermaid") return renderMermaid(result);
+  return renderTraceTable(result);
+}
+function runTraceCommand(opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const start = {
+      repo: opts.repo,
+      servicePath: opts.service,
+      operation: opts.operation,
+      operationPath: opts.path,
+      handler: opts.handler
+    };
+    const options = {
+      depth: Number(opts.depth),
+      workspaceId,
+      vars: parseVars(opts.var),
+      includeExternal: Boolean(opts.includeExternal),
+      includeDb: Boolean(opts.includeDb),
+      includeAsync: Boolean(opts.includeAsync),
+      implementationRepo: opts.implementationRepo,
+      implementationHints: opts.implementationHint.map(parseImplementationHint),
+      dynamicMode: parseDynamicMode(opts.dynamicMode),
+      maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5)
+    };
+    writeTraceOutput(db, start, options, opts.format);
+  });
+}
+function runGraphCommand(opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const start = {
+      repo: opts.repo,
+      operation: opts.operation,
+      servicePath: opts.service,
+      operationPath: opts.path
+    };
+    const options = {
+      depth: 100,
+      workspaceId,
+      includeAsync: true,
+      includeDb: true,
+      includeExternal: true,
+      vars: parseVars(opts.var),
+      implementationRepo: opts.implementationRepo,
+      implementationHints: opts.implementationHint.map(parseImplementationHint),
+      dynamicMode: parseDynamicMode(opts.dynamicMode),
+      maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5)
+    };
+    writeTraceOutput(db, start, options, opts.format);
+  });
+}
 function createProgram() {
   const program = new Command();
   program.name("service-flow").description(
@@ -2275,43 +2266,15 @@ function createProgram() {
   program.command("link").option("--workspace <path>").option("--force").action(
     (opts) => void withWorkspace(opts.workspace, (db, workspaceId) => {
       const r = linkWorkspace(db, workspaceId);
-      const upgradeWarnings = linkUpgradeWarnings(db);
+      const upgradeWarnings = linkUpgradeWarnings(db, workspaceId);
       writeStdout(
         `${upgradeWarnings.length ? `Warnings: ${upgradeWarnings.map((item) => String(item.code)).join(", ")}. Run service-flow doctor --strict for remediation.
-` : ""}Linked ${r.edgeCount} edges: ${r.remoteResolvedCount} remote operation calls resolved, ${r.localResolvedCount} local operation calls resolved, ${r.unresolvedCount} unresolved operation calls, ${r.ambiguousCount} ambiguous operation calls, ${r.dynamicCount} dynamic operation calls, ${r.terminalCount} terminal call edges, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous, ${r.implementationUnresolvedCount} implementation unresolved
+` : ""}Linked ${r.edgeCount} edges: ${r.remoteResolvedCount} remote operation calls resolved, ${r.localResolvedCount} local operation calls resolved, ${r.unresolvedCount} unresolved operation calls, ${r.ambiguousCount} ambiguous operation calls, ${r.dynamicCount} dynamic operation calls, ${r.terminalCount} terminal call edges, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous, ${r.implementationUnresolvedCount} implementation unresolved, ${r.subscriptionHandlerResolvedCount} subscription handlers resolved, ${r.subscriptionHandlerAmbiguousCount} subscription handlers ambiguous, ${r.subscriptionHandlerUnresolvedCount} subscription handlers unresolved, ${r.subscriptionHandlerMissingAssociationCount} subscription handler associations missing
 `
       );
     }).catch(fail)
   );
-  program.command("trace").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").option("--handler <name>").option("--depth <n>", "trace depth", "25").option("--format <format>", "table|json|mermaid", "table").option("--include-external").option("--include-db").option("--include-async").option("--implementation-repo <name>").option("--implementation-hint <scope>", "scoped implementation hint", collect, []).option("--var <key=value>", "dynamic variable", collect, []).option("--dynamic-mode <mode>", "strict|candidates|infer", "strict").option("--max-dynamic-candidates <n>", "maximum dynamic candidates to show", "5").action(
-    (opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-      const result = trace(
-        db,
-        {
-          repo: opts.repo,
-          servicePath: opts.service,
-          operation: opts.operation,
-          operationPath: opts.path,
-          handler: opts.handler
-        },
-        {
-          depth: Number(opts.depth),
-          workspaceId,
-          vars: parseVars(opts.var),
-          includeExternal: Boolean(opts.includeExternal),
-          includeDb: Boolean(opts.includeDb),
-          includeAsync: Boolean(opts.includeAsync),
-          implementationRepo: opts.implementationRepo,
-          implementationHints: opts.implementationHint.map(parseImplementationHint),
-          dynamicMode: parseDynamicMode(opts.dynamicMode),
-          maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5)
-        }
-      );
-      writeStdout(
-        opts.format === "json" ? renderTraceJson(result) : opts.format === "mermaid" ? renderMermaid(result) : renderTraceTable(result)
-      );
-    }).catch(fail)
-  );
+  program.command("trace").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").option("--handler <name>").option("--depth <n>", "trace depth", "25").addOption(traceFormatOption()).option("--include-external").option("--include-db").option("--include-async").option("--implementation-repo <name>").option("--implementation-hint <scope>", "scoped implementation hint", collect, []).option("--var <key=value>", "dynamic variable", collect, []).option("--dynamic-mode <mode>", "strict|candidates|infer", "strict").option("--max-dynamic-candidates <n>", "maximum dynamic candidates to show", "5").action((opts) => void runTraceCommand(opts).catch(fail));
   const list = program.command("list");
   list.command("repos").option("--workspace <path>").action(
     (opts) => void withReadOnlyWorkspace(
@@ -2377,34 +2340,7 @@ function createProgram() {
       writeStdout(renderJson(rows));
     }).catch(fail)
   );
-  program.command("graph").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").option("--format <format>", "mermaid|json", "mermaid").option("--implementation-repo <name>").option("--implementation-hint <scope>", "scoped implementation hint", collect, []).option("--var <key=value>", "dynamic variable", collect, []).option("--dynamic-mode <mode>", "strict|candidates|infer", "strict").option("--max-dynamic-candidates <n>", "maximum dynamic candidates to show", "5").action(
-    (opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-      const result = trace(
-        db,
-        {
-          repo: opts.repo,
-          operation: opts.operation,
-          servicePath: opts.service,
-          operationPath: opts.path
-        },
-        {
-          depth: 100,
-          workspaceId,
-          includeAsync: true,
-          includeDb: true,
-          includeExternal: true,
-          vars: parseVars(opts.var),
-          implementationRepo: opts.implementationRepo,
-          implementationHints: opts.implementationHint.map(parseImplementationHint),
-          dynamicMode: parseDynamicMode(opts.dynamicMode),
-          maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5)
-        }
-      );
-      writeStdout(
-        opts.format === "json" ? renderTraceJson(result) : renderMermaid(result)
-      );
-    }).catch(fail)
-  );
+  program.command("graph").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").addOption(graphFormatOption()).option("--implementation-repo <name>").option("--implementation-hint <scope>", "scoped implementation hint", collect, []).option("--var <key=value>", "dynamic variable", collect, []).option("--dynamic-mode <mode>", "strict|candidates|infer", "strict").option("--max-dynamic-candidates <n>", "maximum dynamic candidates to show", "5").action((opts) => void runGraphCommand(opts).catch(fail));
   const inspect = program.command("inspect");
   inspect.command("repo").argument("<name>").option("--workspace <path>").action(
     (name, opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
@@ -2423,8 +2359,11 @@ function createProgram() {
     }).catch(fail)
   );
   program.command("doctor").option("--workspace <path>").option("--strict").option("--detail").option("--format <format>", "json|table").action(
-    (opts) => void withReadOnlyWorkspace(opts.workspace, (db) => {
-      const allDiagnostics = doctorDiagnostics(db, Boolean(opts.strict), { detail: Boolean(opts.detail) });
+    (opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+      const allDiagnostics = doctorDiagnostics(db, Boolean(opts.strict), {
+        detail: Boolean(opts.detail),
+        workspaceId
+      });
       writeStdout(renderDoctorDiagnostics(allDiagnostics, opts.format));
     }).catch(fail)
   );