Skip to content

Roadmap: deferred architecture and engineering-health capabilities #1

Open

Description

@jdylanmc

This was generated by AI during triage.

Current status (2026-09-29)

Inspected baseline: main@b64bb2f.

Status: deferred roadmap; not an implementation-ready umbrella.

Current main delivers the Archify storybook, default source-grounded repository exploration (PR #79), pristine Archify 3.0.0 integration (PR #80), and the published npm CLI-plus-skills toolbelt (PR #81). The retired WebGL explorer and its historical performance promises are not current product requirements. The maintained intent remains the product specification, with historical issue text preserved below.

Remaining roadmap

  • Additional language adapters beyond TypeScript/JavaScript.

  • Broader source-grounded application-logic extraction, engineering-health/history overlays, agent-activity visibility, and editor/ecosystem integrations, each requiring bounded scope and acceptance criteria.

  • Any new exploration capability must extend the current Archify shell rather than silently restore the retired WebGL surface.

Current backlog map

No new implementation, orchestration, performance guarantee, or approval of deferred scope is implied.

Previous issue text and original requirements (historical; current disposition is above)

Reconciled status (2026-09-27)

Inspected baseline: main@c8e22ec. Maintained intent: docs/product-spec.md.

Disposition: remains open for the scope below.

Keep open only as a deferred roadmap, not the active implementation specification or an assertion that the original product is complete. The maintained product intent is now docs/product-spec.md, migrated by #78; the shipped product is the persistent Archify storybook shell from #71.

Remaining scope

  • Additional language adapters beyond the supported TypeScript/JavaScript scanner.
  • Broader source-grounded application-logic extraction, engineering-health/history overlays, agent-activity visibility, and editor/ecosystem integrations from the historical roadmap.
  • Any future exploration or semantic-zoom experience must be reconciled with Replace the retired WebGL explorer with source-grounded Archify exploration #70 and the maintained Archify product direction before implementation; this issue does not authorize restoring the retired WebGL explorer.

Readiness and dependencies

Deferred vision requiring bounded discovery and separately agreed acceptance criteria. Historical Phase 1 work and original renderer/performance goals below are not a current ready-for-agent queue. Keep genuinely unimplemented roadmap scope visible rather than closing it as delivered.

Merged delivery evidence: #17, #30, #33, #71, #78. These merge commits are ancestors of the inspected main revision.

Current source and regression evidence:

Existing exact-main CI is successful. This reconciliation inspected current code, committed regression coverage and merged history; it does not claim a new test run, manual walkthrough, visual acceptance, cross-machine experiment, or approval of paused work.

Historical issue scope (preserved; current disposition and readiness are above)

Current status (2026-09-19)

The source-checkout Phase 1 explorer is delivered. This issue remains the historical product vision, not an assertion that every Phase 2/3 feature is implemented or currently scheduled. The current product direction and next implementation scope are the Storybook-for-architecture MVP in #40.

Evidence: PR #17; PR #30; PR #33; #40.

Original issue text is preserved below. This update records current delivery status without erasing historical decisions. #40 governs the next architecture-story MVP; it does not imply that the broader historical roadmap is implemented.


Product Requirements Document

Project: TOPO-CODE
Subtitle: A Multi-Scale, Fractal Code Visualizer and Architectural Map
Status: Draft

Summary

Topocode reimagines complex codebases as interactive topographical landscapes. Traditional Unified Modeling Language (UML) diagrams generate static, unreadable "spaghetti charts" that quickly go out of date. Topocode automatically scans repository structures to build a zoomable, multi-layered architectural map.

By treating code like a digital map, developers can move from a high-level system topology down to individual class relationships while preserving their architectural context.

Topocode is delivered through scripts and agent skills. It creates a .topo/ directory in the target repository for generated graph data, configuration, caches, and optional project-specific metadata. Teams may commit selected .topo/ artifacts or keep the directory local. Like Storybook, Topocode hosts a small interactive local website for exploring the generated map.

Philosophy

Software development has entered an era in which coding agents can make tactical changes at far greater velocity than a human can manually produce or review them. The human architect's highest-leverage role is no longer typing every change; it is maintaining strategic direction, recognizing system-wide consequences, and keeping autonomous work aligned with product and architectural intent.

TOPO-CODE exists to plug the human directly into that control loop.

It is an architect's dashboard for picking apart a codebase: a shared visual surface where source architecture, agent activity, repository health, and continuous integration and continuous delivery (CI/CD) health can be inspected together. Instead of presenting one canonical diagram, TOPO-CODE offers multiple coordinated views of the same evolving system, including topographical maps, Unified Modeling Language diagrams, dependency graphs, delivery overlays, and focused slices.

The central design principle is to use tactical techniques to make strategic decisions easier. Agents, parsers, scripts, graph algorithms, and automated integrations perform the high-volume tactical work of collecting evidence and maintaining an up-to-date model. The human uses that model to understand tradeoffs, set direction, identify risk, and decide what should happen next. TOPO-CODE should automate observation and synthesis without pretending to replace architectural judgment.

The product should help a human answer:

  • What is this system, and how is it changing?
  • Where are agents currently making tactical changes?
  • Do those changes follow the intended strategic and architectural direction?
  • Which parts of the repository or delivery pipeline are becoming unhealthy?
  • What context should the human inspect before authorizing the next action?

Value

  • Codebase zoomability: Semantic zoom from an ecosystem overview to component-level details.
  • Language-agnostic parsing: Abstract Syntax Tree (AST) and Language Server Protocol (LSP) integrations map architecture across languages.
  • Context preservation: Focused two-dimensional slices isolate a subsystem without losing its location in the wider architecture.
  • Strategic agent oversight: Connect tactical agent activity to the architecture and goals it is intended to advance.
  • Unified engineering health: Correlate code structure with repository signals and CI/CD outcomes.
  • Multiple architectural lenses: Render the same graph through topographical, UML, dependency, ownership, and operational views.
  • Local-first security: Source parsing and graph synthesis happen on the developer's machine.
  • Repository portability: The .topo/ workspace makes configuration and selected generated artifacts easy to share when desired.

Users

Onboarding developer

Problem: Developers spend weeks reading text-heavy documentation to understand module boundaries and communication paths.

Outcome: A developer can visually identify major modules, interfaces, dependencies, and entry points.

Software architect

Problem: Architects cannot easily verify whether implementation matches intended architecture.

Outcome: An architect can inspect dependencies, detect circular references, evaluate domain boundaries, monitor repository and delivery health, and keep high-velocity agent changes aligned with strategic intent.

Architecture

[ Local repository / GitHub ]
              |
              v
1. Parse layer (Tree-sitter / LSP)
   Extract nodes and relationships
              |
              v
2. Graph engine
   Aggregate entities into nested architectural levels
              |
              v
3. Render layer (Canvas / WebGL)
   Render semantic zoom, contours, and 2D slices

Parse layer

  • Extract modules, imports, classes, functions, interfaces, and language-specific structures.
  • Start with one language and expose an adapter contract for future parsers.
  • Produce a unified graph JSON representation of entities and relationships.

Graph engine

  • Build a hierarchical abstraction tree from the raw graph.
  • Group entities into files, folders, packages, namespaces, and higher-level regions.
  • Compute metadata such as coupling, dependency degree, cyclomatic complexity, code coverage, and lines of code to determine visual elevation and health overlays.
  • Preserve deterministic layout identifiers so small code changes do not unnecessarily rearrange the map.

Render layer

  • Keep the production renderer undecided until comparative prototypes are measured.
  • Prototype a D3.js and Scalable Vector Graphics implementation for hierarchy, layout, zoom, selection, and transitions.
  • Prototype a WebGL implementation, potentially using PixiJS or Three.js, against the same graph data and interaction model.
  • Consider a hybrid in which D3.js computes layouts and interactions while Canvas or WebGL performs rendering.
  • Render nested regions, relationship edges, labels, elevation, and interaction states.
  • Support smooth layout and viewport transitions on standard developer laptops.

Repository workspace

Running Topocode against a repository creates:

.topo/
├── config.*
├── graph/
├── reports/
│   ├── inputs/
│   └── outputs/
├── cache/
└── metadata/

The exact schema and file formats remain to be designed. Generated caches should be safely ignorable, while stable configuration, normalized report inputs, and intentionally generated architectural metadata should be independently source-controllable.

Features

Semantic zoom and levels of detail

  • Level 0 — system overview: Show macro-containers, external application programming interfaces, and major subsystems as regions or islands.
  • Level 1 — module/package: Reveal folders, files, packages, and architectural layers.
  • Level 2 — class/component: Reveal properties, methods, inheritance, dependency injection, and other fine-grained relationships.

Two-dimensional slice isolator

  • Allow a user to isolate any selected module.
  • Fade unrelated regions into the background.
  • Show the selected module with its immediate upstream inputs and downstream outputs.

Application logic extraction

  • Extract an inspectable model of what the application does, not only how its files and types are connected.
  • Identify entry points, workflows, business rules, conditions, state transitions, data transformations, external calls, and side effects.
  • Connect derived logic back to exact source locations and architectural graph entities.
  • Present logic through coordinated views such as decision trees, state diagrams, sequence diagrams, data-flow diagrams, and narrative summaries.
  • Allow users to trace a behavior from an initiating event through decisions and effects across module boundaries.
  • Distinguish directly observed code structure from inferred behavior and attach confidence and evidence to every inference.
  • Support project-authored annotations that clarify intent or correct an incomplete extraction without modifying source code.
  • Keep the extracted logic model deterministic and versioned so architectural and behavioral changes can be reviewed over time.

Architectural contours

  • Render highly coupled or dependency-dense entities as prominent peaks.
  • Render decoupled utilities and standalone services as quieter peripheral regions.
  • Reserve visual channels for future overlays without encoding subjective quality judgments as facts.

Architect dashboard and coordinated views

  • Provide multiple synchronized views over the same underlying architectural graph.
  • Support topographical, UML, dependency, ownership, change-hotspot, and delivery-health views.
  • Preserve selection and navigation context when switching views.
  • Surface repository health signals such as cyclomatic complexity, dependency cycles, stale areas, code churn, code coverage, ownership gaps, and failing checks when data is available.
  • Allow complexity thresholds to be configured and inspected at function, class, file, module, and repository levels.
  • Show current complexity alongside historical trends so users can distinguish persistently complex code from regressions introduced by recent changes.
  • Ingest line, branch, and function coverage where supported and project those results onto the corresponding graph entities.
  • Allow coverage thresholds to be configured at file, module, and repository levels.
  • Show coverage gaps and trends without implying that high coverage alone establishes test quality.
  • Surface CI/CD health such as build status, test failures, deployment state, and recurring pipeline instability when integrations are configured.
  • Associate agent-authored changes and active work with the affected architectural regions.
  • Distinguish measured facts, inferred risks, and configured architectural intent.

Deterministic report pipeline

  • Define a versioned, deterministic contract for feeding scanner output, test results, coverage, complexity, CI/CD status, repository metadata, and other reports into TOPO-CODE.
  • Normalize tool-specific reports through adapters into a common internal schema.
  • Record source identity, schema version, collection time, repository revision, configuration, and adapter version with every input.
  • Produce reproducible dashboard data and report artifacts from the same repository revision, normalized inputs, and configuration.
  • Sort and serialize generated data deterministically so unchanged evidence does not create noisy diffs.
  • Validate inputs explicitly and report unsupported versions, malformed data, stale evidence, and conflicting sources.
  • Support both interactive dashboard consumption and generated artifacts suitable for source control, automation, or review.
  • Evaluate Mermaid diagrams, static images, HTML reports, graph JSON, and other output adapters without choosing a final presentation format yet.
  • Keep the normalized model independent of any single visualization or report format.

Roadmap

Phase 1 — Birds-eye minimum viable product

  • Parse a local TypeScript/JavaScript repository.
  • Create and manage the .topo/ workspace.
  • Generate a static unified graph JSON document.
  • Host a local interactive website.
  • Render an interactive file and directory map.
  • Support click-to-expand navigation instead of continuous semantic zoom.

Phase 2 — Semantic zoom

  • Add high-performance continuous zoom.
  • Add the two-dimensional slice isolator.
  • Add an initial application-logic extraction view for entry points, control flow, state transitions, and side effects.
  • Add parser adapters for Python, Java, and C#.

Phase 3 — Ecosystem integration

  • Add a Git hotspot overlay that visualizes frequently modified files as active architectural volcanoes.
  • Add repository and CI/CD health integrations and overlays.
  • Add agent activity overlays that connect active or proposed changes to affected architectural regions.
  • Add coordinated UML and operational dashboard views backed by the shared graph.
  • Add bidirectional editor integration for Visual Studio Code and JetBrains integrated development environments.

Non-functional requirements

  • Parse and initially map a 100,000-line repository in under 30 seconds.
  • Maintain more than 50 frames per second during rapid zooming on a standard developer laptop.
  • Keep parsing and graph synthesis local by default.
  • Avoid uploading source code or derived proprietary structure without explicit user action.
  • Produce deterministic, incrementally updateable output where practical.

Phase 1 acceptance criteria

  • A user can run one documented command from a supported TypeScript/JavaScript repository.
  • The command initializes .topo/ without overwriting user-authored files.
  • The scanner emits a versioned graph JSON document containing stable node identifiers and typed edges.
  • A documented command ingests one or more versioned report fixtures and emits normalized, deterministic dashboard data.
  • Running the report pipeline twice with identical source revision, inputs, and configuration produces byte-for-byte equivalent deterministic artifacts, excluding explicitly documented volatile metadata.
  • The local website starts from a documented command and displays the scanned repository.
  • A user can expand and collapse regions and inspect basic file dependency details.
  • Re-running the scanner after a small source change preserves unaffected node identifiers and layout positions.
  • Documentation explains which .topo/ paths are safe to commit and which should be ignored.
  • A representative fixture demonstrates the full scan-to-render workflow.
  • D3.js/SVG and WebGL prototypes are evaluated against identical small, medium, and large graph fixtures.
  • The renderer decision records measured frame rate, interaction latency, memory use, implementation complexity, accessibility, and visual fidelity.

Open design questions

  1. What is the versioned graph JSON schema for nodes, edges, containment, metrics, and source locations?
  2. Which .topo/ artifacts are authoritative, generated, cached, or safe to commit?
  3. Which deterministic layout strategy best prevents structural shifts after small code changes?
  4. How should slices represent extreme circular dependencies without visual clutter?
  5. What keyboard, mouse, and accessibility controls should govern navigation and slice isolation?
  6. Which normalized report schemas and adapter contracts support deterministic ingestion without coupling the core to individual tools?
  7. Which generated outputs should be interactive, source-controllable, or human-readable, and should Mermaid be one of the standard adapters?
  8. How should TOPO-CODE represent extracted application logic across static analysis, runtime evidence, and human-authored intent without overstating inferred behavior?

Initial technical decisions to make

  • Select the implementation language and package/runtime model.
  • Select the TypeScript/JavaScript parser.
  • Define the parser adapter interface and graph schema.
  • Define the behavioral model for workflows, decisions, state transitions, data flow, external calls, side effects, evidence, and confidence.
  • Define the report manifest, normalized health schema, adapter interface, and reproducibility rules.
  • Build comparable D3.js/SVG and WebGL rendering spikes before selecting the production rendering backend and graph layout strategy.
  • Define .topo/ initialization, ignore rules, and migration/versioning behavior.

Activity

  1. jdylanmc commented on Aug 26, 2026

    @jdylanmc
    OwnerAuthor

    Design decision: how human notes anchor to code

    Decided: annotations, evidence pointers, and any human-authored note anchor as a
    triple — (path, symbol, content pattern) — degrading in that order. Never a line number.

    Why

    This came out of reviewing code-tour,
    which pins prose to code using three strategies (line, pattern regex, ref commit pin)
    and ships a validator that only checks the current working tree. It has no answer for drift.
    That gap is directly our problem too, so it was measured rather than argued.

    Fixture: mermaid, baseline 90a35ca00 → HEAD 5d90f8cf4 (400 commits; tree churn 1491 added /
    311 modified / 106 deleted / 269 renamed). 400 anchors sampled at random from .ts/.js files
    present at the baseline, then replayed against HEAD.

    anchor survives given the file survived
    path 90.2% —
    symbol declaration — 99.7%
    pattern (exact line content) 89.0% 98.6%
    line number 79.2% 87.8%

    Line numbers are the only weak anchor. Content-based anchoring costs almost nothing beyond
    file survival. CodeTour's schema defaults to line and treats pattern as the escape hatch,
    which is inverted for durability.

    Two qualifications

    • pattern alone is ambiguous. 10.7% of pattern survivors matched more than one line in
      the file. Pattern needs symbol scope to disambiguate; it is not a standalone anchor.
    • The 99.7% symbol figure was checked for being an artifact. Matching a short identifier
      (id, data) anywhere in a file would trivially succeed, so it was re-run requiring an actual
      declaration site of that name. Strict and loose agree exactly — 313/314, 0pp difference.

    Consequence for an existing decision

    rename = rebuild holds, and now has a number behind it. Only 26% of path-identity loss
    was rename (10 of 39); the rest were genuine deletions. 9 of those 10 renames kept the anchor
    content intact. Cost of the rule is roughly 2.5% of anchors per 400 commits, which is cheap
    enough to keep the simpler identity model.

    Harnesses: anchors.py (measurement) and anchors2.py (self-check + rename attribution).
    Full event trail is in .skill-log/ as of 6c84bb8.

  2. jdylanmc commented on Aug 26, 2026

    @jdylanmc
    OwnerAuthor

    Decision index

    This PRD is the vision and governs everything. The open decisions it implies have been split into their own issues, so each one can be resolved with evidence attached rather than being re-derived from this document.

    Foundation

    Rendering and scale

    Human layer

    Delivery

    Not yet split out: report ingestion pipeline, health overlays (churn × complexity, CRAP). Deliberately deferred.

    Each issue records what is already settled, what was measured, and what is still open. The append-only chronicle in .skill-log/ remains the authority on how each decision was reached.

  3. jdylanmc commented on Sep 13, 2026

    @jdylanmc
    OwnerAuthor

    Phase 1 source-checkout implementation is integrated through merged #24, at 94a029b765e8dec5b6bd3c6696da52c4fc6226b6. Its tree matches the exact-head green CI result for 3de2979254e23d3ca032501881f709a6b19fb002; the primary checkout is synced and rebuilt.

    • Documented local TypeScript/JavaScript scan, authored-safe .topo/ lifecycle, versioned graph, deterministic report ingestion, and local static site are implemented.
    • Expansion/collapse, dependency/provenance inspection, keyboard navigation, and committed-source-change identity/layout stability have regression coverage.
    • Comparative renderer evidence remains source-bound. The owner chose WebGL only and a 30 whole-workload FPS floor, uncapped. SVG/D3 and alternate backend fallback are removed. The latest recorded expanded VSCode observations are 46.733 FPS headless and 49.035 FPS headed; the decision records latency, heap, maintenance, accessibility and visual limitations.

    This remains source-checkout delivery, not an npm-publication or namespace-ownership claim. Formal screen-reader/forced-colours conformance and a worst-frame latency guarantee are not claimed. Existing decision issues are not automatically closed.

    The next queued slice is curated views (#9). Its remaining membership/pin/composition policies need confirmation before implementation.

  4. jdylanmc commented on Sep 13, 2026

    @jdylanmc
    OwnerAuthor

    Autonomous backlog pass after #25: #26 now delivers the approved static module contract, independent degree/cycle producers, consistent generation, and reduced-build/version-skew behavior. It is ready for human review; no automatic merge or issue closure.

    Current frontier (not a claim that the entire PRD is complete):

    Area State
    Phase-1/v1 schema, scanner, workspace, graph/layout, reports, WebGL and license gates Landed; current contracts and limitations are documented. Source-based renderer policy remains WebGL-only and >=30 whole-workload FPS, uncapped.
    Curated views #9 Flat path-rule/override/pin/review slice merged in #25. Drag-generated predicate semantics and composed-view pin/exclusion policy remain open.
    Static module composition #12 #26 ready; two independent modules and real build/data skew cases pass. Runtime plugins remain out of scope.
    AI boundary #11 Existing core provenance/witness fields are not a complete AI lifecycle. Primary-label policy, group witness identity, approval semantics and claim expiry need an explicit decision before introducing that workflow. Conservative proposal: secondary-only machine claims, approval never verification, and fingerprint/membership-based staleness.
    Public distribution #13 Private workspace and compiled assets work; npm scope/account ownership and public registry access are unverified. Fresh evidence posted on #13.
    Later roadmap Application-logic representation, additional language adapters, and ecosystem/editor integrations remain future work, not silently marked delivered by these PRs.

    No product-policy defaults or public namespace ownership were invented to claim exhaustion. Next implementation depends on the outstanding decision/access gates above.

  5. jdylanmc commented on Sep 13, 2026

    @jdylanmc
    OwnerAuthor

    Approved enrichment and authoring slice: ready for review

    #27 advances #11 and #9. Head b6ab42ceb6e01aac624abdce3daf1142cadff981 has green CI, is non-draft, and is MERGEABLE/CLEAN. It remains unmerged; no issues were closed.

    • Decision: AI-owned group identity and claim-review semantics #11 boundary: explicit topo enrich, using the repository's own argv command and optional prompt. Static facts/labels stay primary; AI text is secondary, literally rendered, and fixed inferred provenance. Snapshot hashing expires commentary when generated graph/report facts change; layout/view edits alone do not. Structural/reference validation is not semantic verification. Invocation is consent: no extra trust registry, approval machinery, provider adapter, or implicit scan hook.
    • Decision: broader curated-view selectors and composition #9 authoring: inventory drag defaults to exact file/directory inclusion plus a pin; Shift offers an editable broader rule. Keyboard equivalents, camera-space placement, exclusions, ancestor expansion, and busy/read-only/conflict behavior are covered. Existing directory predicates continue to include future descendants; views remain independent.
    • Approved deferrals: view composition, npm publishing, AI-owned groups, and elaborate per-claim/review workflows. These are not blockers for this slice or claims that the entire PRD is complete.

    Full local checks and 26 production-browser cases passed. All 24 real renderer workload observations cleared the uncapped 30 whole-workload FPS floor (minimum 44.794 FPS; maximum observed frame 599.975 ms retained). All captures and source binding are committed. No real model was invoked: local fake providers and explicitly synthetic commentary verify the runner/data path, not semantic AI quality or model latency. No isolated speedup claim across differing curated membership or display cadence.

  6. jdylanmc commented on Sep 14, 2026

    @jdylanmc
    OwnerAuthor

    Phase 1 MVP regression delivery ready

    #30 — test: deliver end-to-end MVP regression gate is non-draft, independently reviewed, and MERGEABLE/CLEAN at a57f51203c584646275e0767b1c65de7ccd26adf, current with observed main 95021a4ff78892254b48455d254d06dcc3ad4a75. Final-head Node 22 CI passed all 264 tests (43 root, 194 workspace, 27 production browser). Human merge remains outstanding; no issues were relabeled or closed.

    The documented corepack yarn test:regression command now runs the complete existing gate locally and in CI. Its real Git/CLI/report/server/WebGL journey verifies authored-safe initialization, stable versioned identities and typed edges, exact deterministic artifacts, dependency inspection, stale-evidence rejection without partial replacement, and regeneration after a committed source change with preserved unaffected layout and views. Failure-propagation tests detect an intentionally masked failure.

    A source-bound generated scale observation covered 100,802 actual code lines, 202 files and 400 authoritative imports in 1,529.57525 ms, from before scan through production server/browser startup and painted interactive expansion/selection. Independent review checked source counts, hashes, timing and decoded changed pixels. This is one regular generated fixture on the recorded M5 Pro, not arbitrary-repository, cold-machine, cross-hardware or FPS evidence. Existing real renderer measurements retain their original source binding and the WebGL-only/30 whole-workload FPS policy.

    No production code or dependency changes were needed for this regression slice. The approved source-checkout MVP is the scope; npm publication, composed views, additional languages, application-logic/editor/ecosystem features and elaborate AI workflows remain deferred. The PR remains under an attached in-session Shepherd observer for feedback, target movement and merge/closure.

  7. jdylanmc commented on Sep 15, 2026

    @jdylanmc
    OwnerAuthor

    Maintainer-aligned product direction and the accepted Archify wrapper POC are captured in #34 and the next-orchestration planning anchor #35. Topo is an agent-authored architectural whiteboard with succinct linked explanations, source evidence, and documentation evolved alongside PRs. Start by wrapping Archify; a fork remains an option only for demonstrated required changes. These records preserve the new direction without rewriting this historical PRD or treating unresolved production contracts/CI enforcement policy as decided.

  8. changed the title [-]PRD: Build the Topocode multi-scale code visualizer[/-] [+]Roadmap: deferred architecture and engineering-health capabilities[/+] on Sep 27, 2026
  9. jdylanmc commented on Sep 27, 2026

    @jdylanmc
    OwnerAuthor

    Backlog reconciliation (2026-09-27)

    Inspected baseline: main@c8e22ec. Maintained intent: docs/product-spec.md.

    Disposition: remains open for the scope below.

    Keep open only as a deferred roadmap, not the active implementation specification or an assertion that the original product is complete. The maintained product intent is now docs/product-spec.md, migrated by #78; the shipped product is the persistent Archify storybook shell from #71.

    Remaining scope

    • Additional language adapters beyond the supported TypeScript/JavaScript scanner.
    • Broader source-grounded application-logic extraction, engineering-health/history overlays, agent-activity visibility, and editor/ecosystem integrations from the historical roadmap.
    • Any future exploration or semantic-zoom experience must be reconciled with Replace the retired WebGL explorer with source-grounded Archify exploration #70 and the maintained Archify product direction before implementation; this issue does not authorize restoring the retired WebGL explorer.

    Readiness and dependencies

    Deferred vision requiring bounded discovery and separately agreed acceptance criteria. Historical Phase 1 work and original renderer/performance goals below are not a current ready-for-agent queue. Keep genuinely unimplemented roadmap scope visible rather than closing it as delivered.

    Merged delivery evidence: #17, #30, #33, #71, #78. These merge commits are ancestors of the inspected main revision.

    Current source and regression evidence:

    Existing exact-main CI is successful. This reconciliation inspected current code, committed regression coverage and merged history; it does not claim a new test run, manual walkthrough, visual acceptance, cross-machine experiment, or approval of paused work.

  10. jdylanmc commented on Sep 29, 2026

    @jdylanmc
    OwnerAuthor

    This was generated by AI during triage.

    Backlog reconciliation (2026-09-29)

    Updated the roadmap to the merged and published product. npm distribution and replacement exploration are delivered; the remaining acceptance work, renderer-assurance gaps, product decisions, owner pause, and npm administration are now separated. Historical decisions remain preserved.

    Evidence and preserved historical requirements are in the updated issue body. Baseline: main@b64bb2f. No repository source or credential changes.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    enhancementNew feature or requestneeds-triageMaintainer evaluation needed

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions