waterplane 0.0.1 → 0.1.6

package/node_modules/@waterplane/shared/dist/assess/sasswords.d.ts

@@ -0,0 +1,140 @@
+import { type AssessVerdict } from "./sassvocab.js";
+import { type AssessConflict, type AssessDowngrade, type AssessProposal, type AssessRow, type AssessSplit } from "./sassio.js";
+/**
+ * The ONE place a verdict becomes a word.
+ *
+ * `clihealth.ts`'s rule: the phone's row and the host's stored reason must not
+ * word one fact two ways, or "already done" and "done" become two categories in
+ * a list a person is scanning for the one row they disagree with.
+ */
+export declare function assessVerdictLabel(v: AssessVerdict): string;
+/** Why the pure layer overrode the CLI, in words. */
+export declare function downgradeText(d: AssessDowngrade): string;
+/** The finished sentence for one row — verdict, why, and what backs it. A UI
+ *  renders it as is and must not re-weave it. */
+export declare function assessRowSentence(row: AssessRow): string;
+/**
+ * The reason a dismissed row carries, forever, where the row is rendered.
+ *
+ * `intoId` is the intent id the merge was posted as, which the pure layer
+ * cannot know — the host calls this a second time once it does, rather than
+ * assembling its own sentence, so the merged row and the sheet say the same
+ * thing.
+ */
+export declare function assessDismissReason(v: AssessVerdict, evidence: string, intoId?: string): string;
+/** How many rows each verdict claimed — what a header says before anybody
+ *  scrolls. */
+export declare function assessCounts(p: AssessProposal): Record<AssessVerdict, number>;
+/**
+ * **How many things this run has something to CALL** — the number the naming
+ * question is asked about.
+ *
+ * One per row, group or new item carrying a title or a kind, counted once
+ * whichever of the two it has: the question is "should these names be written",
+ * and a row with both is still one row a person is deciding about. Merges and
+ * new items are in the count for the same reason they are in the sheet — they
+ * are rows this apply will create, and a person reading "titles 14 items" must
+ * not find 16.
+ */
+export declare function assessNameCount(p: AssessProposal): number;
+/** A conflict card's sentence. The ids are the caller's to draw as rows; this
+ *  is the line above them, so the sheet and any notification say it alike. */
+export declare function assessConflictSentence(c: AssessConflict): string;
+/** A split card's sentence. */
+export declare function assessSplitSentence(s: AssessSplit): string;
+/** The reason an approved split's ORIGINAL carries once archived. `intoIds`
+ *  are the two posted rows' ids, which only the host knows. */
+export declare function assessSplitReason(rationale: string, intoIds?: readonly string[]): string;
+/**
+ * What the user approved. Absent means absent: nothing here applies itself, so
+ * an empty set of choices decides nothing at all.
+ */
+export interface AssessChoices {
+    /** Row ids whose verdict was accepted. */
+    rows?: readonly string[];
+    /** Merge group ids approved — one decision about all N members. */
+    merges?: readonly string[];
+    /** Indices into `proposal.news`. */
+    news?: readonly number[];
+    /**
+     * Split ids (`AssessSplit.sid`) approved — post both texts on the original's
+     * clock, archive the original. There is deliberately NO field for conflicts:
+     * a conflict is words, and what a person does about one (edit, drop one,
+     * ignore) is a separate tap with the existing verbs, never an apply.
+     */
+    splits?: readonly string[];
+    /**
+     * **Is the order you just approved marked as yours?** Asked at apply time,
+     * because only the person applying knows.
+     *
+     * An assessment ranks the wanted set, and applying writes that rank as each
+     * row's `order` either way. Pinned, each ranked row is also stamped
+     * `handOrdered` — the mark a drag leaves, drawn as "placed by you". Nothing
+     * on the host re-sorts a row on its own any more (see `Intent.handOrdered`), so the mark says who placed a row;
+     * it does not defend it from a machine.
+     *
+     * Absent is false — the behaviour every apply had before the question
+     * existed, so an older client applying a proposal changes nothing.
+     */
+    pinRanks?: boolean;
+    /**
+     * **Do the run's titles go on the rows, or stay on this sheet?** Asked at
+     * apply time for `pinRanks`' reason: only the person applying knows whether
+     * they want a machine's words at the top of their own list.
+     *
+     * Neither answer is obviously right. A titled backlog is scannable in a way a
+     * wall of first lines is not; a title a model wrote is also the one string on
+     * the row that nobody checked, sitting where a reader looks first. What is
+     * never in question is the typed half — a `label` a person wrote is never
+     * replaced by this, whatever the answer.
+     *
+     * Absent is false — the behaviour every apply had before the question
+     * existed, so an older client applying a proposal changes nothing.
+     */
+    writeNames?: boolean;
+}
+/**
+ * **The question the apply asks about the order it is about to write**, and the
+ * two answers, worded so neither reads as the safe one.
+ *
+ * Here rather than in the sheet because the host says the same thing back on
+ * the row (`applyProposal`'s `handOrdered`) and a second wording of one fact is
+ * how two screens come to disagree about what was decided.
+ *
+ * Neither label may promise protection from a re-sort: nothing re-sorts a
+ * row on its own, so the only difference is the "placed by you" mark.
+ */
+export declare function assessPinQuestion(n: number): string;
+export declare const ASSESS_PIN_KEEP = "keep this order";
+export declare const ASSESS_PIN_FREE = "leave it unmarked";
+/**
+ * …and what each answer means, since the consequence is not on either label.
+ * Both are true in every repo: the order is written either way, and nothing
+ * moves a row on its own afterwards.
+ */
+export declare function assessPinNote(pinned: boolean): string;
+/**
+ * **The question the apply asks about the titles it is about to write**, and
+ * the two answers — `assessPinQuestion`'s shape, for the same reason it has
+ * that shape: the sheet and the host must not word one decision two ways.
+ *
+ * It names both halves of what a name is, because the row shows both and a
+ * question that said only "titles" would be asking about half of what the tap
+ * does.
+ */
+export declare function assessNameQuestion(n: number): string;
+export declare const ASSESS_NAME_WRITE = "write them";
+export declare const ASSESS_NAME_SKIP = "leave the rows as they are";
+/**
+ * …and what each answer means.
+ *
+ * The write side says the protection out loud because it is the only thing
+ * standing between a naming run and words somebody typed, and a person deciding
+ * this has no other place to learn it. It also says the names are EDITABLE,
+ * since the honest reason to say yes is that a wrong title costs one tap.
+ *
+ * The skip side does not say "nothing happens": the suggestions are still on
+ * the sheet, and a person who wanted them somewhere else needs to know they did
+ * not evaporate.
+ */
+export declare function assessNameNote(write: boolean): string;

