prismatica 0.2.0

package/dist/atlas/labels.js

@@ -0,0 +1,121 @@
+// ── Flow truth fields ─────────────────────────────────────────────────────────
+export const FLOW_FIELD = {
+    goal: { label: 'Goal', hint: 'What the user gets done, in a few words.' },
+    startsWhen: {
+        label: 'Starts when',
+        hint: 'The moment this flow begins — who or what kicks it off.',
+    },
+    needs: {
+        label: 'Needs first',
+        hint: 'Conditions that must already be true before this flow can start.',
+    },
+    steps: { label: 'Steps', hint: 'The main path, one row per action.' },
+    endsWith: { label: 'Ends with', hint: 'What is true when the flow finishes well.' },
+    variations: {
+        label: 'Variations',
+        hint: 'Other routes through this flow. A big difference deserves its own flow.',
+    },
+    rules: { label: 'Rules', hint: 'Things that must stay true for this flow, no matter what.' },
+    involves: {
+        label: 'Involves',
+        hint: 'Who and what takes part — people, services, systems.',
+    },
+};
+/**
+ * A flow's presentation block — display only, deliberately outside the truth
+ * block/hash. `PRESENTATION_DIFF_HEADING` names that distinction on the one
+ * surface where it decides what an owner is consenting to.
+ */
+export const FLOW_PRESENTATION_FIELD = {
+    title: { label: 'Title', hint: 'The short name this flow is shown under.' },
+    journey: { label: 'Journey', hint: 'The group of flows this one belongs to.' },
+    order: { label: 'Position', hint: 'Where it sits within its journey.' },
+};
+export const PRESENTATION_DIFF_HEADING = 'Display (not part of the signed truth)';
+/** A flow's own top-level status field (outside the truth block/hash). */
+export const FLOW_STATUS_FIELD = {
+    label: 'Status',
+    hint: 'Does this exist in the app today?',
+};
+export const FLOW_STATUS_LABEL = {
+    works: 'Works now',
+    planned: 'Planned',
+    idea: 'Idea',
+    uncertain: 'Uncertain',
+};
+/**
+ * Flow Report entry statuses, in the owner's words. `mechanics-updated` is the
+ * one that has to be said carefully: it means the code this flow is MAPPED to
+ * moved, and nothing more. It never claims the user-visible story changed —
+ * that is `truth-proposed`, and only a person proposes it.
+ */
+export const FLOW_REPORT_STATUS_LABEL = {
+    unchanged: 'Assessed as unaffected',
+    'mechanics-updated': 'Mapped implementation touched',
+    'truth-proposed': 'Truth change proposed',
+    new: 'New flow proposed',
+    unsure: 'Unsure — needs a person',
+};
+// ── Step fields (Who / Does / Shows / Changes / Only if) ──────────────────────
+export const FLOW_STEP_FIELD = {
+    actor: { label: 'Who', hint: 'The person or system doing this step.' },
+    action: { label: 'Does', hint: 'What they do.' },
+    shows: { label: 'Shows', hint: 'What the app shows or returns after this step.' },
+    changes: { label: 'Changes', hint: 'What data or state changes.' },
+    assumes: { label: 'Only if', hint: 'This step only works when these are true.' },
+};
+// ── Mechanics (agent-owned, collapsed by default) ──────────────────────────────
+export const MECHANICS_FIELD = {
+    label: 'Where it lives in the code',
+    hint: 'Kept current by agents automatically — never needs your approval.',
+};
+// ── Evidence — attached per step/rule, never a whole-flow claim ───────────────
+/** The four states from R8: manually verified / test verified / code inferred / stale — plus unknown. */
+export const EVIDENCE_STATE_LABEL = {
+    manual: 'Manually verified',
+    test: 'Test verified',
+    inferred: 'Code inferred',
+    stale: 'Stale',
+    unknown: 'Unknown',
+};
+export const LAST_VERIFIED_FIELD = {
+    label: 'Last verified',
+    hint: 'How this was last confirmed — never typed by hand.',
+};
+// ── App rules ───────────────────────────────────────────────────────────────
+export const RULE_FIELD = {
+    label: 'Rule',
+    hint: 'Something that must stay true across the whole app.',
+};
+// ── Mapping an app that has no Flows yet ─────────────────────────────────────
+/**
+ * The ONE wording every surface uses to tell an owner how to map an app, and
+ * the ONE command that is actually theirs to run.
+ *
+ * Mapping starts in the owner's coding agent, not in a terminal: they activate
+ * Prismatica Understand, it runs `prismatica context discover` FOR ITSELF
+ * mid-conversation, reads the code, and hands back one import command. So
+ * `context discover` is never what an owner-facing empty state should print —
+ * doing so teaches them to do by hand what the skill already does, and it takes
+ * no argument, so a copyable form of it says nothing anyway. It stays published
+ * and documented in `context --help` as the route for an agent with no
+ * Prismatica plugin; that is an advanced fallback, not the journey.
+ *
+ * Shared rather than repeated because this sentence had already drifted: `next`
+ * rule 3 named the skill while the board's three empty states, `flow list`,
+ * `rules list`, `doctor` and `init` still named the export. One constant is
+ * what stops the stale half coming back one surface at a time.
+ */
+export const UNDERSTAND_CTA = 'Open your coding agent and use Prismatica Understand.';
+/** What Prismatica Understand hands back — the owner's own command. */
+export const UNDERSTAND_IMPORT_COMMAND = 'prismatica discover --import <proposal.json>';
+// ── Flow Delta (defined in full when Phase 3 adds the schema; labels frozen now) ─
+export const DELTA_FIELD = {
+    where: { label: 'Where', hint: 'Which flow and step this change is about.' },
+    today: { label: 'Today', hint: 'What happens now.' },
+    instead: { label: 'Instead', hint: 'What should happen.' },
+    keep: { label: 'Keep', hint: 'What must not change.' },
+    assumptions: { label: 'New assumptions', hint: 'Conditions this change adds or relies on.' },
+    showMe: { label: 'Show me', hint: 'How the result will be demonstrated.' },
+};
+//# sourceMappingURL=labels.js.map

