graphlin 0.2.0 → 0.2.1

package/runtime/pipeline.mjs

@@ -8,6 +8,8 @@ import {
 } from './core/index.mjs';
 import { safeLabel, safeText, excluded } from './core/privacy.mjs';
 import { createPlatform } from './platform.mjs';
+import { createArchitectureController } from './architecture/controller.mjs';
+import { analyzeArchitecture, ARCHITECTURE_NAMESPACE } from './architecture/analysis.mjs';
 
 const MAX_ACTIVITY = 200;
 const MAX_HOOK_EVENTS = 200;
@@ -93,7 +95,7 @@ function restoreGraph(input, { stale = true } = {}) {
 export function createPipeline({
   projectRoot, policy: policyOptions, decisionService, onChange = () => {},
   onDiagnostic = () => {}, restoredState, restoredModel, mode = 'live', clock = Date.now,
-  classificationDeadlineMs = DEADLINE_MS,
+  classificationDeadlineMs = DEADLINE_MS, missingKey = false,
 } = {}) {
   if (!Number.isSafeInteger(classificationDeadlineMs) ||
       classificationDeadlineMs < DEADLINE_MS || classificationDeadlineMs > 10_000) {
@@ -152,6 +154,9 @@ export function createPipeline({
   let reconciliationTask = null;
   let resumeScheduled = false;
   let lineageId = null;
+  let architecture;
+  let architectureEpoch = 0;
+  const architectureGuards = new WeakMap();
 
   const serialized = (fn) => {
     const operation = serial.then(fn);
@@ -167,9 +172,124 @@ export function createPipeline({
       registerArtifacts(await evidence.reconcile({ refs }));
       return evidence.isCurrent(refs);
     }),
+    onChange: () => { architecture?.wake(); notify(); },
+  });
+  architecture = createArchitectureController({
+    snapshot: () => platform.snapshot(),
+    capture: captureArchitecture,
+    commit: commitArchitecture,
+    analyze: async input => {
+      const guard = {
+        epoch: architectureEpoch, signal: input.signal, policyVersion: policy.version,
+        lineageId: input.model.coverage.lineage?.id ?? modelProjectId,
+      };
+      const result = await analyzeArchitecture({ ...input, service: decisionService, policy });
+      architectureGuards.set(result, guard);
+      return result;
+    },
+    available: architectureUnavailable,
+    ready: () => {
+      const { queued, active } = platform.stats();
+      return queued === 0 && active === 0;
+    },
     onChange: notify,
+    onDiagnostic: result => trace(null, 'classification', {
+      status: result.status === 'complete' ? 'accepted' : result.status === 'partial' ? 'partial' : 'unavailable',
+      reason: result.status === 'complete' ? 'ok' : result.status === 'partial' ? 'unknown' : 'decision_failure',
+      diagnostics: { calls: result.providerRequests },
+    }),
+    now: clock,
   });
 
+  function architectureUnavailable() {
+    if (closed) return 'closed';
+    if (!policy.transmitSource) return 'source_consent_required';
+    if (missingKey) return 'missing_key';
+    if (paused) return 'paused';
+    if (mode === 'demo') return 'demo';
+    if (typeof decisionService?.analyze !== 'function' || typeof decisionService?.evaluate !== 'function') {
+      return 'unsupported_service';
+    }
+    return null;
+  }
+
+  async function captureArchitecture(ids) {
+    const artifacts = await serialized(async () => {
+      if (architectureUnavailable()) return [];
+      const refs = ids.slice(0, 64).filter(id => knownArtifacts.has(id)).map(artifactId => ({ artifactId }));
+      const captures = await evidence.reconcile({ refs });
+      registerArtifacts(captures);
+      return captures;
+    });
+    // Parser acceptance uses the same serial queue; waiting inside it deadlocks.
+    await platform.whenIdle();
+    return artifacts;
+  }
+
+  function commitArchitecture(result, context) {
+    return serialized(async () => {
+      const guard = architectureGuards.get(result);
+      architectureGuards.delete(result);
+      const current = () => guard && guard.signal === context.signal && !context.signal.aborted &&
+        guard.epoch === architectureEpoch && guard.policyVersion === policy.version &&
+        guard.lineageId === (lineageId ?? platform.snapshot().coverage.lineage?.id ?? modelProjectId) &&
+        !architectureUnavailable();
+      if (!current() || result.sourceRefs.length > 256 || context.artifacts.length > 64) return false;
+      const expected = new Map();
+      const sameVersion = (a, b) => a && b && a.hash === b.hash &&
+        a.generation === b.generation && a.status === b.status;
+      for (const value of [...context.artifacts, ...result.sourceRefs.map(ref => ({ ...ref, status: 'present' }))]) {
+        if (!knownArtifacts.has(value.artifactId) ||
+            expected.has(value.artifactId) && !sameVersion(expected.get(value.artifactId), value)) return false;
+        expected.set(value.artifactId, value);
+      }
+      if (expected.size > 256) return false;
+      const observed = new Map();
+      const refs = [...expected.keys()].map(artifactId => ({ artifactId }));
+      // Re-read all selected versions, including absence, and any extra
+      // membership support. Retain metadata only across these bounded reads.
+      for (let offset = 0; offset < refs.length; offset += 32) {
+        const captures = await evidence.reconcile({ refs: refs.slice(offset, offset + 32) });
+        registerArtifacts(captures);
+        for (const artifact of captures) observed.set(artifact.id, {
+          hash: artifact.hash, generation: artifact.generation, status: artifact.status,
+          exists: artifact.exists, complete: artifact.complete,
+        });
+        if (!current()) return false;
+      }
+      if ([...expected].some(([id, value]) => !sameVersion(value, observed.get(id)))) return false;
+      const missing = new Set(result.coverage.missingArtifactIds ?? []);
+      const selected = new Set(context.artifacts.map(value => value.artifactId));
+      for (const id of missing) {
+        const value = observed.get(id);
+        if (!selected.has(id) || value?.status !== 'missing' || value.hash !== null ||
+            value.exists !== false || value.complete !== true) return false;
+      }
+      const withdrawn = new Set(result.coverage.withdrawnEntityIds ?? []);
+      const model = platform.snapshot();
+      const entities = new Map(model.entities.map(value => [value.id, value]));
+      if ([...withdrawn].some(id => !missing.has(entities.get(id)?.artifactId))) return false;
+      const affected = result.affectedEntityIds.filter(id => !withdrawn.has(id));
+      let omitted = 0;
+      if (affected.length || result.interpretations.length) {
+        const replacement = platform.model.replaceInterpretations(ARCHITECTURE_NAMESPACE, result.interpretations, {
+          affectedEntityIds: affected, sourceRefs: result.sourceRefs,
+        });
+        if (!replacement.accepted) return false;
+        omitted = Math.max(0, result.interpretations.length - replacement.retained);
+      }
+      if (missing.size) {
+        // Present-source guards cannot prove deletion. The serialized reread
+        // above authorizes this clear, even when deleted anchors were evicted.
+        const cleared = platform.model.replaceInterpretations(ARCHITECTURE_NAMESPACE, [], {
+          affectedEntityIds: [...withdrawn], artifactIds: [...missing],
+        });
+        if (!cleared.accepted) return false;
+      }
+      return omitted ? { accepted: true, omitted } : true;
+    });
+  }
+
   function artifactMetadata(artifact) {
     const relative = artifact.relativePath;
     return {
@@ -429,6 +549,7 @@ export function createPipeline({
       }
     }
     platform.observeArtifacts(artifacts, event);
+    if (changed.length) architecture.observe(changed);
     return changed;
   }
 
@@ -1074,6 +1195,7 @@ export function createPipeline({
   function setPaused(value) {
     const wasPaused = paused;
     paused = Boolean(value);
+    if (wasPaused !== paused) architectureEpoch++;
     if (!wasPaused && paused) {
       for (const job of classificationQueue.splice(0)) {
         deferClassification(job.event, job.candidates);
@@ -1086,6 +1208,7 @@ export function createPipeline({
       serialized(flushDeferred).catch(() => { dropped++; })
         .finally(() => { resumeScheduled = false; });
     }
+    architecture.wake();
     notify();
     return getState();
   }
@@ -1095,6 +1218,8 @@ export function createPipeline({
       if (closed || lineage.id === lineageId) return;
       platform.observeLineage(lineage);
       lineageId = lineage.id;
+      architectureEpoch++;
+      architecture.invalidate();
       completedClassifications.clear();
       for (const job of activeClassifications) job.controller.abort();
       for (const job of classificationQueue.splice(0)) {
@@ -1115,21 +1240,26 @@ export function createPipeline({
   }
 
   async function whenIdle() {
-    await serial;
-    await platform.whenIdle();
-    await serial;
-    while (tasks.size || classificationQueue.length) {
-      pumpClassifications();
-      await Promise.allSettled([...tasks]);
+    do {
       await serial;
-    }
-    await platform.whenIdle();
-    await serial;
+      await platform.whenIdle();
+      await serial;
+      while (tasks.size || classificationQueue.length) {
+        pumpClassifications();
+        await Promise.allSettled([...tasks]);
+        await serial;
+      }
+      await platform.whenIdle();
+      await architecture.whenIdle();
+      await serial;
+    } while (tasks.size || classificationQueue.length || platform.stats().queued || platform.stats().active);
   }
 
   async function close() {
     if (closed) return;
     closed = true;
+    architectureEpoch++;
+    const architectureClosed = architecture.close();
     deferredWork.clear();
     for (const job of classificationQueue.splice(0)) {
       skipJob(job, 'pipeline_closed');
@@ -1138,11 +1268,14 @@ export function createPipeline({
     for (const job of activeClassifications) job.controller.abort();
     decisionService?.close?.();
     await platform.close();
+    await architectureClosed;
     await whenIdle();
   }
 
   return {
     ingest, getState, reconcile, observeLineage, setPaused, selectSession, whenIdle, close,
+    getArchitectureStatus: () => architecture.status(),
+    discoverArchitecture: () => architecture.request(),
     getModelState: options => platform.snapshot(options),
     createCheckpoint: options => platform.checkpoint(options),
     model: platform.model,

package/runtime/visualizers/c4.mjs

@@ -1,4 +1,4 @@
-import { structureScene, aggregateEdges, sceneKind, emptyScene } from './structure.mjs';
+import { structureScene, aggregateEdges, sceneKind, emptyScene, entityIndex } from './structure.mjs';
 
 const LEVELS = {
   context: new Set(['system', 'external_system', 'actor', 'person', 'context']),
@@ -11,40 +11,142 @@ const KINDS = { application: 'service', container: 'service', datastore: 'datast
 export function c4Scene(model, settings = {}) {
   if (settings.level === 'code') return structureScene(model, settings, { flat: true });
   const level = LEVELS[settings.level] || LEVELS.applications;
-  const byId = new Map(model.entities.map(entity => [entity.id, entity]));
-  const boundaries = model.interpretations.filter(value =>
-    level.has(value.kind) && value.validity === 'current' && value.support === 'supported' &&
+  const { byId, children: sourceChildrenById } = entityIndex(model);
+  const supported = model.interpretations.filter(value =>
+    value.validity === 'current' && value.support === 'supported' &&
     value.classification === 'accepted' && value.sourceRefs?.length &&
-    value.entityIds?.some(id => byId.has(id)));
-  if (!boundaries.length) {
+    value.entityIds?.some(id => byId.has(id))).map(value => ({
+      ...value, members: value.entityIds.filter(id => byId.has(id)), memberSet: new Set(value.entityIds),
+    }));
+  if (!supported.some(value => level.has(value.kind))) {
     const scene = structureScene(model, { ...settings, depth: 0 });
     scene.coverage.label = 'Source scopes; application and responsibility boundaries unknown';
     scene.groups.forEach(group => { group.style = 'unknown'; });
     scene.nodes.forEach(node => { node.style = 'unknown'; });
     return scene;
   }
-  const scene = emptyScene(), represented = new Set();
-  for (const boundary of boundaries.slice(0, 63)) {
-    const members = boundary.entityIds.filter(id => byId.has(id)).slice(0, 256);
-    members.forEach(id => represented.add(id));
-    const expanded = settings.expanded?.includes(members[0]);
+  const applications = supported.filter(value => LEVELS.applications.has(value.kind));
+  const components = supported.filter(value => LEVELS.components.has(value.kind));
+  const parents = new Map(), children = new Map();
+  const explicitParents = new Map();
+  for (const membership of supported.filter(value =>
+    value.namespace === 'graphlin.architecture' && value.kind === 'architecture_membership')) {
+    const anchors = membership.entityIds;
+    if (anchors.length !== 2 || anchors[0] === anchors[1] ||
+      anchors.some(id => byId.get(id)?.validity !== 'current')) continue;
+    const parent = applications.filter(value => value.kind === 'application' &&
+      value.entityIds.length === 1 && anchors.includes(value.entityIds[0]));
+    const child = components.filter(value => value.entityIds.length === 1 && anchors.includes(value.entityIds[0]));
+    if (parent.length !== 1 || child.length !== 1 || parent[0].entityIds[0] === child[0].entityIds[0]) continue;
+    if (!explicitParents.has(child[0].id)) explicitParents.set(child[0].id, new Set());
+    explicitParents.get(child[0].id).add(parent[0].id);
+  }
+  for (const component of components) {
+    // Host architecture uses small, source-backed anchor pairs. Other
+    // interpretations can still establish containment by a unique strict subset.
+    const explicit = explicitParents.get(component.id);
+    const candidates = explicit ? applications.filter(value => explicit.has(value.id))
+      : component.namespace === 'graphlin.architecture' ? []
+      : applications.filter(application => component.memberSet.size < application.memberSet.size &&
+        [...component.memberSet].every(id => application.memberSet.has(id)));
+    if (candidates.length !== 1) continue;
+    const parent = candidates[0];
+    parents.set(component.id, parent.id);
+    if (!children.has(parent.id)) children.set(parent.id, []);
+    children.get(parent.id).push(component);
+  }
+  const descendants = anchor => {
+    const pending = [anchor], visited = new Set();
+    for (let index = 0; index < pending.length; index++) {
+      const id = pending[index];
+      if (visited.has(id)) continue;
+      visited.add(id);
+      pending.push(...(sourceChildrenById.get(id) || []));
+    }
+    return [...visited];
+  };
+  for (const boundary of [...applications, ...components]) {
+    if (boundary.namespace === 'graphlin.architecture' && boundary.members.length === 1)
+      boundary.members = descendants(boundary.members[0]);
+  }
+  for (const application of applications) {
+    // This is a bounded display projection, not a persisted union of evidence
+    // references or a new application-membership claim.
+    application.members = [...new Set([...application.members,
+      ...(children.get(application.id) || []).flatMap(component => component.members)])];
+  }
+  const roots = level === LEVELS.components
+    ? [...applications.filter(value => children.has(value.id)), ...components.filter(value => !parents.has(value.id))]
+    : supported.filter(value => level.has(value.kind));
+  const expanded = new Set(settings.expanded || []), collapsed = new Set(settings.collapsed || []);
+  const legacyKeys = new Map();
+  for (const boundary of supported.filter(value => value.kind !== 'architecture_membership'))
+    legacyKeys.set(boundary.members[0], (legacyKeys.get(boundary.members[0]) || 0) + 1);
+  const query = (settings.query || '').toLowerCase(), kinds = settings.kinds ? new Set(settings.kinds) : null;
+  const matching = id => {
+    const entity = byId.get(id);
+    return entity && (!query || `${entity.label} ${entity.qualifiedName || ''}`.toLowerCase().includes(query)) &&
+      (!kinds || kinds.has(entity.kind));
+  };
+  function isExpanded(id, members, defaultOpen = false) {
+    if ((query || kinds) && members.some(matching)) return true;
+    if (collapsed.has(id)) return false;
+    if (expanded.has(id)) return true;
+    // Older in-memory settings used a group's first source member. Keep that
+    // fallback only when it identifies a single interpretation.
+    const legacy = members[0];
+    if (legacyKeys.get(legacy) === 1) {
+      if (collapsed.has(legacy)) return false;
+      if (expanded.has(legacy)) return true;
+    }
+    return defaultOpen;
+  }
+  const scene = emptyScene(), represented = new Set(), emitted = new Set(), sourceNodes = new Set();
+  let truncated = false;
+  function sourceChildren(members, parentId, excluded = new Set()) {
+    for (const id of members) {
+      if (excluded.has(id) || sourceNodes.has(id)) continue;
+      const entity = byId.get(id);
+      if (entity.validity === 'retracted') continue;
+      if (scene.nodes.length + scene.groups.length >= 255) { truncated = true; break; }
+      const style = entity.validity !== 'current' ? 'stale' :
+        entity.classification === 'tentative' ? 'tentative' : 'default';
+      scene.nodes.push({ id, entityId: id, label: entity.label, kind: sceneKind(entity.kind), parentId, style });
+      sourceNodes.add(id);
+    }
+  }
+  function addBoundary(boundary, parentId) {
+    if (emitted.has(boundary.id)) return;
+    if (scene.groups.length >= 63 || scene.nodes.length + scene.groups.length >= 255) { truncated = true; return; }
+    emitted.add(boundary.id);
+    const members = boundary.members.slice(0, 256), id = `c4.${boundary.id}`;
+    boundary.members.forEach(member => represented.add(member));
+    if (boundary.members.length > members.length) truncated = true;
+    const nested = level === LEVELS.context ? [] : children.get(boundary.id) || [];
+    const open = isExpanded(id, members, boundary.kind === 'application' || nested.length > 0);
     scene.groups.push({
-      id: `c4.${boundary.id}`, entityIds: members, label: boundary.label, collapsed: !expanded,
+      id, entityIds: members, label: boundary.label, collapsed: !open,
       kind: sceneKind(KINDS[boundary.kind] || 'group'), membershipId: boundary.id,
+      ...(parentId ? { parentId } : {}),
     });
-    if (expanded) for (const id of members) {
-      if (scene.nodes.length + scene.groups.length >= 255 || scene.nodes.some(node => node.entityId === id)) continue;
-      const entity = byId.get(id);
-      scene.nodes.push({ id, entityId: id, label: entity.label, kind: sceneKind(entity.kind), parentId: `c4.${boundary.id}` });
+    if (open) {
+      for (const child of nested) addBoundary(child, id);
+      const nestedMembers = new Set(nested.filter(child => emitted.has(child.id)).flatMap(child => child.members));
+      sourceChildren(members, id, nestedMembers);
     }
   }
-  const unknown = model.entities.filter(entity => !represented.has(entity.id)).slice(0, 256);
-  if (unknown.length) scene.groups.push({
-    id: 'c4.unknown', entityIds: unknown.map(entity => entity.id), label: 'Responsibility unknown',
-    kind: 'unknown', collapsed: true, style: 'unknown',
-  });
-  scene.coverage = { shown: scene.groups.length, total: model.entities.length,
-    truncated: represented.size + unknown.length < model.entities.length || boundaries.length > 63,
+  for (const boundary of roots) addBoundary(boundary);
+  const unknown = model.entities.filter(entity => !represented.has(entity.id));
+  if (unknown.length) {
+    const members = unknown.slice(0, 256).map(entity => entity.id), open = isExpanded('c4.unknown', members);
+    scene.groups.push({
+      id: 'c4.unknown', entityIds: members, label: 'Responsibility unknown',
+      kind: 'unknown', collapsed: !open, style: 'unknown',
+    });
+    if (open) sourceChildren(members, 'c4.unknown');
+    if (unknown.length > members.length) truncated = true;
+  }
+  scene.coverage = { shown: scene.groups.length + scene.nodes.length, total: model.entities.length, truncated,
     label: 'Supported interpretations; source does not establish runtime hosting' };
   return aggregateEdges(model, scene);
 }

package/runtime/web/app.js

@@ -2246,7 +2246,7 @@ export function startViewer() {
           'aria-expanded': String(!node.collapsed), transform: `translate(${node.width - 33} 10)` });
         toggle.append(svgElement('rect', { width: 24, height: 24, rx: 4 }),
           svgElement('text', { x: 12, y: 18, 'text-anchor': 'middle' }, node.collapsed ? '+' : '−'));
-        const toggleGroup = event => { event.stopPropagation(); platform.toggle(node.entityId, node.collapsed); };
+        const toggleGroup = event => { event.stopPropagation(); platform.toggle(node.id, node.collapsed); };
         toggle.addEventListener('click', toggleGroup);
         toggle.addEventListener('keydown', event => {
           if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); toggleGroup(event); }

package/runtime/web/index.html

@@ -131,6 +131,7 @@
                 <option value="context">Context</option><option value="applications" selected>Applications / datastores</option>
                 <option value="components">Components</option><option value="code">Code</option>
               </select></label>
+              <button id="architecture-discover" type="button" aria-describedby="architecture-status" hidden>Discover architecture</button>
               <label id="baseline-label" hidden>Baseline <select id="task-baseline"><option value="">Choose checkpoint</option></select></label>
               <button id="baseline-create" type="button" hidden>Set baseline now</button>
               <label>Position <select id="model-position"><option value="">Live</option></select></label>
@@ -142,6 +143,7 @@
                 <button id="analysis-access" type="button">Manage access</button>
               </div>
             </div>
+            <p id="architecture-status" class="architecture-status" role="status" aria-live="polite" hidden></p>
             <p class="view-status" id="view-status" role="status" hidden></p>
             <section class="extension-access" id="extension-access" aria-label="Visualizer data access" hidden>
               <p id="extension-access-description"></p>

package/runtime/web/platform.js

@@ -5,13 +5,38 @@ import { createExtensionFrame } from './extension-frame.js';
 import { DATA_FIELDS, extensionId, digest, id as validId } from '../extensions/contracts.mjs';
 import { filterScene } from './scene.js';
 
+const DISCOVERY_STATES = ['idle', 'waiting', 'queued', 'running', 'complete', 'partial', 'unavailable'];
+const DISCOVERY_BLOCKED = ['source_consent_required', 'missing_key', 'no_source', 'paused', 'unsupported_service', 'endpoint_unavailable'];
+const DISCOVERY_REASONS = {
+  source_consent_required: 'Architecture discovery needs source-transmission consent. Enable source mode for this project in Graphlin setup.',
+  missing_key: 'Configure a classification service key in Graphlin setup to discover architecture.',
+  no_source: 'No source evidence is available yet. Let Graphlin inspect project files, then try again.',
+  paused: 'Classification is paused. Resume classification to discover architecture.',
+  analysis_failed: 'Architecture discovery could not finish. Try again; supported boundaries remain available.',
+  unsupported_service: 'The configured classification service does not support architecture discovery.',
+  source_changed: 'Source changed during discovery. Boundaries will be checked against current evidence.',
+  partial_coverage: 'Some evidence is unavailable. The shown boundaries cover only inspected evidence.',
+  none_supported: 'No supported application or component boundaries were found. Source scopes remain available.',
+  endpoint_unavailable: 'Architecture discovery requires a newer local service.',
+  request_failed: 'Could not check architecture discovery. Reconnect to the local service or try again.',
+};
+function discoveryStatus(value) {
+  if (!value || !DISCOVERY_STATES.includes(value.status)) throw new Error('invalid_architecture_status');
+  const result = { status: value.status, reason: typeof value.reason === 'string' ? value.reason : '' };
+  for (const name of ['applications', 'components', 'pending', 'inspected', 'total']) {
+    if (Number.isSafeInteger(value[name]) && value[name] >= 0 && value[name] <= 1_000_000) result[name] = value[name];
+  }
+  return result;
+}
+
 export function createViewPlatform({ document, request, onView, onSelect, onFollow = () => {},
-  createFrame = createExtensionFrame, grantPollMs = 2000 }) {
+  createFrame = createExtensionFrame, grantPollMs = 2000, architecturePollMs = 2000 }) {
   const $ = id => document.getElementById(id);
   let model, active = 'graphlin.code', instance, installed = [], generation = 0, closed = false;
   let projectionController;
   let analysisBusy = false;
   let grantWatch;
+  let architectureWatch, architectureState, architectureProject, architectureBusy = false, suspended = false;
   let selection = {}, canonicalSelection = null, follow = true, query = '', kinds = null, focusEntityId = null;
   const settings = new Map(), listeners = [];
   const ownSettings = () => {
@@ -33,9 +58,82 @@ export function createViewPlatform({ document, request, onView, onSelect, onFoll
     $('view-retry').hidden = !message;
   }
   function dispose() {
+    stopArchitecture();
     if (grantWatch) { clearTimeout(grantWatch.timer); grantWatch.controller?.abort(); grantWatch = null; }
     instance?.dispose(); instance = null;
   }
+  const architectureLive = () => !closed && !suspended && model && active === 'graphlin.c4' && !selection.checkpoint;
+  function stopArchitecture() {
+    if (architectureWatch) {
+      clearTimeout(architectureWatch.timer);
+      clearTimeout(architectureWatch.deadline);
+      architectureWatch.controller?.abort();
+      architectureWatch = null;
+    }
+    architectureBusy = false;
+  }
+  function renderArchitecture() {
+    const shown = active === 'graphlin.c4';
+    $('architecture-discover').hidden = !shown;
+    $('architecture-status').hidden = !shown;
+    const state = architectureState;
+    $('architecture-discover').disabled = !architectureLive() || architectureBusy ||
+      ['queued', 'running'].includes(state?.status) || DISCOVERY_BLOCKED.includes(state?.reason);
+    $('architecture-discover').setAttribute('aria-busy', String(architectureBusy));
+    if (!shown) return;
+    if (selection.checkpoint) {
+      $('architecture-status').textContent = 'Recorded architecture. Return to Live to discover current boundaries.';
+      return;
+    }
+    if (!state) { $('architecture-status').textContent = 'Checking architecture discovery…'; return; }
+    const messages = {
+      idle: 'Ready to discover application and component boundaries for this project.',
+      waiting: 'Waiting for source evidence before architecture discovery can continue.',
+      queued: 'Architecture discovery queued.',
+      running: 'Discovering architecture…',
+      complete: 'Architecture discovery complete.',
+      partial: 'Architecture is partly discovered; some boundaries remain unknown.',
+      unavailable: 'Architecture discovery is unavailable. Check project source settings and the classification service.',
+    };
+    const counts = ['applications', 'components'].filter(name => state[name] !== undefined)
+      .map(name => `${state[name]} ${name}`);
+    if (state.inspected !== undefined && state.total !== undefined) counts.push(`${state.inspected} of ${state.total} inspected`);
+    if (state.pending > 0) counts.push(`${state.pending} pending`);
+    $('architecture-status').textContent = [
+      DISCOVERY_REASONS[state.reason] || messages[state.status], counts.join(' · '),
+    ].filter(Boolean).join(' ');
+  }
+  async function refreshArchitecture(watch, manual = false) {
+    const controller = new AbortController();
+    watch.controller = controller;
+    const deadline = watch.deadline = setTimeout(() => controller.abort(), 8000);
+    try {
+      const result = await request(manual ? '/api/architecture/discover' : '/api/architecture',
+        { signal: controller.signal, ...(manual ? { method: 'POST', body: '{}' } : {}) });
+      if (architectureWatch !== watch || !architectureLive()) return;
+      architectureState = discoveryStatus(manual && !DISCOVERY_STATES.includes(result?.status) ? { status: 'queued' } : result);
+    } catch (error) {
+      if (architectureWatch !== watch || !architectureLive()) return;
+      architectureState = { status: 'unavailable', reason: error.status === 404 ? 'endpoint_unavailable' : 'request_failed' };
+    } finally {
+      clearTimeout(deadline);
+      if (architectureWatch === watch && architectureLive()) {
+        architectureBusy = false;
+        renderArchitecture();
+        if (architectureState?.reason !== 'endpoint_unavailable')
+          watch.timer = setTimeout(() => refreshArchitecture(watch), architecturePollMs);
+      }
+    }
+  }
+  function syncArchitecture() {
+    if (!architectureLive()) stopArchitecture();
+    else if (!architectureWatch) {
+      if (architectureProject !== model.projectId) { architectureState = null; architectureProject = model.projectId; }
+      architectureWatch = {};
+      void refreshArchitecture(architectureWatch);
+    }
+    renderArchitecture();
+  }
   function watchGrant(row) {
     if (grantWatch?.instance === instance) return;
     const watch = { instance, id: row.id, digest: row.digest, grant: JSON.stringify(row.grant), timer: null };
@@ -83,6 +181,7 @@ export function createViewPlatform({ document, request, onView, onSelect, onFoll
     for (const option of $('visualizer').children) option.disabled = !model && option.value !== 'graphlin.code';
     $('view-context').hidden = !model;
     $('c4-level-label').hidden = active !== 'graphlin.c4';
+    syncArchitecture();
     $('baseline-label').hidden = active !== 'graphlin.changes';
     $('baseline-create').hidden = active !== 'graphlin.changes';
     $('baseline-create').disabled = Boolean(selection.checkpoint);
@@ -269,6 +368,15 @@ export function createViewPlatform({ document, request, onView, onSelect, onFoll
   listen('visualizer', 'change', () => choose($('visualizer').value));
   listen('view-retry', 'click', () => { dispose(); void client.open(selection); });
   listen('c4-level', 'change', () => { ownSettings().level = $('c4-level').value; void project(false, true); });
+  listen('architecture-discover', 'click', () => {
+    if (!architectureLive() || $('architecture-discover').disabled) return;
+    stopArchitecture();
+    architectureBusy = true;
+    architectureState = { status: 'queued' };
+    architectureWatch = {};
+    renderArchitecture();
+    void refreshArchitecture(architectureWatch, true);
+  });
   listen('task-baseline', 'change', () => { ownSettings().baseline = $('task-baseline').value; void project(false, true); });
   listen('baseline-create', 'click', async () => {
     if (selection.checkpoint) return;
@@ -314,7 +422,7 @@ export function createViewPlatform({ document, request, onView, onSelect, onFoll
   });
   controls();
   return {
-    async start() { if (await client.open(selection)) await catalogue(); },
+    async start() { suspended = false; if (await client.open(selection)) await catalogue(); },
     choose,
     filter(nextQuery, nextKinds) { query = nextQuery; kinds = nextKinds; void project(false, true); },
     selected(id) { canonicalSelection = id; },
@@ -329,7 +437,7 @@ export function createViewPlatform({ document, request, onView, onSelect, onFoll
       void project(false, true);
     },
     close() { closed = true; generation++; projectionController?.abort(); client.close(); dispose(); listeners.forEach(remove => remove()); },
-    suspend() { generation++; projectionController?.abort(); client.suspend(); dispose(); },
+    suspend() { suspended = true; generation++; projectionController?.abort(); client.suspend(); dispose(); },
     get active() { return active; },
     get model() { return model; },
     get selection() { return selection; },

package/runtime/web/style.css

@@ -20,6 +20,8 @@
 .view-context select, .view-context button { max-width: 210px; font-size: 11px; min-height: 28px; padding: 3px 7px; color: var(--ink); background: var(--white); border: 1px solid var(--line); border-radius: 5px; }
 #scope-breadcrumbs { display: flex; flex-wrap: wrap; gap: 4px; flex: 1; }
 .view-status, .view-coverage { padding: 4px 12px; font-size: 11px; color: var(--muted); }
+.architecture-status { padding: 5px 12px; font-size: 11px; color: var(--muted); border-bottom: 1px solid var(--line); }
+.view-context #architecture-discover { color: var(--blue); border-color: var(--blue); }
 .extension-access { padding: 12px; border-bottom: 1px solid var(--line); background: var(--paper); font-size: 12px; }
 .extension-access p { max-width: 78ch; margin-bottom: 8px; }
 #extension-fields { display: flex; flex-wrap: wrap; gap: 12px; margin-bottom: 8px; }

package/scripts/control.mjs

@@ -39,7 +39,7 @@ async function handle(line) {
     const supported = ['2024-11-05', '2025-03-26', '2025-06-18'];
     return result({ protocolVersion: supported.includes(message.params?.protocolVersion) ? message.params.protocolVersion : '2025-06-18',
       capabilities: { tools: { listChanged: false } },
-      serverInfo: { name: 'graphlin', version: '0.2.0' },
+      serverInfo: { name: 'graphlin', version: '0.2.1' },
       instructions: 'Controls only. Passive host hooks provide observations when separately activated. No drawing calls after each action.' });
   }
   if (message.method === 'ping') return result({});