package/node_modules/@waterplane/shared/dist/assess/sasswords.js

@@ -0,0 +1,155 @@
+// ── The sentences ────────────────────────────────────────────────────────────
+/**
+ * The ONE place a verdict becomes a word.
+ *
+ * `clihealth.ts`'s rule: the phone's row and the host's stored reason must not
+ * word one fact two ways, or "already done" and "done" become two categories in
+ * a list a person is scanning for the one row they disagree with.
+ */
+export function assessVerdictLabel(v) {
+    switch (v) {
+        case "done": return "already done";
+        case "obsolete": return "no longer applies";
+        case "superseded": return "covered by another item";
+        case "merged": return "merged with others";
+        case "wanted": return "still wanted";
+        case "unclear": return "could not tell";
+    }
+}
+/** Why the pure layer overrode the CLI, in words. */
+export function downgradeText(d) {
+    switch (d) {
+        case "no-evidence": return "left undecided: nothing was cited to back that up";
+        case "unknown-verdict": return "left undecided: the verdict was not one this app knows";
+        case "duplicate": return "left undecided: it was given more than one verdict";
+        case "unmentioned": return "left undecided: the assessment did not mention it";
+        case "supersede-unknown": return "left undecided: it points at an item that was not in the list";
+        case "supersede-self": return "left undecided: it points at itself";
+        case "supersede-cycle": return "left undecided: the chain of items it points at comes back round";
+        case "merge-conflict": return "left undecided: more than one outcome claimed it";
+        case "merge-dropped": return "left undecided: the merge it was part of did not stand";
+        case "merge-unknown": return "left undecided: it names a merge that does not exist";
+    }
+}
+/** The finished sentence for one row — verdict, why, and what backs it. A UI
+ *  renders it as is and must not re-weave it. */
+export function assessRowSentence(row) {
+    const tail = row.evidence ? ` — ${row.evidence}` : "";
+    if (row.downgraded)
+        return `${downgradeText(row.downgraded)}${tail}`;
+    if (row.verdict === "superseded" && row.supersededBy) {
+        return `${assessVerdictLabel("superseded")} (${row.supersededBy})${tail}`;
+    }
+    return `${assessVerdictLabel(row.verdict)}${tail}`;
+}
+/**
+ * The reason a dismissed row carries, forever, where the row is rendered.
+ *
+ * `intoId` is the intent id the merge was posted as, which the pure layer
+ * cannot know — the host calls this a second time once it does, rather than
+ * assembling its own sentence, so the merged row and the sheet say the same
+ * thing.
+ */
+export function assessDismissReason(v, evidence, intoId) {
+    const tail = evidence ? ` — ${evidence}` : "";
+    if (v === "merged")
+        return `merged into ${intoId ? intoId : "one new item"}${tail}`;
+    return `${assessVerdictLabel(v)}${tail}`;
+}
+/** How many rows each verdict claimed — what a header says before anybody
+ *  scrolls. */
+export function assessCounts(p) {
+    const out = { done: 0, obsolete: 0, superseded: 0, merged: 0, wanted: 0, unclear: 0 };
+    for (const r of p.rows)
+        out[r.verdict]++;
+    return out;
+}
+/**
+ * **How many things this run has something to CALL** — the number the naming
+ * question is asked about.
+ *
+ * One per row, group or new item carrying a title or a kind, counted once
+ * whichever of the two it has: the question is "should these names be written",
+ * and a row with both is still one row a person is deciding about. Merges and
+ * new items are in the count for the same reason they are in the sheet — they
+ * are rows this apply will create, and a person reading "titles 14 items" must
+ * not find 16.
+ */
+export function assessNameCount(p) {
+    const has = (x) => !!x.headline || !!x.category;
+    return p.rows.filter(has).length + p.merges.filter(has).length + p.news.filter(has).length;
+}
+/** A conflict card's sentence. The ids are the caller's to draw as rows; this
+ *  is the line above them, so the sheet and any notification say it alike. */
+export function assessConflictSentence(c) {
+    return `${c.ids.length === 2 ? "these two" : `these ${c.ids.length}`} contradict each other — ${c.why}`;
+}
+/** A split card's sentence. */
+export function assessSplitSentence(s) {
+    const tail = s.rationale ? ` — ${s.rationale}` : "";
+    return `two jobs in one item: split into two, on the same clock${tail}`;
+}
+/** The reason an approved split's ORIGINAL carries once archived. `intoIds`
+ *  are the two posted rows' ids, which only the host knows. */
+export function assessSplitReason(rationale, intoIds) {
+    const into = intoIds && intoIds.length ? intoIds.join(" and ") : "two new items";
+    return `split into ${into}${rationale ? ` — ${rationale}` : ""}`;
+}
+/**
+ * **The question the apply asks about the order it is about to write**, and the
+ * two answers, worded so neither reads as the safe one.
+ *
+ * Here rather than in the sheet because the host says the same thing back on
+ * the row (`applyProposal`'s `handOrdered`) and a second wording of one fact is
+ * how two screens come to disagree about what was decided.
+ *
+ * Neither label may promise protection from a re-sort: nothing re-sorts a
+ * row on its own, so the only difference is the "placed by you" mark.
+ */
+export function assessPinQuestion(n) {
+    return `This applies an order to ${n === 1 ? "1 item" : `${n} items`}. Should it stay as you approved it?`;
+}
+export const ASSESS_PIN_KEEP = "keep this order";
+export const ASSESS_PIN_FREE = "leave it unmarked";
+/**
+ * …and what each answer means, since the consequence is not on either label.
+ * Both are true in every repo: the order is written either way, and nothing
+ * moves a row on its own afterwards.
+ */
+export function assessPinNote(pinned) {
+    return pinned
+        ? "Marked as placed by you, the way a drag is — each row says so."
+        : "The order is written either way; these rows just do not say “placed by you”. Nothing re-sorts them on its own.";
+}
+/**
+ * **The question the apply asks about the titles it is about to write**, and
+ * the two answers — `assessPinQuestion`'s shape, for the same reason it has
+ * that shape: the sheet and the host must not word one decision two ways.
+ *
+ * It names both halves of what a name is, because the row shows both and a
+ * question that said only "titles" would be asking about half of what the tap
+ * does.
+ */
+export function assessNameQuestion(n) {
+    return `This run wrote a title or a kind for ${n === 1 ? "1 item" : `${n} items`}. Should they go on the rows?`;
+}
+export const ASSESS_NAME_WRITE = "write them";
+export const ASSESS_NAME_SKIP = "leave the rows as they are";
+/**
+ * …and what each answer means.
+ *
+ * The write side says the protection out loud because it is the only thing
+ * standing between a naming run and words somebody typed, and a person deciding
+ * this has no other place to learn it. It also says the names are EDITABLE,
+ * since the honest reason to say yes is that a wrong title costs one tap.
+ *
+ * The skip side does not say "nothing happens": the suggestions are still on
+ * the sheet, and a person who wanted them somewhere else needs to know they did
+ * not evaporate.
+ */
+export function assessNameNote(write) {
+    return write
+        ? "Written as the run's — a title or kind you typed yourself is never replaced, and you can edit or clear any of them on the row."
+        : "Nothing is titled. The suggestions stay on this sheet only.";
+}
+//# sourceMappingURL=sasswords.js.map

package/node_modules/@waterplane/shared/dist/assess/sasswords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sasswords.js","sourceRoot":"","sources":["../../src/assess/sasswords.ts"],"names":[],"mappings":"AAKA,gFAAgF;AAEhF;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,CAAgB;IACjD,QAAQ,CAAC,EAAE,CAAC;QACV,KAAK,MAAM,CAAC,CAAC,OAAO,cAAc,CAAC;QACnC,KAAK,UAAU,CAAC,CAAC,OAAO,mBAAmB,CAAC;QAC5C,KAAK,YAAY,CAAC,CAAC,OAAO,yBAAyB,CAAC;QACpD,KAAK,QAAQ,CAAC,CAAC,OAAO,oBAAoB,CAAC;QAC3C,KAAK,QAAQ,CAAC,CAAC,OAAO,cAAc,CAAC;QACrC,KAAK,SAAS,CAAC,CAAC,OAAO,gBAAgB,CAAC;IAC1C,CAAC;AACH,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,aAAa,CAAC,CAAkB;IAC9C,QAAQ,CAAC,EAAE,CAAC;QACV,KAAK,aAAa,CAAC,CAAC,OAAO,mDAAmD,CAAC;QAC/E,KAAK,iBAAiB,CAAC,CAAC,OAAO,wDAAwD,CAAC;QACxF,KAAK,WAAW,CAAC,CAAC,OAAO,oDAAoD,CAAC;QAC9E,KAAK,aAAa,CAAC,CAAC,OAAO,mDAAmD,CAAC;QAC/E,KAAK,mBAAmB,CAAC,CAAC,OAAO,+DAA+D,CAAC;QACjG,KAAK,gBAAgB,CAAC,CAAC,OAAO,qCAAqC,CAAC;QACpE,KAAK,iBAAiB,CAAC,CAAC,OAAO,kEAAkE,CAAC;QAClG,KAAK,gBAAgB,CAAC,CAAC,OAAO,kDAAkD,CAAC;QACjF,KAAK,eAAe,CAAC,CAAC,OAAO,wDAAwD,CAAC;QACtF,KAAK,eAAe,CAAC,CAAC,OAAO,sDAAsD,CAAC;IACtF,CAAC;AACH,CAAC;AAED;iDACiD;AACjD,MAAM,UAAU,iBAAiB,CAAC,GAAc;IAC9C,MAAM,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACtD,IAAI,GAAG,CAAC,UAAU;QAAE,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,EAAE,CAAC;IACrE,IAAI,GAAG,CAAC,OAAO,KAAK,YAAY,IAAI,GAAG,CAAC,YAAY,EAAE,CAAC;QACrD,OAAO,GAAG,kBAAkB,CAAC,YAAY,CAAC,KAAK,GAAG,CAAC,YAAY,IAAI,IAAI,EAAE,CAAC;IAC5E,CAAC;IACD,OAAO,GAAG,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,CAAC;AACrD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,CAAgB,EAAE,QAAgB,EAAE,MAAe;IACrF,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9C,IAAI,CAAC,KAAK,QAAQ;QAAE,OAAO,eAAe,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,GAAG,IAAI,EAAE,CAAC;IACpF,OAAO,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC;AAC3C,CAAC;AAED;eACe;AACf,MAAM,UAAU,YAAY,CAAC,CAAiB;IAC5C,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IACtF,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI;QAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACzC,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAAC,CAAiB;IAC/C,MAAM,GAAG,GAAG,CAAC,CAAiD,EAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IACzG,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;AAC7F,CAAC;AAED;8EAC8E;AAC9E,MAAM,UAAU,sBAAsB,CAAC,CAAiB;IACtD,OAAO,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAC,GAAG,EAAE,CAAC;AAC1G,CAAC;AAED,+BAA+B;AAC/B,MAAM,UAAU,mBAAmB,CAAC,CAAc;IAChD,MAAM,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACpD,OAAO,0DAA0D,IAAI,EAAE,CAAC;AAC1E,CAAC;AAED;+DAC+D;AAC/D,MAAM,UAAU,iBAAiB,CAAC,SAAiB,EAAE,OAA2B;IAC9E,MAAM,IAAI,GAAG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;IACjF,OAAO,cAAc,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,MAAM,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;AACnE,CAAC;AAqDD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,CAAS;IACzC,OAAO,4BAA4B,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,sCAAsC,CAAC;AAC7G,CAAC;AACD,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAC;AACjD,MAAM,CAAC,MAAM,eAAe,GAAG,mBAAmB,CAAC;AACnD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,MAAe;IAC3C,OAAO,MAAM;QACX,CAAC,CAAC,gEAAgE;QAClE,CAAC,CAAC,gHAAgH,CAAC;AACvH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,CAAS;IAC1C,OAAO,wCAAwC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,+BAA+B,CAAC;AAClH,CAAC;AACD,MAAM,CAAC,MAAM,iBAAiB,GAAG,YAAY,CAAC;AAC9C,MAAM,CAAC,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AAC7D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,KAAK;QACV,CAAC,CAAC,gIAAgI;QAClI,CAAC,CAAC,6DAA6D,CAAC;AACpE,CAAC"}