package/dist/atlas/labels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.js","sourceRoot":"","sources":["../../src/atlas/labels.ts"],"names":[],"mappings":"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"}

package/dist/atlas/next.js

@@ -0,0 +1,327 @@
+import { UNDERSTAND_CTA, UNDERSTAND_IMPORT_COMMAND } from './labels.js';
+import { shellQuote } from '../shellquote.js';
+/**
+ * The ONE way Prismatica ever tells the owner to catch main up. Shared by
+ * `next`'s rule 11, `frame`'s stale-base refusal and `close`'s follow-through
+ * so the three cannot drift into three different instructions for the same
+ * situation.
+ *
+ * Absolute and cwd-safe (`git -C <main>`): all three can be reached from a
+ * lane, and `git switch main && git pull` there switches the WRONG worktree —
+ * or fails outright, since a branch checked out in another worktree cannot be
+ * switched to. `--ff-only` because a merge commit on main is never what this
+ * advice means, and `origin <branch>` explicitly so it works before any
+ * upstream tracking is configured.
+ */
+export function mainSyncCommand(mainRoot, mainBranch) {
+    return `git -C ${shellQuote(mainRoot)} pull --ff-only origin ${shellQuote(mainBranch)}`;
+}
+/**
+ * The ONE eligibility test for release follow-through, shared by `next` and
+ * the board so neither can describe a contract's release proof differently
+ * from the other. `releaseTrackingSince` (`Config`, set once by `init` and
+ * never advanced or replaced) is the non-retroactive compatibility boundary:
+ * a contract created before it never had its release tracked in the first
+ * place, so it must never be queued for `ship --verify` and never described
+ * as shipped or verified — only as legacy release proof that was not tracked.
+ * With no boundary configured yet (a config written before this field
+ * existed, and not re-initialised since), every contract is treated as
+ * eligible: there is no cutoff yet to call anything legacy against.
+ */
+export function isReleaseTracked(contractCreatedAt, releaseTrackingSince) {
+    return releaseTrackingSince === undefined || contractCreatedAt >= releaseTrackingSince;
+}
+function forChange(change) {
+    if (change.stage === 'frame') {
+        return {
+            rule: 7,
+            command: `prismatica pack ${change.id}`,
+            why: `"${change.id}" is framed but has no brief yet`,
+            after: `prismatica open ${change.builder} ${change.id}`,
+        };
+    }
+    if (!change.hasCommittedWork && change.dirtyCodePaths.length === 0) {
+        return {
+            rule: 7,
+            command: `prismatica open ${change.builder} ${change.id}`,
+            why: `"${change.id}" is packed — hand the brief to an agent`,
+            after: 'prismatica next',
+        };
+    }
+    if (change.rejectedReviewNeedsCommit) {
+        const inLane = `git -C ${shellQuote(change.lane)}`;
+        const review = `.prismatica/reviews/${change.id}.md`;
+        return {
+            rule: 7,
+            command: `${inLane} add ${shellQuote(review)} && ${inLane} commit -m ${shellQuote(`record requested changes for ${change.id}`)}`,
+            why: `"${change.id}"'s sealed rejection must reach Git history before any rework`,
+            after: `prismatica open ${change.builder} ${change.id}`,
+        };
+    }
+    if (change.dirtyCodePaths.length > 0) {
+        const quotedPaths = change.dirtyCodePaths.map(shellQuote).join(' ');
+        const inLane = `git -C ${shellQuote(change.lane)}`;
+        return {
+            rule: 7,
+            command: `${inLane} add ${quotedPaths} && ${inLane} commit -m ${shellQuote(change.title)}`,
+            why: `"${change.id}" has uncommitted work in the lane`,
+            after: `prismatica check ${change.id}`,
+        };
+    }
+    if (change.lastCheck !== 'pass') {
+        if (!change.readyCheckAttemptAvailable) {
+            return {
+                rule: 7,
+                command: `prismatica ready status ${change.id}`,
+                why: `"${change.id}" cannot start another Check in its active Get Change Ready run`,
+            };
+        }
+        return {
+            rule: 7,
+            command: `prismatica check ${change.id}`,
+            why: change.lastCheck === 'fail'
+                ? `"${change.id}"'s last check run failed`
+                : change.lastCheck === 'stale'
+                    ? `"${change.id}"'s checks passed against an earlier commit — nothing has proven this one`
+                    : `"${change.id}" has not been checked yet`,
+            after: 'prismatica next',
+        };
+    }
+    if (change.flowReportGaps.length > 0) {
+        return {
+            rule: 7,
+            // `--auto`, because the bare command has no arguments to act on and
+            // simply errors. `--auto` records what the diff proves and then prints
+            // the exact per-flow commands for everything it deliberately would not
+            // decide, so this is one paste that always moves the change forward.
+            command: 'prismatica flow report --auto',
+            why: change.flowReportGaps.join('; '),
+            after: 'prismatica next',
+        };
+    }
+    // A reviewer who said no outranks everything downstream, at EVERY tier above
+    // light — this used to be reachable only through the heavy-tier decision
+    // branch below, so a normal-tier `request_changes` fell straight through to
+    // "ready to ship". It is checked FIRST because a rework makes the review,
+    // the decision and the ship advice all moot at once.
+    if (change.tier !== 'light') {
+        if (change.reviewState === 'sealed-current-blocked') {
+            return {
+                rule: 7,
+                command: `prismatica open ${change.builder} ${change.id}`,
+                why: `"${change.id}"'s reviewer asked for changes — it goes back to the builder, not onward`,
+                after: `prismatica check ${change.id}`,
+            };
+        }
+        if (change.reviewState !== 'sealed-current-approved') {
+            return {
+                rule: 7,
+                command: `prismatica review ${change.id} --reviewer supervisor`,
+                why: change.reviewState === 'sealed-stale'
+                    ? `"${change.id}"'s code changed since the review was sealed — re-review`
+                    : `"${change.id}" passed checks and needs a fresh-eyes review before it can seal`,
+                after: `prismatica seal ${change.id}`,
+            };
+        }
+    }
+    if (change.tier === 'heavy') {
+        // A rejection of THIS diff sends the change back; a rejection of an EARLIER
+        // one is simply spent, and asking for a fresh decision is what unsticks the
+        // loop the old unqualified `rejected` state created.
+        if (change.decisionState === 'rejected-current') {
+            return {
+                rule: 7,
+                command: `prismatica open ${change.builder} ${change.id}`,
+                why: `"${change.id}" was sent back with changes requested`,
+                after: `prismatica check ${change.id}`,
+            };
+        }
+        if (change.decisionState !== 'signed-current') {
+            return {
+                rule: 7,
+                command: `prismatica accept ${change.id}`,
+                why: change.decisionState === 'rejected-stale'
+                    ? `"${change.id}" was rejected over an earlier diff — this one needs its own signed decision`
+                    : `"${change.id}" is heavy tier and needs a signed owner decision over this diff`,
+                after: `prismatica ship ${change.id}`,
+            };
+        }
+    }
+    if (!change.shipped) {
+        // The PR/merge pipeline — gathered read-only from GitHub once the change
+        // has reached ship or beyond (see NextChangeState.prState). A network
+        // failure never masquerades as any of these; it falls to `unknown`
+        // below, honest about not knowing rather than guessing.
+        if (change.prState === 'merged') {
+            return {
+                rule: 7,
+                command: `prismatica close ${change.id}`,
+                why: `"${change.id}"'s PR merged on GitHub — close the lane before verifying`,
+                after: `prismatica ship ${change.id} --verify`,
+            };
+        }
+        if (change.prState === 'ready') {
+            return {
+                rule: 7,
+                command: `prismatica merge ${change.id}`,
+                why: `"${change.id}"'s PR is open with a passing gate at this exact head — ready to merge`,
+                after: `prismatica close ${change.id}`,
+            };
+        }
+        if (change.prState === 'pending') {
+            return {
+                rule: 7,
+                command: change.prNumber ? `gh pr checks ${change.prNumber}` : `prismatica next`,
+                why: `"${change.id}"'s PR is open — waiting on the prismatica-gate check to finish`,
+                after: `prismatica merge ${change.id}`,
+            };
+        }
+        if (change.prState === 'failed') {
+            return {
+                rule: 7,
+                command: `prismatica open ${change.builder} ${change.id}`,
+                why: `"${change.id}"'s PR gate check failed — back to the lane to fix it`,
+                after: `prismatica check ${change.id}`,
+            };
+        }
+        if (change.prState === 'unknown') {
+            return {
+                rule: 7,
+                command: `prismatica ship ${change.id}`,
+                why: `"${change.id}"'s GitHub PR state could not be checked (gh unavailable or offline) — re-running ship is safe, it reuses an existing open PR`,
+                after: 'prismatica next',
+            };
+        }
+        return {
+            rule: 7,
+            command: `prismatica ship ${change.id}`,
+            why: `"${change.id}" is ready to ship`,
+            after: `prismatica ship ${change.id} --verify`,
+        };
+    }
+    return {
+        rule: 7,
+        command: `prismatica ship ${change.id} --verify`,
+        why: `"${change.id}" shipped — record the live smoke verification and rollback route`,
+        after: 'prismatica next',
+    };
+}
+export function decideNext(state) {
+    if (!state.appRegistered) {
+        return {
+            rule: 1,
+            command: 'prismatica init',
+            why: 'this repo has not adopted Prismatica yet',
+            after: 'prismatica next',
+        };
+    }
+    // Atlas record hygiene (release-blocker fix) outranks everything below it
+    // on purpose: a deleted or tampered canonical Flow can make `flowCount`
+    // read as 0, which would otherwise wrongly fall into rule 3's "run
+    // discover" — drafting brand-new flows over a broken record is exactly
+    // backwards. A merely pending Delta-approval decision is the lightest
+    // finding this can surface, and it's still more specific/actionable than
+    // a generic "nothing mapped yet" or "review a proposal" nudge.
+    if (state.mode === 'govern' && state.atlasHygieneAdvice) {
+        return {
+            rule: 2,
+            command: state.atlasHygieneAdvice.command,
+            why: state.atlasHygieneAdvice.why,
+            after: 'prismatica next',
+        };
+    }
+    if (state.flowCount === 0 && state.pendingFlowDrafts === 0 && state.pendingFlowUpdates === 0) {
+        return {
+            rule: 3,
+            // Mapping an app is a conversation, so this rule names one rather than a
+            // command. Bare `prismatica discover` is the IMPORT half now and refuses
+            // without `--import <file>`; `prismatica context discover` is the
+            // machine-facing export the Understand skill runs for itself. Printing
+            // either would hand the owner something that either cannot work or is
+            // not theirs to run — and the prompt-pack `discover` that once belonged
+            // here was deleted on purpose.
+            command: UNDERSTAND_CTA,
+            why: 'no Flows exist yet — describe the app with it, and it will read the code and write the Flow and Rule proposals for you to review',
+            after: UNDERSTAND_IMPORT_COMMAND,
+            inAgent: true,
+        };
+    }
+    if (state.pendingFlowDrafts > 0) {
+        return {
+            rule: 4,
+            command: 'prismatica view',
+            why: `${state.pendingFlowDrafts} drafted flow(s) are waiting for your review`,
+            after: 'prismatica next',
+        };
+    }
+    if (state.pendingFlowUpdates > 0 || state.pendingRuleProposals > 0) {
+        return {
+            rule: 5,
+            command: 'prismatica view',
+            why: 'a truth proposal is waiting for your review',
+            after: 'prismatica next',
+        };
+    }
+    if (state.approvedUnframedDelta) {
+        return {
+            rule: 6,
+            command: `prismatica frame --from-delta ${state.approvedUnframedDelta.id}`,
+            why: `delta "${state.approvedUnframedDelta.id}" was approved but has not been framed into a change yet`,
+            after: 'prismatica next',
+        };
+    }
+    if (state.change) {
+        return forChange(state.change);
+    }
+    // The plan's rule 7 (a flow-report gap on a finished change) is folded
+    // into rule 7's forChange above — see NextChangeState.flowReportGaps —
+    // because a "finished change" in this codebase's Model B is still an open
+    // change (its lane hasn't been removed yet), so it always matches
+    // `state.change` first.
+    if (state.ambiguousOpenChangeCount >= 2) {
+        return {
+            rule: 8,
+            command: 'prismatica view',
+            why: `${state.ambiguousOpenChangeCount} open changes — cd into one of their lanes for specific advice, or pick one to work on`,
+            after: 'prismatica next',
+        };
+    }
+    if (state.staleFlow) {
+        return {
+            rule: 9,
+            command: `prismatica flow verify ${state.staleFlow.flowId} --step ${state.staleFlow.step}`,
+            why: `evidence for step ${state.staleFlow.step} of "${state.staleFlow.flowId}" predates a later code change`,
+            after: 'prismatica next',
+        };
+    }
+    // A change that reached main and never got its passport. Below everything
+    // above it on purpose: an open change is live work, and this one has already
+    // shipped — but "all quiet" is wrong while the record of whether it actually
+    // works in production was never written. The command deliberately carries
+    // no `--deploy-result`/`--rollback` — those are real evidence only the owner
+    // has, and printing plausible-looking placeholders here is how a passport
+    // once ended up recording "..." as a tested rollback route. `ship --verify`
+    // itself explains exactly what it still needs.
+    if (state.awaitingVerification) {
+        return {
+            rule: 12,
+            command: `prismatica ship ${state.awaitingVerification.id} --verify`,
+            why: `"${state.awaitingVerification.id}" is on main, awaiting live verification — no passport records that it works in production`,
+            after: 'prismatica next',
+        };
+    }
+    // Last before all-quiet: "nothing needs you" is false while main is known
+    // to be behind its remote, and every change framed from here would take a
+    // stale baseline (`frame` refuses outright for exactly that reason). Never
+    // pulled automatically — a fast-forward is still the owner's to run.
+    if (state.mainBehind) {
+        return {
+            rule: 11,
+            command: mainSyncCommand(state.mainBehind.mainRoot, state.mainBehind.mainBranch),
+            why: `your "${state.mainBehind.mainBranch}" is ${state.mainBehind.count} commit(s) behind its remote — the next change would start from a stale baseline`,
+            after: 'prismatica next',
+        };
+    }
+    return { rule: 10, command: 'prismatica view', why: 'all quiet — nothing needs you right now' };
+}
+//# sourceMappingURL=next.js.map

