superdev-cli 0.3.0 → 0.4.0

package/.claude-plugin/marketplace.json

@@ -5,7 +5,7 @@
   },
   "metadata": {
     "description": "Superdev - tell it what you want to build, and it keeps the product map, documentation, decisions and status in step while specialist providers do the specialist work.",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "homepage": "https://github.com/superdev-ai/superdev"
   },
   "plugins": [
@@ -13,7 +13,7 @@
       "name": "superdev",
       "source": "./",
       "description": "Describe a product in ordinary language and get a living map of goals, features, workflows, tasks, integrations, UI surfaces, decisions and evidence - plus a self-contained visual dashboard. Routes specialist work to external providers and reports their readiness truthfully.",
-      "version": "0.3.0",
+      "version": "0.4.0",
       "author": {
         "name": "Rahul Retnan"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "superdev",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Describe a product in ordinary language and get a living map of goals, features, workflows, tasks, integrations, UI surfaces, decisions and evidence, plus a self-contained visual dashboard. Routes specialist work to external providers and reports their readiness truthfully.",
   "author": {
     "name": "Rahul Retnan"
@@ -16,6 +16,6 @@
   "homepage": "https://github.com/superdev-ai/superdev",
   "repository": "https://github.com/superdev-ai/superdev",
   "requires": {
-    "cli": "0.3.0"
+    "cli": "0.4.0"
   }
 }

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "superdev",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Describe a product in ordinary language and get a living map of goals, features, workflows, tasks, integrations, UI surfaces, decisions and evidence, plus a self-contained visual dashboard.",
   "author": {
     "name": "Rahul Retnan"
@@ -22,6 +22,6 @@
   "homepage": "https://github.com/superdev-ai/superdev",
   "repository": "https://github.com/superdev-ai/superdev",
   "requires": {
-    "cli": "0.3.0"
+    "cli": "0.4.0"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superdev-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Local-first product-building control system for humans and coding agents.",
   "author": "Rahul Retnan",

package/src/cli.mjs

@@ -137,6 +137,7 @@ Working
   test-plan run <id>   Run the plan and record what it produced
   test-plan record <id>  Record a plan carried out by hand
   verify               Re-run the checks the recorded evidence stands on
+  evidence supersede <id>  Retire a record that no longer applies, with the reason
   task cancel <id>     Stop work that should not continue, with a reason
   task complete <id>   Finish a task once its verification passes
   task block <id>      Record why a task cannot move
@@ -2034,9 +2035,18 @@ async function cmdTaskEvidence(ctx) {
   }
   const { attachEvidence } = await lifecycle();
   const task = await attachEvidence(ctx.root, id, evidence);
+  const also = (task.alsoProving ?? []).filter((e) => e.id !== task.evidence.id);
   return {
     data: { applied: true, task },
-    text: `${task.evidence.id} recorded against ${task.id}: ${summary}`,
+    text: R.stitch([
+      `${task.evidence.id} recorded against ${task.id}: ${summary}`,
+      // Two current records for one criterion is legitimate, and it is also how a
+      // correction looks. Saying so is what stops the older one being forgotten
+      // until verify starts failing on a command that has moved.
+      also.length
+        ? R.wrap(`${countWord(also.length, "record")} already ${also.length === 1 ? "proves" : "prove"} ${evidence.acceptanceCriterionId}: ${also.map((e) => e.id).join(", ")}. If this replaces one rather than adding to it, retire it with superdev evidence supersede ${also[0].id} --reason "<why>" --apply.`)
+        : null,
+    ]),
   };
 }
 
@@ -2207,6 +2217,38 @@ async function cmdTaskBlock(ctx) {
  * duplicate is superseded and says which task replaced it, which is the same
  * answer for the reader and a better one for the record.
  */
+/**
+ * Retire one evidence record that no longer applies.
+ *
+ * `evidence` rather than `task evidence supersede`, because the resolver reads two
+ * words and the third would be taken as a task identifier. The record is the
+ * subject here anyway, not the task.
+ */
+async function cmdEvidenceSupersede(ctx) {
+  const id = requireWord(ctx.words, 2, 'Say which record: superdev evidence supersede <EV-id> --reason "<why it no longer applies>".');
+  const reason = String(requireFlag(ctx.flags, "reason", "Superseding evidence needs a reason, because the record already said this was observed."));
+  if (!ctx.apply) {
+    return planned({ id, reason }, "supersede it", R.stitch([
+      R.wrap(`Would supersede ${id}: ${reason}`),
+      R.wrap("The record and its reason stay in history. It leaves the verification tally, and any acceptance criterion resting on it falls back to whatever else is current, or to unmet."),
+    ]));
+  }
+  const { supersedeEvidence } = await lifecycle();
+  const out = await supersedeEvidence(ctx.root, id, { reason, actor: ctx.actor });
+  return {
+    data: out,
+    text: R.stitch([
+      `${id} is superseded and no longer counted.`,
+      out.command ? R.wrap(`Its command was: ${out.command}`) : null,
+      out.criterion
+        ? R.wrap(out.criterion.restingOn
+            ? `${out.criterion.id} is still met, now resting on ${out.criterion.restingOn}.`
+            : `${out.criterion.id} is ${R.status(out.criterion.status)}, because nothing current proves it now.`)
+        : null,
+    ]),
+  };
+}
+
 async function cmdTaskMerge(ctx) {
   const duplicate = requireWord(ctx.words, 2, "Say which task is the duplicate: superdev task merge <duplicate-id> --into <TASK-id>.");
   const survivor = String(requireFlag(ctx.flags, "into", "Say which task keeps the work: --into <TASK-id>."));
@@ -3164,6 +3206,7 @@ const COMMANDS = {
   "task cancel": cmdTaskCancel,
   "task complete": cmdTaskComplete,
   "task block": cmdTaskBlock,
+  "evidence supersede": cmdEvidenceSupersede,
   "task merge": cmdTaskMerge,
   "task reopen": cmdTaskReopen,
   "docs generate": cmdDocsGenerate,
@@ -3240,7 +3283,7 @@ const COMMANDS = {
   "category restore": cmdCategoryRestore,
 };
 
-const GROUPS = new Set(["db", "task", "docs", "memory", "question", "decision", "category", "feature",
+const GROUPS = new Set(["db", "task", "docs", "memory", "question", "decision", "category", "feature", "evidence",
   "module", "goal", "milestone", "workflow", "architecture", "schema", "api", "integration", "change", "assumption", "cloud"]);
 
 function resolveCommand(words) {

package/src/runtime/hooks.mjs

@@ -491,10 +491,22 @@ async function postToolUse(root, payload) {
     // A command that looked like a write and changed nothing is not work.
     if (!changed.length) return EMPTY;
     const moved = movedSince(root, changed, readTouched(root).attributed);
-    fresh = moved.length > 0;
+    // A generated document that Superdev just rewrote is not the product changing.
+    //
+    // `docs generate` rewrites its own projection of its own database, so running it
+    // after finishing a task produced a marker saying the product had changed while
+    // no task was claimed. That is the same mistake as counting the runtime
+    // directory, and it blocked a release: doctor raised its only high-severity
+    // warning about Superdev regenerating its own files.
+    //
+    // Decided from the documents table rather than from a path prefix, because a
+    // file somebody wrote by hand under the same directory is not a generated
+    // document and should still count.
+    const product = await notGenerated(root, moved);
+    fresh = product.length > 0;
     markTouched(root, changed);
     attribute(root, moved);
-    file = file ?? changed[0];
+    file = product[0]?.[0] ?? file ?? changed[0];
   }
   markTouched(root, [file]);
   await flushTouched(root, { force: false });
@@ -601,6 +613,26 @@ export function movedSince(root, candidates, attributed) {
   return moved;
 }
 
+/**
+ * The paths among these that are not registered generated documents.
+ *
+ * Reads the documents table, which is the only authority on what Superdev wrote:
+ * a hand-authored file sitting in the same directory is not a generated document,
+ * and a hand edit to one that is becomes a proposal through its own flow rather
+ * than passing through here. A database that cannot be read leaves every path in,
+ * because failing to notice real work is the worse mistake.
+ */
+export async function notGenerated(root, moved) {
+  if (!moved.length) return moved;
+  try {
+    const rows = await query(root, (db) => db.all("SELECT path FROM documents"));
+    const generated = new Set(rows.map((r) => r.path));
+    return moved.filter(([path]) => !generated.has(path));
+  } catch {
+    return moved;
+  }
+}
+
 /** Record that these paths are accounted for, at the state they are in now. */
 function attribute(root, moved) {
   if (!moved.length) return;

package/src/tasks/lifecycle.mjs

@@ -821,6 +821,21 @@ export async function attachEvidence(root, taskId, evidence = {}) {
 
   return mutate(root, async (db) => {
     const task = await taskOr404(db, taskId);
+    // What already proves this criterion, read before the new row is written.
+    //
+    // Two current records for one criterion is legitimate: two different checks can
+    // both prove one thing. It is also how a correction is made, and the second row
+    // silently joining the first is how a project ends up with one record failing
+    // forever because its command moved. So the caller is told, and told what to do
+    // about it, rather than the product guessing which of the two was meant.
+    const alreadyProving = acceptanceCriterionId
+      ? await db.all(
+          `SELECT id, check_command FROM verification_evidence
+            WHERE acceptance_criterion_id = ? AND status = 'current' AND result = 'pass'
+            ORDER BY recorded_at, id`,
+          acceptanceCriterionId)
+      : [];
+
     if (acceptanceCriterionId && result === "pass") {
       // Fresh proof of a criterion retires the stale proof it replaces. Marking
       // evidence stale is verify saying the check stopped passing, and the
@@ -906,6 +921,9 @@ export async function attachEvidence(root, taskId, evidence = {}) {
 
     const task_after = await db.get("SELECT * FROM tasks WHERE id = ?", taskId);
     task_after.evidence = row;
+    // Carried out so the surface can say it. A correction that looks identical to a
+    // second independent proof is how one record ends up failing forever.
+    task_after.alsoProving = alreadyProving;
     return task_after;
   });
 }
@@ -960,3 +978,73 @@ export async function findTaskForWork(root, { description, featureId = null, lim
     return best.row;
   });
 }
+
+/**
+ * Retire one evidence record that no longer applies.
+ *
+ * A check whose script moved keeps failing forever, and the row cannot be
+ * corrected: `task evidence` only appends. Under the old verify allowlist such a
+ * row was refused and merely counted as unrunnable, so it was invisible; once
+ * containment let the path through, verify ran it, the file was gone, and it
+ * failed on every run of a healthy project. `decision supersede` and
+ * `memory supersede` have existed all along; this is the same shape for the one
+ * record type that is the whole basis of a completion claim.
+ *
+ * Nothing is deleted. What was observed and when is the point of keeping it, and
+ * the reason it stopped applying is worth as much as the observation was.
+ */
+export async function supersedeEvidence(root, evidenceId, { reason, actor = "superdev" } = {}) {
+  if (!reason) {
+    throw new TaskError(E.REASON_REQUIRED,
+      "Superseding evidence needs a reason, because the record already said this was observed.");
+  }
+  return mutate(root, async (db) => {
+    const row = await db.get("SELECT * FROM verification_evidence WHERE id = ?", evidenceId);
+    if (!row) {
+      throw new TaskError(E.NOT_FOUND,
+        `There is no evidence ${evidenceId}. superdev verify --json names every record it ran, and task show lists what a task carries.`);
+    }
+    if (row.status === "superseded") {
+      throw new TaskError(E.INVALID_TRANSITION, `${evidenceId} is already superseded.`);
+    }
+
+    await db.run("UPDATE verification_evidence SET status = 'superseded' WHERE id = ?", evidenceId);
+
+    // The criterion this was the proof for now rests on whatever else is current,
+    // and on nothing if there is nothing else. Leaving it met on retired proof
+    // would be the same defect as a green check that never ran.
+    let criterion = null;
+    if (row.acceptance_criterion_id) {
+      const replacement = await db.get(
+        `SELECT id FROM verification_evidence
+          WHERE acceptance_criterion_id = ? AND status = 'current' AND result = 'pass' AND id <> ?
+          ORDER BY recorded_at DESC, id DESC LIMIT 1`,
+        row.acceptance_criterion_id, evidenceId,
+      );
+      const before = await db.get(
+        "SELECT * FROM feature_acceptance_criteria WHERE id = ?", row.acceptance_criterion_id);
+      if (before && before.evidence_id === evidenceId) {
+        await db.run(
+          "UPDATE feature_acceptance_criteria SET status = ?, evidence_id = ? WHERE id = ?",
+          replacement ? "met" : "unmet", replacement?.id ?? null, row.acceptance_criterion_id,
+        );
+      }
+      criterion = {
+        id: row.acceptance_criterion_id,
+        status: before?.evidence_id === evidenceId ? (replacement ? "met" : "unmet") : before?.status ?? null,
+        restingOn: replacement?.id ?? null,
+      };
+    }
+
+    await recordActivity(db, row.project_id, {
+      type: "verification_attached",
+      actor,
+      taskId: row.task_id,
+      featureId: row.feature_id,
+      summary: `Evidence ${evidenceId} superseded: ${reason}`,
+      metadata: { evidenceId, reason, criterion: row.acceptance_criterion_id ?? null },
+    });
+
+    return { evidenceId, was: row.status, summary: row.summary, command: row.check_command ?? null, criterion };
+  });
+}