🧭 Establish a dependency-aware portfolio map and focus queue

[szmyty]

Outcome

Create a human-reviewable, dependency-aware portfolio view for the Ego Hygiene organization that makes the current system understandable at a glance and supports one clear execution lane without turning conceptual relationships into false blockers.

The organization now contains many interrelated repositories, migrations, specifications, and active issue chains. The missing capability is not another repository inventory or autonomous fleet mutation mechanism; it is a concise operational projection that helps a human answer:

• What systems exist, and which repository owns each responsibility?
• Which relationships are true execution dependencies?
• Which projects are merely related and may proceed in parallel?
• What is actively in progress?
• What should be Now, Next, Later, or Parked?
• What is the single primary lane and the next three concrete actions?

Architecture boundary

• Observatory supplies observed repository and issue inventory.
• Hygiene supplies governed architecture, applicability, and canonical ownership rules.
• Aether supplies portable agent/workflow contracts where relevant.
• Pace owns the reviewable execution projection, dependency ordering, and focus queue.
• Product repositories remain the source of truth for their implementation work.
• The portfolio view must link to canonical issues rather than copying their full specifications.

This issue must not make Pace the canonical source for repository purpose, organizational policy, or product requirements.

Scope

Define and implement a portable portfolio model that represents:

• systems, repositories, projects, and major initiatives;
• canonical owner and lifecycle state;
• explicit relationship types such as depends-on, consumes, migrates-from, supersedes, and related-to;
• relationship basis and confidence so inferred edges are not presented as approved architecture;
• active issue or roadmap references;
• blockers, decisions requiring the user, and safe parallel work;
• Now / Next / Later / Parked placement;
• one optional primary execution lane;
• exactly three next concrete actions when sufficient evidence exists;
• freshness, source revision, and unresolved-data warnings.

Required views

Produce at least:

1. Ecosystem map — repositories/systems and canonical responsibilities.
2. Dependency view — only evidence-backed execution prerequisites.
3. Parallel lanes — work that can proceed independently.
4. Focus queue — Now / Next / Later / Parked with one primary lane.
5. Decision queue — items that require explicit human judgment.
6. Drift/staleness view — source data that needs refresh before it can guide execution.

The initial interface may be Markdown and JSON. A dashboard is optional and should consume the same canonical projection rather than becoming a second model.

Workflow

1. Ingest current inventory and architecture sources.
2. Normalize project and issue references.
3. Classify relationship type, basis, and confidence.
4. Detect missing, cyclic, contradictory, or stale dependencies.
5. Generate a reviewable proposed portfolio projection.
6. Require human confirmation for inferred ownership, supersession, or priority changes.
7. Publish the accepted projection with source revisions.
8. Refresh incrementally without erasing parked work or human annotations.

Cognitive-load requirements

• Default to a compact overview before detailed drill-down.
• Keep the primary lane visually distinct from parallel and parked work.
• Do not show every open issue in the default view.
• Explain why an item is blocked or prioritized.
• Preserve ideas without making every idea an active commitment.
• Allow a brain dump or planning session to be captured as proposed inputs before it becomes accepted roadmap state.
• Make the next three actions independently copyable and executable.

Validation

Use a representative organization snapshot containing:

• at least five repositories with different ownership roles;
• at least one true dependency chain;
• at least one conceptual relationship that is not a blocker;
• at least two safe parallel lanes;
• one stale source;
• one contradictory or inferred relationship;
• one parked idea without an implementation issue.

Prove that:

• dependency cycles and unresolved references are reported;
• inferred edges cannot silently become accepted architecture;
• a stale inventory cannot be presented as current without warning;
• the same canonical issue is not duplicated across lanes;
• regeneration preserves human-reviewed state and annotations;
• the primary lane and next three actions remain concise.

Acceptance criteria

• A versioned portable portfolio schema exists.
• Canonical ownership and relationship types are explicit.
• True dependencies are distinguishable from conceptual relationships.
• Observatory, Hygiene, and relevant repository issues are referenced rather than duplicated.
• Now / Next / Later / Parked views are generated from one model.
• One primary execution lane can be selected without hiding parallel work.
• The projection emits exactly three next actions when evidence is sufficient.
• Inferences, contradictions, stale inputs, and missing references are visible.
• Brain-dump inputs remain proposed until reviewed.
• Human annotations and accepted priority decisions survive refreshes.
• A deterministic local validation command checks schema, references, cycles, duplicate issue placement, and freshness metadata.
• Documentation explains authoring, review, refresh, and recovery.

Non-goals

• Replacing GitHub Issues or repository-local roadmaps.
• Automatically reprioritizing work from activity alone.
• Treating every conceptual connection as a dependency.
• Migrating repositories or closing issues.
• Building a large dashboard before the portable contract is proven.
• Requiring the user to keep the entire organization model in working memory.