package/dist/atlas/next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.js","sourceRoot":"","sources":["../../src/atlas/next.ts"],"names":[],"mappings":"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"}

package/dist/atlas/packs.js

@@ -0,0 +1,169 @@
+/**
+ * Agent-facing prompt packs for Atlas. Prismatica never calls an LLM — these are
+ * plain text files an owner hands to an agent (or copies into one), the same
+ * pattern as the existing mapping pack and change briefs.
+ */
+import { renderFlowBody } from './render.js';
+import { FLOW_FIELD, FLOW_STEP_FIELD } from './labels.js';
+const FLOW_PROPOSAL_TEMPLATE = `---
+id: <kebab-case-id, e.g. log-a-practice-session>
+proposalType: draft
+reason: "Discovered while reading the repo"
+proposedBy: agent
+createdAt: "<ISO timestamp, e.g. 2026-01-01T00:00:00.000Z>"
+status: works               # works | planned | idea | uncertain — be honest; see rules below
+truth:
+  goal: "<${FLOW_FIELD.goal.hint}>"
+  startsWhen: "<${FLOW_FIELD.startsWhen.hint}>"
+  needs: []                 # optional — ${FLOW_FIELD.needs.hint}
+  steps:
+    - actor: "<${FLOW_STEP_FIELD.actor.hint}>"
+      action: "<${FLOW_STEP_FIELD.action.hint}>"
+      shows: "<optional — ${FLOW_STEP_FIELD.shows.hint}>"
+      changes: "<optional — ${FLOW_STEP_FIELD.changes.hint}>"
+      assumes: []            # optional — ${FLOW_STEP_FIELD.assumes.hint}
+      evidence: { method: inferred, at: "<same ISO timestamp>" }
+    # one entry per step — add as many as the real flow needs
+  endsWith: "<${FLOW_FIELD.endsWith.hint}>"
+  variations: []             # optional — {name, differs, status?}
+  rules: []                  # optional — free text, or an existing rule id like "r-offline-first"
+  involves: []                # optional — who/what takes part
+mechanics:
+  touchpoints: ["<file globs this flow's code lives in>"]
+  routes: []
+  components: []
+  entities: []
+  tests: []                   # [{file, steps: [1,2]}] — only list tests you actually found and read
+---
+
+Notes for the owner (optional free text — not validated).
+`;
+const RULE_PROPOSAL_TEMPLATE = `---
+id: <kebab-case-id starting with "r-", e.g. r-offline-first>
+proposalType: draft
+reason: "Discovered while reading the repo"
+proposedBy: agent
+createdAt: "<ISO timestamp>"
+text: "<the rule, in one plain sentence>"
+---
+`;
+export function discoveryPackContent(input) {
+    const existingSection = input.existingFlowCount === 0
+        ? "This app has no flows recorded yet. Draft 6–12 flows that cover its real, everyday use — don't invent features that aren't in the code."
+        : `This app already has ${input.existingFlowCount} flow(s) recorded:\n${input.existingFlowGoals.map((goal) => `  - ${goal}`).join('\n')}\n\nDraft flows for whatever real behaviour isn't covered yet. If something you find changes an EXISTING flow above, write an "update" proposal for it instead of a duplicate "draft" (same id as the existing flow, proposalType: update).`;
+    return `# Discovery pack — ${input.appName}
+
+You are an AI agent. Your task is to read this repository and draft Flows and
+app Rules — Prismatica's map of what the app actually does. You are NOT
+building or changing anything; you are only observing and writing draft files.
+Nothing you write here takes effect until the owner reviews and approves it.
+
+## What a Flow is
+
+A Flow is one complete, real route through the app: where it starts, the
+steps someone takes, what the app shows and changes at each step, and where
+it ends. Not a feature list, not a code walkthrough — an outcome someone
+actually gets, start to finish.
+
+## Do
+
+1. ${existingSection}
+2. For each flow, read the real code paths involved (routes, handlers,
+   components, tests) before writing anything.
+3. Write one file per flow at \`.prismatica/flows/proposals/<id>.md\`, using
+   the exact template below. Every field name must match the template exactly.
+4. Be honest about \`status\`: mark \`works\` ONLY if you found working,
+   connected code for the whole path. If you're not sure it's wired up
+   end-to-end, mark \`uncertain\`. If it's referenced but clearly not built,
+   mark \`planned\` or \`idea\`. Never guess "works" to look thorough.
+5. Set every step's \`evidence.method\` to \`inferred\` — you read code, you did
+   not run it. Only a human running \`prismatica flow verify\` produces
+   \`manual\` evidence; only a passing mapped test produces \`test\` evidence.
+6. Also propose candidate app rules — short, cross-cutting requirements you
+   noticed (e.g. "offline-first", "never call a paid API") — one file per rule
+   at \`.prismatica/rules/proposals/<id>.md\`, using its template below.
+7. When you're done, tell the owner how many flows and rules you drafted and
+   where to review them: \`prismatica flow list\` and \`prismatica view\`.
+
+## Do not
+
+- Do not write to \`.prismatica/flows/\` or \`.prismatica/rules.md\` directly —
+  only to the \`proposals/\` folders. Only the owner's approval creates the
+  canonical record.
+- Do not mark anything as manually or test verified.
+- Do not invent flows that aren't really in the code.
+
+## Flow proposal template — \`.prismatica/flows/proposals/<id>.md\`
+
+\`\`\`
+${FLOW_PROPOSAL_TEMPLATE}\`\`\`
+
+## Rule proposal template — \`.prismatica/rules/proposals/<id>.md\`
+
+\`\`\`
+${RULE_PROPOSAL_TEMPLATE}\`\`\`
+`;
+}
+/**
+ * `flow assume` — evaluating a future "what if" without building anything.
+ * Reuses `renderFlowBody` (the same rendering `pack`/`review` embed) so the
+ * agent sees the exact approved truth, never a paraphrase. The agent's answer
+ * is never applied directly: it comes back as a `delta new` command for the
+ * owner to run (proposed, then approved, then framed — the existing path),
+ * or as a plain "nothing needs to change" if the flow already holds up.
+ */
+export function assumePackContent(input) {
+    const relatedSection = input.relatedFlows.length === 0
+        ? '_None found — this flow shares no entity, route, or component with any other flow._'
+        : input.relatedFlows.map((flow) => renderFlowBody(flow)).join('\n\n---\n\n');
+    const rulesSection = input.rules.length === 0
+        ? '_No app rules recorded yet._'
+        : input.rules.map((rule) => `- **${rule.id}** — ${rule.text}`).join('\n');
+    return `# Assumption check — ${input.flow.truth.goal}
+
+You are an AI agent. The owner wants to know what happens if an assumption
+behind this flow stops holding — evaluating a future need before anyone
+builds anything. You are NOT changing anything here; you are reasoning
+about it against the real code and reporting back.
+
+## The assumption being flipped
+
+${input.assumption}
+
+## The flow as it stands today (\`${input.flow.id}\`)
+
+${renderFlowBody(input.flow)}
+
+## Related flows (share a screen, entity, route, or component with this one)
+
+${relatedSection}
+
+## App rules that might constrain the answer
+
+${rulesSection}
+
+## What to do
+
+1. Trace the real code paths this flow and its related flows depend on —
+   don't reason from the flow text alone.
+2. Decide: if the assumption above no longer holds, does this flow (or a
+   related one) need to change?
+3. If nothing needs to change, say so plainly to the owner. Do not write a
+   delta for "no change needed" — there is nothing to propose.
+4. If something should change, give the owner the exact command to run,
+   every value filled in with your real answer, no placeholders:
+
+   \`\`\`
+   prismatica delta new --flow ${input.flow.id} --today "what happens today" --instead "what should happen instead" --show-me "how the result will be demonstrated"
+   \`\`\`
+
+   Add \`--step <n>\` if it's about one specific step, \`--keep "..."\`
+   (repeatable) for anything that must not change, and \`--assume "..."\`
+   (repeatable) for any new assumption this introduces.
+5. Never edit \`.prismatica/flows/\` or \`.prismatica/rules.md\` yourself. A
+   delta only ever proposes — the owner approves it
+   (\`prismatica delta approve\`) and frames it into a change
+   (\`prismatica frame --from-delta\`) before anything is built.
+`;
+}
+//# sourceMappingURL=packs.js.map

