# PortaShape Product Roadmap

## Roadmap principle

Build the shared system model and one complete vertical workflow before expanding the number of connectors or isolated interface features. The product must prove that inspection, shaping, mapping, validation, execution, and artifact preservation are one loop.

## Phase 0 — Product canon and artifact foundations

**Outcome:** Stable vocabulary, repository structure, conceptual schema, and examples.

- adopt the single purpose and positioning;
- define system elements, scopes, authority, relations, surfaces, workflows, runs, and libraries;
- establish `.posh` artifact kinds and canonical JSON rules;
- extract and validate the example catalog;
- place the Alpine.js + htmx material as the Web-Native Runtime Library;
- define contribution, versioning, and compatibility conventions.

## Phase 1 — System model and inspector

**Outcome:** Connect one real system and make it understandable.

- implement adapter contract;
- support JSON/file and one API or runtime adapter;
- build typed element graph;
- display paths, types, values, constraints, scope, authority, and provenance;
- save and load a `system` or `snapshot` `.posh` artifact;
- support search, selection, and annotations.

**Proof:** A user can connect a system and produce a reusable, inspectable snapshot without hand-authoring its schema.

## Phase 2 — Generated control surface and runtime feedback

**Outcome:** Shape a connected system through generated controls.

- type-to-control rendering;
- temporary, proposed, and committed state distinctions;
- live observation and preview;
- surface composition and persistence;
- basic permissions and validation;
- initial web-native renderer using the runtime library patterns;
- source patch or configuration export for one supported target.

**Proof:** A user can expose a value, tune it, see the result, and save both the control surface and accepted output.

## Phase 3 — Mapping, transform, and simulation

**Outcome:** Relate two systems and preview a controlled transfer.

- source/destination explorer;
- direct, lookup, formula, combine, split, conditional, and template mappings;
- reusable transform registry;
- confidence-backed suggestions;
- dependency planning;
- unresolved values and explicit loss;
- dry-run report;
- mapping and transform artifact support.

**Proof:** A user can create a mapping through the UI, simulate it, inspect every produced value, and save a valid `.posh` file.

## Phase 4 — Execution, snapshots, and comparison

**Outcome:** Safely run and audit real changes.

- staged execution;
- run jobs and progress state;
- pre- and post-run snapshots;
- diff and drift views;
- approvals and environment policies;
- rerun and partial execution;
- rollback or compensation for supported adapters;
- signed run reports and provenance.

**Proof:** A user can migrate or promote a bounded system slice and explain exactly what changed and why.

## Phase 5 — Complete vertical product workflow

**Outcome:** Demonstrate the full PortaShape identity with one ambitious domain.

Recommended proving domain: **website system transfer and reconstruction** because it exercises content, styles, tokens, components, routes, assets, settings, options, permissions, runtime behavior, preview, validation, and migration.

Deliver:

- two supported website or content adapters;
- visual source/destination exploration;
- generated control surfaces;
- mapping and transmutation;
- destination preview;
- route, asset, content, visual, and accessibility validation;
- staged execution and run report;
- reusable mapping library.

## Phase 6 — Library ecosystem and collaboration

**Outcome:** Reuse becomes a first-class product advantage.

- package manifest and registry;
- organization, project, environment, and user layers;
- adapter and transform SDKs;
- policy and surface libraries;
- review, comments, approvals, and artifact diffs;
- compatibility and deprecation tooling;
- expanded Web-Native Runtime Library with PortaShape-native components and `.posh` patterns.

## Phase 7 — Pattern learning and assisted composition

**Outcome:** PortaShape helps users discover better abstractions.

- recurring control and mapping detection;
- suggested semantic concepts;
- workflow and policy suggestions;
- AI-assisted schema interpretation and transform drafting;
- evidence, confidence, review, and structured acceptance;
- cross-project knowledge with privacy and organization boundaries.

## MVP boundary

The first coherent MVP should include:

- two simple adapters;
- one system explorer;
- generated controls for common types;
- live preview for one target;
- source/destination mapping;
- a small transform library;
- simulation and validation;
- `.posh` save/load;
- provenance for every output;
- one runnable end-to-end migration or configuration-promotion workflow.

Do not call a set of disconnected inspector, dashboard, and mapper demos an MVP. The proof is continuity across the loop.

## Intentionally deferred

Until the core loop is proven, defer:

- broad connector marketplaces;
- fully autonomous migration;
- universal bidirectional synchronization;
- a large visual app-builder feature set;
- many frontend renderer technologies;
- high-frequency collaborative canvas editing;
- unsupported claims of full website fidelity;
- opaque AI transformations;
- public artifact registry without trust and compatibility controls.

## Product health measures

Useful measures include:

- time from connection to first useful surface;
- percentage of discovered values with type, scope, authority, and provenance;
- mapping suggestion acceptance and correction rates;
- unresolved and silently discarded value counts;
- preview-to-successful-run conversion;
- validation failures caught before execution;
- reuse rate of mappings, transforms, surfaces, and policies;
- ability to reproduce a run from artifacts and versions;
- destination drift detected after execution;
- number of repeated manual actions promoted into reusable abstractions.

## Definition of product coherence

PortaShape is coherent when:

- a value has one identity across inspection, control, mapping, execution, and comparison;
- every change can reveal authority, constraints, provenance, and effect;
- every useful operation can be preserved as an artifact or library contribution;
- a simple control and a complete migration use the same conceptual primitives;
- implementation libraries fit under the product model rather than defining separate products.