package/node_modules/@waterplane/shared/dist/assess.d.ts

@@ -0,0 +1,58 @@
+/**
+ * What an assessment is ALLOWED to conclude.
+ *
+ * ── Why this file exists ───────────────────────────────────────────────────
+ *
+ * One button asks the CLI to read a whole repo and say, of everything still
+ * open for it, what is already done, what is obsolete, what is covered by
+ * something else, and what is still worth doing. The answer arrives as JSON the
+ * CLI wrote about the user's own words — which is the most dangerous input this
+ * app takes. A model that says "implemented" about something half-implemented
+ * is the EXPECTED failure here, not a surprising one, and the cost of believing
+ * it is a prompt somebody wrote and can no longer find.
+ *
+ * So the parse is not a parse. It is the place where a claim has to earn its
+ * verdict:
+ *
+ *   • a retiring verdict with no citation is not a verdict — it is downgraded
+ *     to `unclear`, which retires nothing;
+ *   • a `superseded` pointing at itself, at an unknown id, or round a cycle is
+ *     a graph a phone cannot audit — flattened to one hop, and anything worse
+ *     downgraded;
+ *   • a merge group — the one verdict that writes a prompt in place of the
+ *     user's own — has to be 2..MAX_MERGE_SIZE ids, each belonging to exactly
+ *     one group and to no other verdict, with a prompt that is actually there;
+ *   • an item the assessment simply did not mention comes back as `unclear`
+ *     rather than vanishing, because silence about a row is not a decision
+ *     about it.
+ *
+ * ── What is deliberately NOT here ──────────────────────────────────────────
+ *
+ * No filesystem, no `Date.now()`, no host imports — this is `intent.ts`'s
+ * posture, for `intent.ts`'s reason: the whole rule set is then pinnable from
+ * literals by `packages/shared/test/assess.test.mjs` in milliseconds, with no
+ * daemon booted and nothing spawned, which is what lets the rules be settled
+ * before there is anything that can run them.
+ *
+ * Nothing here APPLIES anything either. `applyAssessment` decides the
+ * mutations; the host performs them. That split is what makes "nothing applies
+ * itself" checkable rather than a promise: a proposal with no approvals decides
+ * nothing, and there is exactly one function that turns approvals into work.
+ *
+ * ── The one rule that is not negotiable ────────────────────────────────────
+ *
+ * Nothing here loses a prompt. Every cap below is on a COUNT, on a citation, or
+ * on a label — never on `AssessItem.text`, which is the user's own words and is
+ * passed through untouched. The two pieces of prose the CLI itself writes (a
+ * merge prompt, a new item) are not clipped either: past `MAX_PROMPT_CHARS`
+ * they are DROPPED with a note, because half an instruction that runs is worse
+ * than an instruction that never ran.
+ */
+export { ASSESS_VERDICTS, CITING_VERDICTS, MIN_MERGE_SIZE, MAX_MERGE_SIZE, MAX_MERGE_GROUPS, MAX_NEW, MAX_EVIDENCE_CHARS, MAX_RATIONALE_CHARS, MAX_PROMPT_CHARS, MAX_RANK, MAX_ASSESS_NOTES, ASSESS_IN_FILE, ASSESS_OUT_FILE, ASSESS_PLAN_FILE, MAX_CONFLICTS, MAX_CONFLICT_IDS, MAX_SPLITS, SPLIT_PARTS, cleanAssessScope } from "./assess/sassvocab.js";
+export type { AssessSource, AssessVerdict, AssessScope } from "./assess/sassvocab.js";
+export type { AssessItem, AssessNote, AssessInput, AssessDowngrade, AssessRow, AssessMerge, AssessNew, AssessProposal, AssessConflict, AssessSplit } from "./assess/sassio.js";
+export { cleanAssessment } from "./assess/sassclean.js";
+export { assessVerdictLabel, downgradeText, assessRowSentence, assessDismissReason, assessCounts, assessNameCount, assessPinQuestion, ASSESS_PIN_KEEP, ASSESS_PIN_FREE, assessPinNote, assessNameQuestion, ASSESS_NAME_WRITE, ASSESS_NAME_SKIP, assessNameNote, assessConflictSentence, assessSplitSentence, assessSplitReason } from "./assess/sasswords.js";
+export type { AssessChoices } from "./assess/sasswords.js";
+export { assessOrigin, applyAssessment } from "./assess/sassapply.js";
+export type { AssessApplyContext, AssessDismiss, AssessRank, AssessPost, AssessName, AssessMutations, AssessSplitApply } from "./assess/sassapply.js";