package/dist/atlas/packs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packs.js","sourceRoot":"","sources":["../../src/atlas/packs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAS1D,MAAM,sBAAsB,GAAG;;;;;;;;YAQnB,UAAU,CAAC,IAAI,CAAC,IAAI;kBACd,UAAU,CAAC,UAAU,CAAC,IAAI;2CACD,UAAU,CAAC,KAAK,CAAC,IAAI;;iBAE/C,eAAe,CAAC,KAAK,CAAC,IAAI;kBACzB,eAAe,CAAC,MAAM,CAAC,IAAI;4BACjB,eAAe,CAAC,KAAK,CAAC,IAAI;8BACxB,eAAe,CAAC,OAAO,CAAC,IAAI;4CACd,eAAe,CAAC,OAAO,CAAC,IAAI;;;gBAGxD,UAAU,CAAC,QAAQ,CAAC,IAAI;;;;;;;;;;;;;CAavC,CAAC;AAEF,MAAM,sBAAsB,GAAG;;;;;;;;CAQ9B,CAAC;AAEF,MAAM,UAAU,oBAAoB,CAAC,KAAyB;IAC5D,MAAM,eAAe,GACnB,KAAK,CAAC,iBAAiB,KAAK,CAAC;QAC3B,CAAC,CAAC,yIAAyI;QAC3I,CAAC,CAAC,wBAAwB,KAAK,CAAC,iBAAiB,uBAAuB,KAAK,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,6OAA6O,CAAC;IAEzX,OAAO,sBAAsB,KAAK,CAAC,OAAO;;;;;;;;;;;;;;;;KAgBvC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BlB,sBAAsB;;;;;EAKtB,sBAAsB;CACvB,CAAC;AACF,CAAC;AAWD;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAsB;IACtD,MAAM,cAAc,GAClB,KAAK,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC;QAC7B,CAAC,CAAC,qFAAqF;QACvF,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAEjF,MAAM,YAAY,GAChB,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QACtB,CAAC,CAAC,8BAA8B;QAChC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,CAAC,EAAE,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAE9E,OAAO,wBAAwB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI;;;;;;;;;EASpD,KAAK,CAAC,UAAU;;oCAEkB,KAAK,CAAC,IAAI,CAAC,EAAE;;EAE/C,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC;;;;EAI1B,cAAc;;;;EAId,YAAY;;;;;;;;;;;;;;iCAcmB,KAAK,CAAC,IAAI,CAAC,EAAE;;;;;;;;;;CAU7C,CAAC;AACF,CAAC"}