thoth-agents 0.3.11 → 0.4.0

package/skills/thoth-sdd/references/phases/tasks.md

@@ -22,6 +22,27 @@ not justify artificial implementation tasks.
 
 Order test-first work before its implementation, group tasks by independently
 deliverable story, identify the MVP, and state dependencies. `[P]` is permitted
-only when mutable paths provably do not overlap and the Parallel execution
-section names a concrete pairing. If there is no safe parallel work, use
+only for tasks assigned to a declared lane whose mutable path union does not
+overlap another lane in the same group. If there is no safe parallel work, use
 `- None: <evidence-backed reason>` instead. Avoid ceremonial tasks.
+
+## Parallel execution
+
+Declare safe work with this exact grammar:
+
+### Group P1
+
+- Lane L1: T001 -> T002 | Owner: deep
+- Lane L2: T003 -> T004 | Owner: quick
+- Prerequisites: None
+- Barrier: Final verification
+- Rationale: Both lane path sets are disjoint and neither lane consumes peer output.
+
+Groups and lanes are sequential and unique. Every `[P]` task belongs to exactly one lane; non-`[P]` tasks do not. Lane surfaces are the union of exact task
+paths, and lanes in a group have disjoint surfaces and no cross-lane dependency.
+The `Rationale` must explicitly state path-disjointness and cross-lane dependency
+evidence so structural validation can gate the evidence shape and Oracle can
+judge whether the claim is true.
+Prerequisites name known tasks outside the group; the barrier is a downstream
+task or `Final verification` after all lane members. If no group exists, use
+only `- None: <evidence-backed reason>` and no task may use `[P]`.

package/skills/thoth-sdd/references/phases/verify.md

@@ -1,10 +1,12 @@
 # Verify contract
 
-**Owner**: oracle, always read-only and independent
+**Owner**: route- and risk-aware; Root for trivial deterministic Direct, otherwise a fresh read-only Oracle
 
-Oracle verifies Direct, Accelerated, and Full work. The root or writer that
-implemented the change cannot substitute for oracle. Inspect changed code and
-run or validate the smallest sufficient checks.
+Every route requires mandatory verification. Trivial deterministic Direct work
+may be verified by Root with focused deterministic checks. Materially risky
+Direct work and Accelerated or Full final verification use a fresh read-only
+Oracle. The implementation writer never approves its own work. Inspect changed
+code and run or validate the smallest sufficient checks.
 
 Judge three dimensions separately: **completeness** of accepted scope and
 coverage, **correctness** against behavioral contracts and executed evidence,
@@ -16,7 +18,7 @@ task.
 
 Return `pass` or `fail`, compliance matrix, commands/results, stable findings,
 critical issues, warnings, and remediation anchors. For Direct, return the
-verdict in-session. For Accelerated and Full, root persists oracle's exact result
+verdict in-session regardless of owner. For Accelerated and Full, root persists Oracle's exact result
 using `<skill-dir>/templates/verify-report.md`, where `<skill-dir>` is the
 directory containing the installed `thoth-sdd/SKILL.md`. Fail routes to converge
 (straight back to implement for Direct); PASS permits closeout and archive for

package/skills/thoth-sdd/scripts/validate.mjs

@@ -540,6 +540,97 @@ function exactTaskPath(line) {
   return normalized.toLowerCase();
 }
 
+function taskDependencyEdges(content) {
+  return [...content.matchAll(/\bT\d{3}(?:\s*->\s*T\d{3})+\b/g)].flatMap(
+    ([chain]) => {
+      const ids = chain.match(/\bT\d{3}\b/g) ?? [];
+      return ids.slice(1).map((target, index) => ({
+        source: ids[index],
+        target,
+      }));
+    },
+  );
+}
+
+function parseParallelGroups(content) {
+  const lines = content.split(/\r?\n/);
+  const headingIndexes = lines
+    .map((line, index) => (/^###\s+Group\s+P\d+\s*$/.test(line) ? index : -1))
+    .filter((index) => index >= 0);
+  const groups = [];
+  let valid = headingIndexes.length > 0;
+
+  if (
+    lines
+      .slice(0, headingIndexes[0] ?? lines.length)
+      .some((line) => line.trim())
+  ) {
+    valid = false;
+  }
+
+  for (const [groupIndex, start] of headingIndexes.entries()) {
+    const end = headingIndexes[groupIndex + 1] ?? lines.length;
+    const groupId = /^###\s+Group\s+P(\d+)\s*$/.exec(lines[start])?.[1];
+    const body = lines.slice(start + 1, end).filter((line) => line.trim());
+    const lanes = [];
+    let prerequisites;
+    let barrier;
+    let rationale;
+    for (const line of body) {
+      const lane =
+        /^- Lane L(\d+): (T\d{3}(?: -> T\d{3})*)(?: \| Owner: (\S+))?\s*$/.exec(
+          line,
+        );
+      if (lane) {
+        lanes.push({
+          number: Number.parseInt(lane[1], 10),
+          taskIds: lane[2].split(' -> '),
+          owner: lane[3],
+        });
+        continue;
+      }
+      const prerequisiteLine =
+        /^- Prerequisites: (None|T\d{3}(?:, T\d{3})*)\s*$/.exec(line);
+      if (prerequisiteLine && prerequisites === undefined) {
+        prerequisites =
+          prerequisiteLine[1] === 'None' ? [] : prerequisiteLine[1].split(', ');
+        continue;
+      }
+      const barrierLine = /^- Barrier: (Final verification|T\d{3})\s*$/.exec(
+        line,
+      );
+      if (barrierLine && barrier === undefined) {
+        barrier = barrierLine[1];
+        continue;
+      }
+      const rationaleLine = /^- Rationale: (\S.*)$/.exec(line);
+      if (rationaleLine && rationale === undefined) {
+        rationale = rationaleLine[1];
+        continue;
+      }
+      valid = false;
+    }
+    if (
+      groupId === undefined ||
+      lanes.length < 2 ||
+      rationale === undefined ||
+      !isConcreteEvidence(rationale) ||
+      lanes.some((lane, index) => lane.number !== index + 1)
+    ) {
+      valid = false;
+    }
+    groups.push({
+      number: Number.parseInt(groupId ?? '0', 10),
+      lanes,
+      prerequisites,
+      barrier,
+      rationale,
+    });
+  }
+  if (groups.some((group, index) => group.number !== index + 1)) valid = false;
+  return { groups, valid };
+}
+
 function validateTasks(content, errors, spec) {
   const artifact = 'tasks.md';
   const taskLines = content
@@ -644,12 +735,6 @@ function validateTasks(content, errors, spec) {
   }));
   const tasksById = new Map(taskRecords.map((task) => [task.id, task]));
   const hasParallelTask = taskRecords.some((task) => task.parallel);
-  const parallelLines = (parallelSection ?? '')
-    .split(/\r?\n/)
-    .map((line) => [line, [...new Set(line.match(/\bT\d{3}\b/g) ?? [])]])
-    .filter(([, ids]) => ids.length >= 2);
-  const referencedTaskIds = new Set(parallelLines.flatMap(([, ids]) => ids));
-  const hasParallelExample = parallelLines.length > 0;
   const noParallelMatch = /^-\s+None:\s*(\S.*)$/im.exec(parallelSection ?? '');
   const explainsNoParallelWork =
     noParallelMatch !== null && isConcreteEvidence(noParallelMatch[1]);
@@ -657,42 +742,190 @@ function validateTasks(content, errors, spec) {
     left === right ||
     left.startsWith(`${right}/`) ||
     right.startsWith(`${left}/`);
-  const unknownReferences = [...referencedTaskIds].filter(
-    (id) => !tasksById.has(id),
+  const noneOnly =
+    explainsNoParallelWork &&
+    parallelSection?.trim() === noParallelMatch?.[0].trim();
+  const { groups, valid: validGroupGrammar } = parseParallelGroups(
+    parallelSection ?? '',
   );
-  const omittedParallelTasks = taskRecords
-    .filter((task) => task.parallel && !referencedTaskIds.has(task.id))
-    .map((task) => task.id);
-  const examplesWithoutParallelTask = parallelLines.some(
-    ([, ids]) => !ids.some((id) => tasksById.get(id)?.parallel),
+  const declaredDependencies = taskDependencyEdges(
+    sectionContent(content, 'Dependencies') ?? '',
   );
-  const overlappingExamples = parallelLines.some(([, ids]) => {
-    const paths = ids.map((id) => tasksById.get(id)?.path);
-    if (paths.some((path) => path === undefined)) return true;
-    return paths.some((path, index) =>
-      paths.slice(index + 1).some((other) => pathsOverlap(path, other)),
-    );
-  });
+  const hasGroups = groups.length > 0;
   if (
     parallelSection === undefined ||
-    (explainsNoParallelWork && hasParallelExample) ||
-    (hasParallelTask &&
-      (!hasParallelExample ||
-        explainsNoParallelWork ||
-        unknownReferences.length > 0 ||
-        omittedParallelTasks.length > 0 ||
-        examplesWithoutParallelTask ||
-        overlappingExamples)) ||
-    (!hasParallelTask && !explainsNoParallelWork)
+    (hasParallelTask && (!hasGroups || explainsNoParallelWork)) ||
+    (!hasParallelTask && !noneOnly) ||
+    (explainsNoParallelWork && !noneOnly)
   ) {
     errors.push(
       issue(
         'SDD-TASK-PARALLEL',
         artifact,
-        'Document existing [P] tasks with non-overlapping paths, or explain why no safe parallel work exists.',
+        'Declare strict parallel groups for [P] tasks, or provide one exclusive evidence-backed None reason.',
+      ),
+    );
+  }
+  if (hasGroups && !validGroupGrammar) {
+    errors.push(
+      issue(
+        'SDD-TASK-LANE-GRAMMAR',
+        artifact,
+        'Groups and lanes must use unique sequential IDs, at least two lanes, and every required field.',
       ),
     );
   }
+
+  if (hasGroups && validGroupGrammar) {
+    const memberships = groups.flatMap((group) =>
+      group.lanes.flatMap((lane) =>
+        lane.taskIds.map((taskId) => ({ group, lane, taskId })),
+      ),
+    );
+    const membershipCounts = new Map();
+    for (const { taskId } of memberships) {
+      membershipCounts.set(taskId, (membershipCounts.get(taskId) ?? 0) + 1);
+    }
+    const invalidMembership =
+      memberships.some(({ taskId }) => !tasksById.get(taskId)?.parallel) ||
+      taskRecords.some(
+        (task) => task.parallel && membershipCounts.get(task.id) !== 1,
+      );
+    if (invalidMembership) {
+      errors.push(
+        issue(
+          'SDD-TASK-LANE-MEMBERSHIP',
+          artifact,
+          'Every [P] task must belong to exactly one lane, and lane members must be known [P] tasks.',
+        ),
+      );
+    }
+
+    if (
+      groups.some((group) =>
+        group.lanes.some(
+          (lane) => !['designer', 'quick', 'deep'].includes(lane.owner),
+        ),
+      )
+    ) {
+      errors.push(
+        issue(
+          'SDD-TASK-LANE-OWNER',
+          artifact,
+          'Every lane owner must be designer, quick, or deep.',
+        ),
+      );
+    }
+
+    for (const group of groups) {
+      const rationale = group.rationale ?? '';
+      const hasPathIndependenceEvidence =
+        /\b(?:path|file|surface)s?\b/i.test(rationale) &&
+        /\b(?:disjoint|non[- ]?overlap(?:ping)?)\b/i.test(rationale);
+      const hasDependencyIndependenceEvidence =
+        /\b(?:dependenc(?:y|ies)|consum(?:e|es|ing)|peer output|data flow)\b/i.test(
+          rationale,
+        );
+      if (!hasPathIndependenceEvidence || !hasDependencyIndependenceEvidence) {
+        errors.push(
+          issue(
+            'SDD-TASK-LANE-RATIONALE',
+            artifact,
+            'Parallel rationale must state concrete path-disjointness and cross-lane dependency evidence for Oracle review.',
+          ),
+        );
+      }
+
+      const memberIds = new Set(group.lanes.flatMap((lane) => lane.taskIds));
+      const prerequisites = group.prerequisites ?? [];
+      if (
+        group.prerequisites === undefined ||
+        new Set(prerequisites).size !== prerequisites.length ||
+        prerequisites.some(
+          (taskId) => !tasksById.has(taskId) || memberIds.has(taskId),
+        )
+      ) {
+        errors.push(
+          issue(
+            'SDD-TASK-LANE-PREREQUISITE',
+            artifact,
+            'Prerequisites must be unique known tasks outside the group.',
+          ),
+        );
+      }
+
+      const memberNumbers = [...memberIds].map((id) =>
+        Number.parseInt(id.slice(1), 10),
+      );
+      const barrierNumber = /^T\d{3}$/.test(group.barrier ?? '')
+        ? Number.parseInt(group.barrier.slice(1), 10)
+        : undefined;
+      if (
+        group.barrier !== 'Final verification' &&
+        (barrierNumber === undefined ||
+          !tasksById.has(group.barrier) ||
+          memberIds.has(group.barrier) ||
+          prerequisites.includes(group.barrier) ||
+          memberNumbers.some((number) => barrierNumber <= number))
+      ) {
+        errors.push(
+          issue(
+            'SDD-TASK-LANE-BARRIER',
+            artifact,
+            'A task barrier must be a known downstream non-member task, or use exact Final verification.',
+          ),
+        );
+      }
+
+      const laneByTask = new Map(
+        group.lanes.flatMap((lane) =>
+          lane.taskIds.map((taskId) => [taskId, lane.number]),
+        ),
+      );
+      if (
+        declaredDependencies.some(
+          ({ source, target }) =>
+            laneByTask.has(source) &&
+            laneByTask.has(target) &&
+            laneByTask.get(source) !== laneByTask.get(target),
+        )
+      ) {
+        errors.push(
+          issue(
+            'SDD-TASK-LANE-DEPENDENCY',
+            artifact,
+            'Declared dependencies cannot connect different lanes in one group.',
+          ),
+        );
+      }
+
+      const lanePaths = group.lanes.map((lane) =>
+        lane.taskIds.map((taskId) => tasksById.get(taskId)?.path),
+      );
+      const overlaps = lanePaths.some((paths, index) =>
+        lanePaths
+          .slice(index + 1)
+          .some((otherPaths) =>
+            paths.some(
+              (path) =>
+                path !== undefined &&
+                otherPaths.some(
+                  (other) => other !== undefined && pathsOverlap(path, other),
+                ),
+            ),
+          ),
+      );
+      if (overlaps) {
+        errors.push(
+          issue(
+            'SDD-TASK-LANE-OVERLAP',
+            artifact,
+            'Mutable task paths cannot overlap across lanes in one group.',
+          ),
+        );
+      }
+    }
+  }
 }
 
 function validateChecklist(content, errors, spec, requireComplete) {

package/skills/thoth-sdd/templates/tasks.md

@@ -32,8 +32,24 @@ for them.
 
 ## Parallel execution
 
-[Replace the anchor with exactly one form: concrete task pairings covering every
-`[P]` task, or `- None: <evidence-backed reason>`. Never keep both forms.]
+Use this exact grammar when safe parallel work exists:
+
+### Group P1
+
+- Lane L1: T001 -> T002 | Owner: deep
+- Lane L2: T003 -> T004 | Owner: quick
+- Prerequisites: None
+- Barrier: Final verification
+- Rationale: Both lane path sets are disjoint and neither lane consumes peer output.
+
+Groups and lanes are sequential and unique. Every `[P]` task belongs to exactly one lane; non-`[P]` tasks do not. Lane surfaces are the union of exact task
+paths, and lanes in a group have disjoint surfaces and no cross-lane dependency.
+The `Rationale` must explicitly state path-disjointness and cross-lane dependency
+evidence so structural validation can gate the evidence shape and Oracle can
+judge whether the claim is true.
+Prerequisites name known tasks outside the group; the barrier is a downstream
+task or `Final verification` after all lane members. If no group exists, use
+only `- None: <evidence-backed reason>` and no task may use `[P]`.
 
 <!-- PARALLEL-EXECUTION-EVIDENCE -->
 

package/.agents/plugins/marketplace.json

@@ -1,20 +0,0 @@
-{
-  "name": "thoth-agents",
-  "interface": {
-    "displayName": "thoth-agents Adaptive Orchestration"
-  },
-  "plugins": [
-    {
-      "name": "thoth-agents",
-      "source": {
-        "source": "local",
-        "path": "./plugin"
-      },
-      "policy": {
-        "installation": "AVAILABLE",
-        "authentication": "ON_INSTALL"
-      },
-      "category": "Productivity"
-    }
-  ]
-}

package/.claude-plugin/marketplace.json

@@ -1,21 +0,0 @@
-{
-  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
-  "name": "thoth-agents",
-  "description": "Adaptive orchestration with seven roles and runtime-autonomous direct, accelerated, and full Spec Kit-compatible SDD routes.",
-  "owner": {
-    "name": "thoth-agents maintainers"
-  },
-  "plugins": [
-    {
-      "name": "thoth-agents",
-      "description": "Adaptive root orchestration, six specialist subagents, and a runtime-autonomous Spec Kit-compatible SDD bundle.",
-      "version": "0.3.11",
-      "author": {
-        "name": "thoth-agents maintainers"
-      },
-      "source": "./plugin",
-      "category": "productivity",
-      "homepage": "https://github.com/EremesNG/thoth-agents"
-    }
-  ]
-}