package/node_modules/@waterplane/shared/dist/assess.js

@@ -0,0 +1,55 @@
+/**
+ * What an assessment is ALLOWED to conclude.
+ *
+ * ── Why this file exists ───────────────────────────────────────────────────
+ *
+ * One button asks the CLI to read a whole repo and say, of everything still
+ * open for it, what is already done, what is obsolete, what is covered by
+ * something else, and what is still worth doing. The answer arrives as JSON the
+ * CLI wrote about the user's own words — which is the most dangerous input this
+ * app takes. A model that says "implemented" about something half-implemented
+ * is the EXPECTED failure here, not a surprising one, and the cost of believing
+ * it is a prompt somebody wrote and can no longer find.
+ *
+ * So the parse is not a parse. It is the place where a claim has to earn its
+ * verdict:
+ *
+ *   • a retiring verdict with no citation is not a verdict — it is downgraded
+ *     to `unclear`, which retires nothing;
+ *   • a `superseded` pointing at itself, at an unknown id, or round a cycle is
+ *     a graph a phone cannot audit — flattened to one hop, and anything worse
+ *     downgraded;
+ *   • a merge group — the one verdict that writes a prompt in place of the
+ *     user's own — has to be 2..MAX_MERGE_SIZE ids, each belonging to exactly
+ *     one group and to no other verdict, with a prompt that is actually there;
+ *   • an item the assessment simply did not mention comes back as `unclear`
+ *     rather than vanishing, because silence about a row is not a decision
+ *     about it.
+ *
+ * ── What is deliberately NOT here ──────────────────────────────────────────
+ *
+ * No filesystem, no `Date.now()`, no host imports — this is `intent.ts`'s
+ * posture, for `intent.ts`'s reason: the whole rule set is then pinnable from
+ * literals by `packages/shared/test/assess.test.mjs` in milliseconds, with no
+ * daemon booted and nothing spawned, which is what lets the rules be settled
+ * before there is anything that can run them.
+ *
+ * Nothing here APPLIES anything either. `applyAssessment` decides the
+ * mutations; the host performs them. That split is what makes "nothing applies
+ * itself" checkable rather than a promise: a proposal with no approvals decides
+ * nothing, and there is exactly one function that turns approvals into work.
+ *
+ * ── The one rule that is not negotiable ────────────────────────────────────
+ *
+ * Nothing here loses a prompt. Every cap below is on a COUNT, on a citation, or
+ * on a label — never on `AssessItem.text`, which is the user's own words and is
+ * passed through untouched. The two pieces of prose the CLI itself writes (a
+ * merge prompt, a new item) are not clipped either: past `MAX_PROMPT_CHARS`
+ * they are DROPPED with a note, because half an instruction that runs is worse
+ * than an instruction that never ran.
+ */
+export { ASSESS_VERDICTS, CITING_VERDICTS, MIN_MERGE_SIZE, MAX_MERGE_SIZE, MAX_MERGE_GROUPS, MAX_NEW, MAX_EVIDENCE_CHARS, MAX_RATIONALE_CHARS, MAX_PROMPT_CHARS, MAX_RANK, MAX_ASSESS_NOTES, ASSESS_IN_FILE, ASSESS_OUT_FILE, ASSESS_PLAN_FILE, MAX_CONFLICTS, MAX_CONFLICT_IDS, MAX_SPLITS, SPLIT_PARTS, cleanAssessScope } from "./assess/sassvocab.js";
+export { cleanAssessment } from "./assess/sassclean.js";
+export { assessVerdictLabel, downgradeText, assessRowSentence, assessDismissReason, assessCounts, assessNameCount, assessPinQuestion, ASSESS_PIN_KEEP, ASSESS_PIN_FREE, assessPinNote, assessNameQuestion, ASSESS_NAME_WRITE, ASSESS_NAME_SKIP, assessNameNote, assessConflictSentence, assessSplitSentence, assessSplitReason } from "./assess/sasswords.js";
+export { assessOrigin, applyAssessment } from "./assess/sassapply.js";
+//# sourceMappingURL=assess.js.map

