thoth-agents 0.3.10 → 0.3.11

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

@@ -1,12 +1,39 @@
 # 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. The implementation writer never performs final verification; root
+hands the unchanged candidate to a fresh Oracle.
 
 Implementation evidence may refine an artifact without restarting the workflow:
 

package/skills/thoth-archive/scripts/archive.mjs

@@ -300,16 +300,36 @@ function parseStoryScenarios(spec) {
     const covers =
       /^\*\*Covers\*\*:\s*(.+)$/im.exec(story)?.[1].match(/\bFR-\d{3}\b/g) ??
       [];
-    const scenarios = [
-      ...story.matchAll(
-        /^\d+\.\s+\*\*Given\*\*\s+(.+?),\s+\*\*When\*\*\s+(.+?),\s+\*\*Then\*\*\s+(.+?)\.?\s*$/gim,
-      ),
-    ].map((scenario, scenarioIndex) => ({
-      title: `US${storyMatch[1]} - ${storyMatch[2].trim()} ${scenarioIndex + 1}`,
-      given: scenario[1].trim(),
-      when: scenario[2].trim(),
-      result: scenario[3].trim(),
-    }));
+    const acceptanceMarker = /^\*\*Acceptance scenarios\*\*:\s*$/im.exec(story);
+    const acceptance = acceptanceMarker
+      ? story.slice((acceptanceMarker.index ?? 0) + acceptanceMarker[0].length)
+      : '';
+    const scenarioStarts = [
+      ...acceptance.matchAll(/^\d+\.\s+\*\*Given\*\*/gim),
+    ];
+    const scenarios = scenarioStarts.map((scenarioStart, scenarioIndex) => {
+      const start = scenarioStart.index ?? 0;
+      const end = scenarioStarts[scenarioIndex + 1]?.index ?? acceptance.length;
+      const normalized = acceptance
+        .slice(start, end)
+        .replace(/\s+/g, ' ')
+        .trim();
+      const scenario =
+        /^\d+\.\s+\*\*Given\*\*\s+(.+?),\s+\*\*When\*\*\s+(.+?),\s+\*\*Then\*\*\s+(.+?)\.?\s*$/i.exec(
+          normalized,
+        );
+      if (!scenario) {
+        throw new Error(
+          `US${storyMatch[1]} acceptance scenario ${scenarioIndex + 1} must use Given, When, and Then`,
+        );
+      }
+      return {
+        title: `US${storyMatch[1]} - ${storyMatch[2].trim()} ${scenarioIndex + 1}`,
+        given: scenario[1].trim(),
+        when: scenario[2].trim(),
+        result: scenario[3].trim(),
+      };
+    });
 
     for (const requirementId of covers) {
       const current = scenariosByRequirement.get(requirementId) ?? [];

package/skills/thoth-sdd/SKILL.md

@@ -31,7 +31,19 @@ Accelerated the minimum recommendation but does not force it.
 
 - 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.
+- 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 the user selects it and **every** `verify`. The
   implementation writer never approves its own work.
 

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

@@ -1,12 +1,39 @@
 # 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. The implementation writer never performs final verification; root
+hands the unchanged candidate to a fresh Oracle.
 
 Implementation evidence may refine an artifact without restarting the workflow: