thoth-agents 0.3.10 → 0.3.12

package/skills/thoth-sdd/SKILL.md

@@ -1,6 +1,11 @@
 ---
 name: thoth-sdd
-description: Run thoth-agents Direct, Accelerated, or Full specification-driven development with Spec Kit-grade artifacts, OpenSpec-style durable deltas, fast-forward planning, and oracle-only analysis and verification.
+description: Run thoth-agents Direct, Accelerated, or Full specification-driven development with Spec Kit-grade artifacts, OpenSpec-style durable deltas, fast-forward planning, and proportional independent verification.
+license: MIT
+compatibility: Requires Node.js >=22.13 for bundled validation scripts.
+metadata:
+  author: thoth-agents
+  version: "1.0"
 ---
 
 # Thoth SDD
@@ -18,21 +23,53 @@ intent is clear and risk is low.
 
 Accelerated is a **fast-forward** route: root writes `spec.md`, `plan.md`, and
 `tasks.md` in one uninterrupted pass and creates optional artifacts only for a
-concrete risk. After `ready`, both artifact-backed routes pause once to offer
+concrete risk. After `ready`, both artifact-backed routes offer
 `Review plan with Oracle (Recommended)` or `Proceed without review`. Full uses
 separate planning gates because uncertainty or failure cost justifies them.
 
 An explicitly named route counts as the user's selection. Otherwise assess and
-recommend Direct, Accelerated, or Full, then wait for the user to choose; the
-recommendation is not the decision. A generic request to “use SDD” makes
-Accelerated the minimum recommendation but does not force it.
+recommend Direct, Accelerated, or Full, first summarize the relevant request
+context, scope, clarity, risk, and why the recommendation fits, then ask. When a
+native route question returns answerless, make at most three total attempts;
+after the third answerless result, treat the recommended route as selected. Any
+explicit answer wins. A generic request to “use SDD” makes Accelerated the
+minimum recommendation but does not force it.
+
+At the post-`ready` review choice, an explicit answer wins, including
+`Proceed without review`. When the native question returns answerless, make at
+most three total attempts; after the third answerless result, treat
+`Review plan with Oracle (Recommended)` as selected. Once review is selected,
+repair actionable same-intent planning blockers, revalidate affected gates, and
+use a fresh Oracle for every new approval round until `[OKAY]`; stop instead on
+a material human-owned blocker.
+
+These bounded fallbacks apply only to the route, plan-review, and implementation
+questions. Never apply them to secrets, destructive or security-sensitive
+actions, or material human-owned product or architecture decisions.
 
 ## Ownership
 
 - Root owns sequential coordination artifacts, gate execution, and archive.
 - Explorer owns Full-route repository discovery.
-- Designer, quick, deep, or root may implement according to scope.
-- Oracle owns `plan-review` when the user selects it and **every** `verify`. The
+- SDD routes govern artifacts and gates, not implementation ownership. Root,
+  `designer`, `quick`, or `deep` may implement in Direct, Accelerated, or Full.
+- Root decides ownership from explicit safe user direction and demonstrated net
+  gain. Delegation benefits include specialization, context isolation,
+  independent bounded work, quality, latency, or total cost; root continuity
+  benefits include short or sequential work, shared mutable state, accumulated
+  context, rediscovery, and coordination overhead. Route, file count, or cheaper
+  model price alone never selects an owner.
+- Only after deciding to delegate implementation, select `designer` for UI/UX,
+  `quick` for known narrow low-risk work, or `deep` for coupled, edge-case-heavy,
+  migration, concurrency, shared-contract, or high-risk work.
+- Each mutable surface has one writer; independent non-overlapping surfaces may
+  split, while coupled surfaces use one `deep` writer and ordered handoffs.
+- Oracle owns `plan-review` when review is explicitly selected or chosen by the
+  bounded recommended fallback. Every route requires
+  mandatory verification, but final-verification ownership is proportional:
+  trivial deterministic Direct work may be verified by Root when Root is not
+  self-approving its own implementation; materially risky Direct work and every
+  Accelerated or Full final verify require a fresh read-only Oracle. The
   implementation writer never approves its own work.
 
 ## Progressive loading
@@ -78,10 +115,10 @@ node "<skill-dir>/scripts/validate.mjs" --change openspec/changes/<feature> --ro
 - **Checklist**: run only when activated; the later `ready` gate includes it if
   present.
 
-`ready` validates the artifacts needed before the user chooses
-`Review plan with Oracle (Recommended)` or `Proceed without review`. Review
-approval remains separate from implementation confirmation and never satisfies
-final verification.
+`ready` validates the artifacts needed before the explicit or bounded-default
+`Review plan with Oracle (Recommended)` / `Proceed without review` choice.
+Review approval remains separate from implementation confirmation and never
+satisfies final verification.
 `closeout` additionally requires completed tasks, independent oracle PASS,
 complete FR/buildable-SC evidence, an observed PASS or explicit residual RISK
 for every outcome SC, and an archive report ready for the transactional archive

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

@@ -1,12 +1,42 @@
 # Implement contract
 
-**Owner**: root, designer, quick, or deep; exactly one writer per mutable surface
+**Owner**: adaptive root, `designer`, `quick`, or `deep` in every route; exactly
+one writer per mutable surface
 
-Root marks selected artifact-backed tasks `[~]`, then assigns exact paths,
-accepted FR/buildable-SC scope, non-goals, and verification commands. Use the
-mandatory `tdd` skill for behavior changes and work in vertical red/green
-slices. Child writers never edit task state; root marks `[x]` only after checking
-task-specific evidence.
+SDD routes govern artifacts and gates, not implementation ownership. Before
+implementation or dispatch, root records the decided owner, task-shape/net-gain
+rationale, exact paths, accepted FR/buildable-SC scope, non-goals, and
+verification commands. Route, file count, or cheaper model price alone is not an
+ownership rationale.
+
+Root may retain implementation when short or sequential work, shared mutable
+state, accumulated context, rediscovery, or coordination overhead outweighs
+delegation benefit. Delegate when specialization, context isolation, independent
+bounded work, quality, latency, or total cost creates demonstrated net gain. If
+root owns the surface, do not dispatch a writer. If a specialist owns it, send a
+bounded handoff with the exact surface, requirements, and checks.
+
+Root marks selected artifact-backed tasks `[~]`; Direct or no-artifact work has
+no task state. Use the mandatory `tdd` skill for behavior changes and work in
+vertical red/green slices. Child writers never edit task state; root marks `[x]`
+only after checking task-specific evidence.
+
+After deciding delegation creates net gain, select deterministically:
+
+- `designer` for user-facing UI/UX, interaction, accessibility, responsive, or
+  visual-quality work;
+- `quick` for a known narrow mechanical low-risk surface with exact targets;
+- `deep` for coupled multi-file, shared-contract, migration, concurrency,
+  edge-case-heavy, or high-risk work.
+
+Proven independent surfaces may use different writers only with non-overlapping
+ownership. Overlapping or compatibility-coupled work uses one `deep` writer and
+ordered handoffs. A writer escalates before expanding beyond its routing
+boundary. Every route requires mandatory verification, and the implementation
+writer never approves its own work. For trivial deterministic Direct work, Root
+may run the proportionate focused checks when Root is not self-approving its own
+implementation. For materially risky Direct work and every Accelerated or Full
+final verify, root hands the unchanged candidate to a fresh read-only Oracle.
 
 Implementation evidence may refine an artifact without restarting the workflow:
 
@@ -17,3 +47,11 @@ Implementation evidence may refine an artifact without restarting the workflow:
   silently expanding this one.
 
 Report files changed, checks executed, deviations, and remaining work.
+
+## Native dispatch groups and waves
+
+For each ready group, confirm prerequisites, ordered lane tasks, exact path
+union, owner, requirements, and checks. Select the capacity-bounded set of
+undispatched ready lanes and create one fresh native specialist assignment per admitted lane. Issue every dispatch in that native wave before any wait, status,
+result collection, or root implementation action. Retain handles; when terminal evidence frees capacity, dispatch the next undispatched ready lane before waiting again. Validate terminal evidence per lane, while root alone updates task state. Cross the declared barrier only after every lane is terminal and reconciled. Preserve truthful capability/capacity fallback: when native
+concurrency is unavailable or width is one, use a truthful sequential fallback.

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.10",
-      "author": {
-        "name": "thoth-agents maintainers"
-      },
-      "source": "./plugin",
-      "category": "productivity",
-      "homepage": "https://github.com/EremesNG/thoth-agents"
-    }
-  ]
-}