package/node_modules/@waterplane/shared/dist/assess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assess.js","sourceRoot":"","sources":["../src/assess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,cAAc,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG1V,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,cAAc,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE9V,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/node_modules/@waterplane/shared/dist/attach.d.ts

@@ -0,0 +1,118 @@
+/**
+ * What became of the FILES a prompt names.
+ *
+ * A prompt written on a phone routinely says "look at
+ * `.claude/inbox/1000074539-mtjv8u52a489a0.jpg`". That path is minted BEFORE the
+ * bytes go anywhere (`plannedInboxPath`), because the text and the attachment are
+ * queued in the same breath — so between writing it and sending it the file can
+ * be in any of five states, and the path itself says nothing about which. Worse,
+ * the name is a camera counter plus a random suffix: it does not even tell the
+ * person who took the photo WHICH photo it was.
+ *
+ * That gap is where prompts died quietly. A send that gave up left its text in
+ * the queue — its own row, its full words, `retireToPad` having been deleted —
+ * naming an upload that had been canceled and its bytes deleted, so re-sending
+ * it pointed the agent at a file nobody was ever going to write. Nothing on screen distinguished that from a prompt whose image
+ * is already sitting in the repo.
+ *
+ * So the decision is made here, from facts rather than hope, and it is pure: the
+ * caller gathers what it can see (the host's own listing, the send queue, the
+ * bytes still parked on this device, the paths already known dead) and this says
+ * what may be done about each file. Pinned by `scripts/e2e-attach.mjs` —
+ * every branch is a different sentence in the UI and a different button.
+ */
+/**
+ * What can still happen to one referenced file.
+ *
+ * Ordered by how good the news is, which is also the order the rules are applied
+ * in: the host having the file outranks everything, including a local record
+ * saying the upload died — a canceled upload and a file that arrived by some
+ * other route (the agent wrote it, an earlier attempt DID land, a second device
+ * sent it) are indistinguishable from here, and the one that can be checked wins.
+ */
+export type AttachState = 
+/** The repo has it. The prompt is sendable as written. */
+"host"
+/** Its bytes are in the send queue — it uploads before the prompt that names
+ *  it (the lane rule), so this is also sendable, just not yet arrived. */
+ | "sending"
+/** Its queue entry is gone but the bytes are still on THIS device: one tap
+ *  re-queues the upload, and the path in the text stays valid. */
+ | "kept"
+/** Something recorded why it is never coming (the upload was canceled, the
+ *  host refused the file) and there are no bytes left to retry with. */
+ | "dead"
+/** The host was asked and does not have it, and nothing local knows about it.
+ *  Usually a path that outlived its upload on another device, or a hand-typed
+ *  one that was always wrong. */
+ | "missing"
+/** The host could not be asked (no link) and nothing local knows about it.
+ *  Not the same as missing, and must not be reported as it. */
+ | "unknown";
+/** Everything the caller could find out about the files in one repo. */
+export interface AttachFacts {
+    /**
+     * Repo-relative paths the host's own listing reported, or `null` when it could
+     * not be asked at all. `null` is the whole reason `unknown` exists: an empty
+     * array means "asked, it has none", which is a verdict, and conflating the two
+     * turns a dead tunnel into "your image is gone".
+     */
+    onHost: string[] | null;
+    /** Paths whose upload entry is still in the send queue (queued or in flight). */
+    sending: string[];
+    /** Paths whose bytes are retained on this device with no queue entry left. */
+    kept: string[];
+    /** Path → why it will never arrive, as recorded when its entry died. */
+    dead: Record<string, string>;
+}
+export interface AttachStatus {
+    relPath: string;
+    state: AttachState;
+    /** The recorded reason, for the states that have one (`dead`). */
+    why?: string;
+}
+/** Where one referenced file stands. See `AttachState` for the ordering. */
+export declare function attachState(relPath: string, f: AttachFacts): AttachState;
+/** The same for a whole prompt's worth of paths, in the order they were named. */
+export declare function attachStatuses(relPaths: string[], f: AttachFacts): AttachStatus[];
+/**
+ * May this prompt be sent as written?
+ *
+ * Only when every file it names will exist by the time the agent reads it —
+ * already there, or queued ahead of the prompt in the same lane. `kept` is
+ * deliberately NOT sendable: the bytes are on the phone, but nothing is
+ * uploading them, and a prompt sent now would race a re-attach that has not
+ * been asked for. It is one tap from sendable, which is what the UI offers.
+ */
+export declare function attachmentsReady(states: AttachStatus[]): boolean;
+/**
+ * The states that need a decision before sending, in the order they should be
+ * shown: the fixable one first (there is something to press), then the two that
+ * can only be dropped, then the one that is merely unverified.
+ *
+ * A prompt with no blockers is sendable; one with blockers is exactly the case
+ * "edit as new prompt" exists for.
+ */
+export declare function attachBlockers(states: AttachStatus[]): AttachStatus[];
+/** The queue facts `sending` is read from — structurally a web `OutboxEntry`. */
+export interface UploadRowLike {
+    mode?: string;
+    status: string;
+    upload?: {
+        relPath: string;
+    } | null;
+}
+/**
+ * `AttachFacts.sending` off the send queue: every upload row that will still be
+ * attempted. A row that has GIVEN UP is not sending anything, or a prompt would
+ * be called sendable on the strength of an upload that has already failed.
+ */
+export declare function sendingUploads(rows: readonly UploadRowLike[]): string[];
+/**
+ * What a cached `checkAttachments` verdict depends on in the queue, as one
+ * string: it moves when an upload is queued, lands or dies, and NOT on a
+ * progress tick or another lane's ack. The strip was keyed on nothing from the
+ * queue at all, so an upload that died after the check went on reading
+ * `sending` — sendable, no re-attach button — over a file that would never come.
+ */
+export declare function sendingUploadsKey(rows: readonly UploadRowLike[]): string;

package/node_modules/@waterplane/shared/dist/attach.js

@@ -0,0 +1,85 @@
+/**
+ * What became of the FILES a prompt names.
+ *
+ * A prompt written on a phone routinely says "look at
+ * `.claude/inbox/1000074539-mtjv8u52a489a0.jpg`". That path is minted BEFORE the
+ * bytes go anywhere (`plannedInboxPath`), because the text and the attachment are
+ * queued in the same breath — so between writing it and sending it the file can
+ * be in any of five states, and the path itself says nothing about which. Worse,
+ * the name is a camera counter plus a random suffix: it does not even tell the
+ * person who took the photo WHICH photo it was.
+ *
+ * That gap is where prompts died quietly. A send that gave up left its text in
+ * the queue — its own row, its full words, `retireToPad` having been deleted —
+ * naming an upload that had been canceled and its bytes deleted, so re-sending
+ * it pointed the agent at a file nobody was ever going to write. Nothing on screen distinguished that from a prompt whose image
+ * is already sitting in the repo.
+ *
+ * So the decision is made here, from facts rather than hope, and it is pure: the
+ * caller gathers what it can see (the host's own listing, the send queue, the
+ * bytes still parked on this device, the paths already known dead) and this says
+ * what may be done about each file. Pinned by `scripts/e2e-attach.mjs` —
+ * every branch is a different sentence in the UI and a different button.
+ */
+/** Where one referenced file stands. See `AttachState` for the ordering. */
+export function attachState(relPath, f) {
+    if (f.onHost?.includes(relPath))
+        return "host";
+    if (f.sending.includes(relPath))
+        return "sending";
+    if (f.kept.includes(relPath))
+        return "kept";
+    if (f.dead[relPath])
+        return "dead";
+    return f.onHost === null ? "unknown" : "missing";
+}
+/** The same for a whole prompt's worth of paths, in the order they were named. */
+export function attachStatuses(relPaths, f) {
+    return relPaths.map((relPath) => {
+        const state = attachState(relPath, f);
+        return state === "dead" ? { relPath, state, why: f.dead[relPath] } : { relPath, state };
+    });
+}
+/**
+ * May this prompt be sent as written?
+ *
+ * Only when every file it names will exist by the time the agent reads it —
+ * already there, or queued ahead of the prompt in the same lane. `kept` is
+ * deliberately NOT sendable: the bytes are on the phone, but nothing is
+ * uploading them, and a prompt sent now would race a re-attach that has not
+ * been asked for. It is one tap from sendable, which is what the UI offers.
+ */
+export function attachmentsReady(states) {
+    return states.every((s) => s.state === "host" || s.state === "sending");
+}
+/**
+ * The states that need a decision before sending, in the order they should be
+ * shown: the fixable one first (there is something to press), then the two that
+ * can only be dropped, then the one that is merely unverified.
+ *
+ * A prompt with no blockers is sendable; one with blockers is exactly the case
+ * "edit as new prompt" exists for.
+ */
+export function attachBlockers(states) {
+    const rank = { kept: 0, dead: 1, missing: 2, unknown: 3 };
+    return states.filter((s) => s.state in rank).sort((a, b) => rank[a.state] - rank[b.state]);
+}
+/**
+ * `AttachFacts.sending` off the send queue: every upload row that will still be
+ * attempted. A row that has GIVEN UP is not sending anything, or a prompt would
+ * be called sendable on the strength of an upload that has already failed.
+ */
+export function sendingUploads(rows) {
+    return rows.filter((e) => e.mode === "upload" && e.upload && e.status !== "failed").map((e) => e.upload.relPath);
+}
+/**
+ * What a cached `checkAttachments` verdict depends on in the queue, as one
+ * string: it moves when an upload is queued, lands or dies, and NOT on a
+ * progress tick or another lane's ack. The strip was keyed on nothing from the
+ * queue at all, so an upload that died after the check went on reading
+ * `sending` — sendable, no re-attach button — over a file that would never come.
+ */
+export function sendingUploadsKey(rows) {
+    return [...sendingUploads(rows)].sort().join("\n");
+}
+//# sourceMappingURL=attach.js.map

package/node_modules/@waterplane/shared/dist/attach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach.js","sourceRoot":"","sources":["../src/attach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAuDH,4EAA4E;AAC5E,MAAM,UAAU,WAAW,CAAC,OAAe,EAAE,CAAc;IACzD,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,MAAM,CAAC;IAC/C,IAAI,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,SAAS,CAAC;IAClD,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,MAAM,CAAC;IAC5C,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,MAAM,CAAC;IACnC,OAAO,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AACnD,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,cAAc,CAAC,QAAkB,EAAE,CAAc;IAC/D,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QAC9B,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QACtC,OAAO,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC1F,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAsB;IACrD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,MAAM,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,MAAsB;IACnD,MAAM,IAAI,GAA2B,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAClF,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAC7F,CAAC;AASD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAA8B;IAC3D,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAO,CAAC,OAAO,CAAC,CAAC;AACpH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAA8B;IAC9D,OAAO,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrD,CAAC"}