@tacuchi/agent-workflow-cli 21.7.1 → 21.9.0

package/dist/domain/session/custody.js

@@ -0,0 +1,176 @@
+/**
+ * What a session RECEIVED, what it CREATED and what it CHANGED — sealed, and
+ * written before the session can produce a single effect.
+ *
+ * `SESSION.md`'s `## Origin` was the only record of where a run came from, and it
+ * is prose: it can say "derived from the plan 024" and still not answer the two
+ * questions a retirement has to answer before deleting anything. Which artifacts
+ * existed BEFORE this run, byte for byte? And which of the things that exist now
+ * are this run's, as opposed to somebody else's work that happens to sit in the
+ * same tree? Neither is derivable from names, dates or tags, and guessing either
+ * one wrong destroys work nobody can reconstruct.
+ *
+ * So custody is the authority and `## Origin` becomes its human projection:
+ *
+ * - **Born with the session, in the same operation.** A session that exists
+ *   without custody could already have mutated something by the time anybody
+ *   thinks to record a baseline, and a baseline taken afterwards is a fiction.
+ * - **A baseline is bytes or an explicit absence.** "The file was not there" is a
+ *   fact a restore needs as much as its previous content; leaving it implicit is
+ *   what turns a reset into a delete.
+ * - **Effects are receipts, never inferences.** A commit's SHAs come back from
+ *   the commit that made them. Reading ownership off a commit MESSAGE would make
+ *   the advisor's convention load-bearing, and a message is not evidence.
+ * - **Incomplete is a refusal, not a partial answer.** A custody that cannot say
+ *   what it received blocks the mutation that would promise retirement later,
+ *   because the alternative is promising a retirement that cannot be delivered.
+ *
+ * Custody lives INSIDE its session folder and dies with it. A durable record
+ * outside would outlive the thing it describes — a parallel history of deleted
+ * work, which is precisely the surface `S025/AC-04` says must not exist.
+ */
+import { semanticDigest } from "../../application/semantic-operation/protocol.js";
+/** Bumped only when a reader can no longer trust the older shape. */
+export const CUSTODY_VERSION = 1;
+/** Session-local file the record lives in. Dot-prefixed: it is not an artifact. */
+export const CUSTODY_FILE = ".custody.json";
+/** The one way to digest a baseline's bytes, shared with the proposal's bases. */
+export function baselineDigest(text) {
+    return semanticDigest(text);
+}
+/** A baseline for a path that was not there. Explicit, never an absent field. */
+export const ABSENT_BASELINE = {
+    existed: false,
+    digest: null,
+    bytes: null,
+    content: null,
+};
+/** A baseline that preserves the previous text, for what only we can restore. */
+export function preservedBaseline(content) {
+    return {
+        existed: true,
+        digest: baselineDigest(content),
+        bytes: Buffer.byteLength(content, "utf8"),
+        content,
+    };
+}
+export function sealCustody(input) {
+    const body = {
+        version: CUSTODY_VERSION,
+        subject: input.subject,
+        subject_path: input.subjectPath,
+        parents: [...(input.parents ?? [])],
+        created: input.created,
+        artifacts: [...(input.artifacts ?? [])],
+        sources: [...(input.sources ?? [])],
+        effects: [...(input.effects ?? [])],
+    };
+    return { ...body, digest: custodyDigest(body) };
+}
+/**
+ * The seal, over the SET rather than the order things were appended in.
+ *
+ * Two custodies that recorded the same facts in a different order are the same
+ * custody, and a digest that disagreed would report tampering on a detail nobody
+ * can see. Content travels as its own digest so the seal stays a fixed size
+ * whatever the preserved bytes weigh.
+ */
+export function custodyDigest(body) {
+    return semanticDigest({
+        version: body.version,
+        subject: body.subject,
+        subject_path: body.subject_path,
+        parents: [...body.parents].sort(nodeOrder),
+        created: body.created,
+        artifacts: [...body.artifacts]
+            .map((a) => ({
+            path: a.path,
+            role: a.role,
+            before: {
+                existed: a.before.existed,
+                digest: a.before.digest,
+                bytes: a.before.bytes,
+                content_digest: a.before.content === null ? null : baselineDigest(a.before.content),
+            },
+        }))
+            .sort((a, b) => order(a.path, b.path)),
+        sources: [...body.sources].sort((a, b) => order(a.alias, b.alias)),
+        effects: [...body.effects],
+    });
+}
+function nodeOrder(a, b) {
+    return order(`${a.kind}:${a.key}`, `${b.kind}:${b.key}`);
+}
+/** Code-unit ordering, the same reason `canonicalJson` avoids `localeCompare`. */
+function order(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Whether this record can still answer "what did the session receive".
+ *
+ * Called at two very different moments and that is deliberate: before a mutation
+ * that promises retirement, and again before a retirement is prepared. The first
+ * refuses to make the promise; the second refuses to pretend it was kept. Both
+ * read the same rule, so a session that was allowed to mutate is never one whose
+ * retirement turns out to be unprovable.
+ */
+export function custodyCompleteness(custody) {
+    const gaps = [];
+    if (custody.version !== CUSTODY_VERSION) {
+        gaps.push({
+            what: `versión de custodia ${custody.version}`,
+            why: `este CLI sella y lee la versión ${CUSTODY_VERSION}`,
+        });
+    }
+    if (custody.digest !== custodyDigest(stripDigest(custody))) {
+        gaps.push({
+            what: "sello de la custodia",
+            why: "el registro no coincide con su digest: fue editado fuera del CLI",
+        });
+    }
+    for (const artifact of custody.artifacts) {
+        if (artifact.role !== "input")
+            continue;
+        if (artifact.before.existed && artifact.before.digest === null) {
+            gaps.push({
+                what: `baseline de '${artifact.path}'`,
+                why: "la entrada existía y no se conservó su estado previo",
+            });
+        }
+    }
+    for (const source of custody.sources) {
+        if (source.baseline_head === null && source.unit_branch !== null) {
+            gaps.push({
+                what: `baseline git de '${source.alias}'`,
+                why: "la sesión tomó una unidad sobre una fuente cuyo HEAD no se registró",
+            });
+        }
+    }
+    return { complete: gaps.length === 0, gaps };
+}
+function stripDigest(custody) {
+    const { digest: _digest, ...body } = custody;
+    return body;
+}
+/**
+ * Every commit this session can prove is its own, per source.
+ *
+ * Two independent readings, and both are receipts rather than heuristics: the
+ * commits a typed commit reported making, and — for a session with its own unit
+ * — the range its branch advanced over its recorded baseline. The second is what
+ * covers commits the agent made with plain git inside its unit: the branch is
+ * the session's by convention and the baseline is sealed, so the range is
+ * exclusive by construction and needs nobody's commit message.
+ */
+export function attributableCommits(custody, alias) {
+    const seen = new Set();
+    for (const effect of custody.effects) {
+        if (effect.kind !== "commit" && effect.kind !== "unit_integrated")
+            continue;
+        if (effect.alias !== alias || effect.after === null)
+            continue;
+        seen.add(effect.after);
+    }
+    return [...seen];
+}
+//# sourceMappingURL=custody.js.map

package/dist/domain/session/custody.js.map

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

package/dist/domain/workline-node.js

@@ -0,0 +1,56 @@
+/**
+ * The identity of a Workline node, said the same way by everybody who points at
+ * one.
+ *
+ * Provenance is a graph over four kinds of thing — a spec, a plan, a quick and a
+ * session — and until now each reader spelled them its own way: the index keys
+ * plans by `number`, sessions by folder, and a session's `## Origin` names its
+ * parent in prose. Prose is exactly what cannot carry an edge: two readings of
+ * "derived from the plan 024" can disagree about which document that is, and a
+ * retirement that guessed wrong would delete somebody else's work.
+ *
+ * So a node has ONE canonical id, `<kind>:<key>`, and every edge is a pair of
+ * those. The path is carried beside the id rather than inside it because a
+ * document can move: identity is `plan:024`, the path is where it lives today,
+ * and a stale path is a warning while a wrong id is a defect.
+ */
+export const WORKLINE_KINDS = ["spec", "plan", "quick", "session"];
+const KIND_SET = new Set(WORKLINE_KINDS);
+export function isWorklineKind(value) {
+    return typeof value === "string" && KIND_SET.has(value);
+}
+/** `plan:024` — the one spelling of a node, in output and in a seal alike. */
+export function formatNodeId(id) {
+    return `${id.kind}:${id.key}`;
+}
+const DOC_PATH_RE = /(?:^|\/)docs\/(specs|plans)\/(\d{3})-(spec|plan)(?:-[^/]*)?\.md$/i;
+/**
+ * The node a document path IS — `docs/plans/024-plan-x.md` is `plan:024`.
+ *
+ * This is not inferring provenance from a name: the workspace's own layout fixes
+ * that a spec lives at `docs/specs/NNN-spec-*.md`, and the board already reads
+ * every spec and plan by exactly this shape. Identity is what the path declares;
+ * what the document is DERIVED from is a different question, answered by the
+ * document's own `Derived from` line or by a session's sealed custody.
+ */
+export function nodeFromDocPath(path) {
+    const m = DOC_PATH_RE.exec(path.split("\\").join("/"));
+    if (m?.[2] === undefined)
+        return null;
+    return { kind: m[1]?.toLowerCase() === "specs" ? "spec" : "plan", key: m[2] };
+}
+/**
+ * Why an edge is believed.
+ *
+ * `custody` and `derived-from` are provable: one was sealed by the CLI when the
+ * node was born, the other is the plan's own machine-readable `Derived from`
+ * line. `origin-prose` is the legacy reading of a free-text `## Origin`, and it
+ * is kept SEPARATE precisely so a retirement can refuse to act on it — an edge
+ * nobody can prove is the one case where deleting is not recoverable.
+ */
+export const EDGE_EVIDENCE = ["custody", "derived-from", "origin-prose"];
+/** Whether an edge is strong enough for a destructive closure to include it. */
+export function isProvable(evidence) {
+    return evidence === "custody" || evidence === "derived-from";
+}
+//# sourceMappingURL=workline-node.js.map

package/dist/domain/workline-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workline-node.js","sourceRoot":"","sources":["../../src/domain/workline-node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAU,CAAC;AAa5E,MAAM,QAAQ,GAAwB,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC;AAE9D,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,YAAY,CAAC,EAAkB;IAC7C,OAAO,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,WAAW,GAAG,mEAAmE,CAAC;AAExF;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,MAAM,CAAC,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACtC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAChF,CAAC;AAiBD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,cAAc,CAAU,CAAC;AAIlF,gFAAgF;AAChF,MAAM,UAAU,UAAU,CAAC,QAAsB;IAC/C,OAAO,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,cAAc,CAAC;AAC/D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tacuchi/agent-workflow-cli",
-  "version": "21.7.1",
+  "version": "21.9.0",
   "description": "Runtime CLI for Workline — the stages + loops + artifacts system for agent work. Bundles the universal `w` skill set under `skills/w/` (slash commands `/w:*`: spec-new/spec-refine, plan-new/plan-exec, quick, persist, workspace-init, export-*); `self install --target <host>` copies SKILL + commands + hooks into the host. Pluggable capability skills via `.workflow/skills.toml`. Multi-empresa parametrization via `profile.json` cascade. Namespace auto-detected from any `.<ns>/sessions/` dir in CWD; default `workflow`.",
   "type": "module",
   "bin": {

package/skills/w/commands/discard.md

@@ -0,0 +1,49 @@
+---
+description: Use to retire a spec, plan, quick or session for good with everything it exclusively owns. `aw discard` resolves the closure from sealed provenance, previews it whole and applies it all-or-nothing on one approval. Never rewrites git history.
+argument-hint: "<spec:NNN | plan:PPP | quick:NNN | session:NNN|carpeta | ruta>"
+allowed-tools: ["Bash", "Read"]
+---
+
+# discard — retire work and everything it exclusively owns
+
+No loop, no session — the closure can include the session that would be driving it.
+Output in the **user's language**.
+
+**Hard floor:**
+
+1. **`prepare` first, always** — read-only: no session, no journal, no file, no ref,
+   so a wrong target costs nothing.
+2. **You never decide the scope.** It comes from sealed custody and each document's
+   `Derived from`; a descendant nobody can prove is a REFUSAL, not a guess.
+3. **One approval, over the exact digest.** `apply` recomputes under the workspace
+   lock and refuses if anything material moved. Approving is not applying.
+4. **Reverts are commits, never rewrites** — no `reset --hard`, rebase, amend, force
+   or push; a published commit's revert leaves its push pending and external.
+
+## Run
+
+1. `aw discard prepare <objetivo> --format human` — what disappears, which local
+   change is dropped, which SHA gets a revert, which unit is reconciled, which
+   `HISTORY` row it adds, and the **digest**.
+2. Show that preview and ask approval. If it touches git history, say so: approving
+   also authorizes commits.
+3. `aw discard apply <objetivo> --approval <digest> --format human`.
+4. A rejection names cause, candidates and next action; **nothing was applied**.
+   `024` resolves only while one node answers to it.
+
+## What the CLI decides (do not re-derive)
+
+- **The closure**, in removal order; a node something outside also descends from
+  blocks the whole operation.
+- **Attribution** of changes and commits, from baselines and receipts — never from a
+  message, an author or a tag.
+- **Whether all-or-nothing holds**: two publication units, a conflicting revert, an
+  operation in progress or an unsyncable tree block before anything mutates.
+- **What survives**: the originals stay reachable and the only durable Workline trace
+  is one append-only `HISTORY` row.
+
+## More context
+
+`aw context-plan --command discard --root "${CLAUDE_PLUGIN_ROOT}/skills/w"` lists what to read.
+
+- Back to before an **incomplete** session instead: `/w:reset`.

package/skills/w/commands/reset.md

@@ -0,0 +1,50 @@
+---
+description: Use to undo an incomplete session and put its document back as it was before that session ran. `aw reset` restores the inputs byte for byte and retires the session, all-or-nothing on one approval. Never rewrites git history.
+argument-hint: "<plan:PPP | session:NNN|carpeta | ruta>"
+allowed-tools: ["Bash", "Read"]
+---
+
+# reset — put an incomplete session's inputs back
+
+No loop, no session. Output in the **user's language**. It is **not**
+`/w:plan-refine`: refining carries a document forward keeping validated phases, this
+takes it back to the bytes it had before the session started.
+
+**Hard floor:**
+
+1. **`prepare` first, always** — read-only, so a wrong target costs nothing.
+2. **Only an INCOMPLETE session.** One that converged does not become resettable by
+   being selected, and `.closed` is never the test: a session closed with work
+   pending is exactly this case.
+3. **The target must resolve to ONE incomplete session**; two is a rejection with its
+   candidates, and then you name the session.
+4. **One approval, over the exact digest.** `apply` recomputes under the lock and
+   refuses if the document moved since the preview.
+5. **Reverts are commits, never rewrites** — no `reset --hard`, rebase, amend, force
+   or push, whatever this command's name suggests.
+
+## Run
+
+1. `aw reset prepare <objetivo> --format human` — which session it resolved, which
+   paths go back to their previous bytes and whether they moved since the baseline,
+   what disappears, which SHA gets a revert, and the **digest**.
+2. Show that preview and ask approval; if it touches git history, say so.
+3. `aw reset apply <objetivo> --approval <digest> --format human`.
+4. A rejection names cause, candidates and next action; **nothing was applied**.
+
+## What the CLI decides (do not re-derive)
+
+- **Which session** an artifact resolves to, and whether it is incomplete.
+- **What "before" was**: the baseline sealed at creation. Never reconstructed from
+  names, dates or tags — without it, it fails closed.
+- **Inputs vs outputs**: an input returns to its bytes, an output is removed, and a
+  document with work of its own blocks instead of being orphaned. A quick with no
+  base document is retired whole.
+- **All-or-nothing**: either the scope is intact, or the result is complete, not
+  resumable, and leaves one append-only `HISTORY` row.
+
+## More context
+
+`aw context-plan --command reset --root "${CLAUDE_PLUGIN_ROOT}/skills/w"` lists what to read.
+
+- Deleting a document and everything under it: `/w:discard`.