Files
archie/internal/workflow/skillbuild/skillbuild_test.go
T
sam f8df051b19 feat: bounded concurrent task dispatch in daemon (archie-core-u64)
Daemon previously processed one task at a time. Add bounded concurrent
dispatch for SQLite and NATS agent modes, reusing [containers].max_concurrency
(0 = unlimited). Same-repository tasks stay FIFO-serialized to avoid worktree
conflicts; different repositories now run concurrently.

Unblocks archie-core-l1q (NATS transport) and archie-core-g1l
(per-repo allow_concurrent override).
2026-07-24 07:42:13 +10:00

920 lines
26 KiB
Go

package skillbuild
import (
"context"
"os"
"path/filepath"
"testing"
"github.com/samcharles93/archie-core/internal/workflow"
)
// ── workflows built from skill plugins ────────────────────────────────
func TestBuildWorkflowFromSkillPlugins(t *testing.T) {
dir := t.TempDir()
skillDir := filepath.Join(dir, ".agents", "skills", "archie-wf-greet")
pluginsDir := filepath.Join(skillDir, "plugins")
if err := os.MkdirAll(pluginsDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
name: archie-wf-greet
description: A custom greeting workflow built entirely from plugins.
version: 1.0.0
metadata:
archie:
workflow: greet
---
Greet the world, then say goodbye.
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(pluginsDir, "01-hello.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "hello", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = "hello from plugin"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(pluginsDir, "02-world.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "world", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = tc.BuildSummary + " world"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
entry := SkillWorkflow{Workflow: "greet", Dir: "archie-wf-greet"}
wf, err := BuildWorkflow(dir, entry)
if err != nil {
t.Fatal(err)
}
if wf.Name != "greet" {
t.Errorf("Workflow.Name = %q, want greet", wf.Name)
}
if len(wf.Stages) != 2 {
t.Fatalf("got %d stages, want 2", len(wf.Stages))
}
if wf.Stages[0].Name != "hello" {
t.Errorf("stage[0].Name = %q, want hello", wf.Stages[0].Name)
}
if wf.Stages[1].Name != "world" {
t.Errorf("stage[1].Name = %q, want world", wf.Stages[1].Name)
}
// Run the workflow — stages must execute in order.
tc := &workflow.TaskContext{BuildSummary: ""}
for _, s := range wf.Stages {
if err := s.Run(context.Background(), tc); err != nil {
t.Fatalf("stage %s failed: %v", s.Name, err)
}
}
if tc.BuildSummary != "hello from plugin world" {
t.Errorf("BuildSummary = %q, want 'hello from plugin world'", tc.BuildSummary)
}
}
func TestBuildWorkflowMissingSkillReturnsEmptyWorkflow(t *testing.T) {
// Missing plugins directory is not an error — same pattern as
// wfeval.Discover. Returns a Workflow with no stages.
entry := SkillWorkflow{Workflow: "nonexistent", Dir: "nonexistent"}
wf, err := BuildWorkflow(t.TempDir(), entry)
if err != nil {
t.Fatal(err)
}
if len(wf.Stages) != 0 {
t.Errorf("got %d stages, want 0 for nonexistent skill", len(wf.Stages))
}
}
// ── registry built from skill catalog ────────────────────────────────
func TestBuildRegistryFromSkillCatalog(t *testing.T) {
// When .agents/skills/ contains directories with metadata.archie.workflow,
// BuildRegistry must return a workflow.Registry with those workflows
// built from their stage plugins. Workflows not declared by any skill
// fall back to the built-in definitions (bootstrap, implement, tdd,
// feasibility, default→implement).
dir := t.TempDir()
// Skill 1: archie-wf-greet — plugin-defined workflow.
greetDir := filepath.Join(dir, ".agents", "skills", "archie-wf-greet", "plugins")
if err := os.MkdirAll(greetDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(greetDir, "01-hello.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "hello", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = "greet-plugin-ran"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(filepath.Dir(greetDir), "SKILL.md"), []byte(`---
name: archie-wf-greet
description: Greet workflow from plugins
version: 1.0.0
metadata:
archie:
workflow: greet
---
Greet the user.
`), 0o644); err != nil {
t.Fatal(err)
}
// Skill 2: archie-wf-implement — overrides the built-in implement workflow.
implDir := filepath.Join(dir, ".agents", "skills", "archie-wf-custom-impl", "plugins")
if err := os.MkdirAll(implDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(implDir, "01-plan.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "custom-plan", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = "custom-impl-ran"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(filepath.Dir(implDir), "SKILL.md"), []byte(`---
name: archie-wf-custom-impl
description: Custom implement workflow
version: 1.0.0
metadata:
archie:
workflow: implement
---
Custom implementation workflow.
`), 0o644); err != nil {
t.Fatal(err)
}
reg, err := BuildRegistry(dir)
if err != nil {
t.Fatal(err)
}
// Skill-defined workflows must be present.
t.Run("skill-defined workflow is registered", func(t *testing.T) {
wf, ok := reg["greet"]
if !ok {
t.Fatal("BuildRegistry did not register workflow 'greet' from skill catalog")
}
if wf.Name != "greet" {
t.Errorf("Workflow.Name = %q, want greet", wf.Name)
}
if len(wf.Stages) == 0 {
t.Error("workflow 'greet' has no stages — plugin stages not loaded")
}
// Run it — stages must execute.
tc := &workflow.TaskContext{BuildSummary: ""}
for _, s := range wf.Stages {
if err := s.Run(context.Background(), tc); err != nil {
t.Fatalf("stage %s: %v", s.Name, err)
}
}
if tc.BuildSummary != "greet-plugin-ran" {
t.Errorf("BuildSummary = %q, want 'greet-plugin-ran'", tc.BuildSummary)
}
})
// Skill override of built-in must take precedence.
t.Run("skill overrides built-in workflow", func(t *testing.T) {
wf, ok := reg["implement"]
if !ok {
t.Fatal("BuildRegistry did not register workflow 'implement'")
}
if len(wf.Stages) == 0 {
t.Fatal("workflow 'implement' has no stages")
}
tc := &workflow.TaskContext{BuildSummary: ""}
for _, s := range wf.Stages {
if err := s.Run(context.Background(), tc); err != nil {
t.Fatalf("stage %s: %v", s.Name, err)
}
}
if tc.BuildSummary != "custom-impl-ran" {
t.Errorf("BuildSummary = %q, want 'custom-impl-ran' — skill override did not take effect", tc.BuildSummary)
}
})
// Built-in fallback: tdd is not declared by any skill.
t.Run("built-in fallback for undeclared workflow", func(t *testing.T) {
wf, ok := reg["tdd"]
if !ok {
t.Fatal("BuildRegistry missing built-in fallback for 'tdd'")
}
if wf.Name != "tdd" {
t.Errorf("Workflow.Name = %q, want tdd", wf.Name)
}
if len(wf.Stages) == 0 {
t.Error("built-in tdd workflow has no stages")
}
})
// "default" key must always exist.
t.Run("default key exists", func(t *testing.T) {
wf, ok := reg["default"]
if !ok {
t.Fatal("BuildRegistry missing 'default' workflow key")
}
if len(wf.Stages) == 0 {
t.Error("default workflow has no stages")
}
})
}
func TestBuildRegistryNoSkillsReturnsBuiltins(t *testing.T) {
// When .agents/skills/ does not exist, BuildRegistry returns the
// built-in workflow set so the daemon can still route tasks.
reg, err := BuildRegistry(t.TempDir())
if err != nil {
t.Fatal(err)
}
builtins := []string{"bootstrap", "implement", "tdd", "feasibility", "default"}
for _, name := range builtins {
wf, ok := reg[name]
if !ok {
t.Errorf("BuildRegistry missing built-in workflow %q when no skills exist", name)
continue
}
if wf.Name != name && !(name == "default" && wf.Name == "implement") {
t.Errorf("built-in %q: Name = %q, want %q", name, wf.Name, name)
}
}
}
func TestBuildRegistrySkillWithNoWorkflowDeclaredIsIgnored(t *testing.T) {
// A skill directory without metadata.archie.workflow must not
// produce a registry entry. It's a utility skill, not a workflow.
dir := t.TempDir()
skillDir := filepath.Join(dir, ".agents", "skills", "archie-wf-utils")
if err := os.MkdirAll(skillDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
name: archie-wf-utils
description: Utility helpers, not a workflow
version: 1.0.0
metadata:
archie:
tools: [go]
---
Utility content.
`), 0o644); err != nil {
t.Fatal(err)
}
reg, err := BuildRegistry(dir)
if err != nil {
t.Fatal(err)
}
// There is no workflow called "utils" because the skill didn't declare one.
if _, ok := reg["utils"]; ok {
t.Error("BuildRegistry registered 'utils' as a workflow, but the skill " +
"did not declare metadata.archie.workflow — only skills that declare " +
"a workflow should produce registry entries")
}
// Built-ins must still be present.
if _, ok := reg["implement"]; !ok {
t.Error("built-in 'implement' missing when a non-workflow skill exists")
}
}
func TestBuildRegistryEmptySkillsDirReturnsBuiltins(t *testing.T) {
// An empty .agents/skills/ directory must not cause an error.
dir := t.TempDir()
if err := os.MkdirAll(filepath.Join(dir, ".agents", "skills"), 0o755); err != nil {
t.Fatal(err)
}
reg, err := BuildRegistry(dir)
if err != nil {
t.Fatal(err)
}
if _, ok := reg["implement"]; !ok {
t.Error("built-in 'implement' missing when skills dir is empty")
}
}
// ── per-worktree registry augmentation ───────────────────────────────
func TestAugmentRegistryAddsWorktreeWorkflows(t *testing.T) {
// When a worktree contains .agents/skills/ with workflow-declaring
// skills, AugmentRegistry must add those workflows to the base
// registry. Workflows already in the base are not duplicated.
worktree := t.TempDir()
skillDir := filepath.Join(worktree, ".agents", "skills", "archie-wf-custom")
pluginsDir := filepath.Join(skillDir, "plugins")
if err := os.MkdirAll(pluginsDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
name: archie-wf-custom
description: Custom workflow from worktree
version: 1.0.0
metadata:
archie:
workflow: custom
---
Custom worktree workflow.
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(pluginsDir, "01-do.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "do", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = "worktree-custom-ran"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
base := workflow.Registry{"default": {Name: "default", Stages: nil}}
aug, err := AugmentRegistry(worktree, base)
if err != nil {
t.Fatal(err)
}
// Base entries preserved.
if _, ok := aug["default"]; !ok {
t.Error("'default' missing from augmented registry")
}
// Worktree workflow added.
wf, ok := aug["custom"]
if !ok {
t.Fatal("'custom' workflow not found in augmented registry — worktree skill was not discovered")
}
if wf.Name != "custom" {
t.Errorf("Workflow.Name = %q, want custom", wf.Name)
}
if len(wf.Stages) != 1 {
t.Fatalf("got %d stages, want 1", len(wf.Stages))
}
if wf.Stages[0].Name != "do" {
t.Errorf("stage[0].Name = %q, want do", wf.Stages[0].Name)
}
// Run the worktree workflow.
tc := &workflow.TaskContext{BuildSummary: ""}
if err := wf.Stages[0].Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if tc.BuildSummary != "worktree-custom-ran" {
t.Errorf("BuildSummary = %q, want 'worktree-custom-ran'", tc.BuildSummary)
}
}
func TestAugmentRegistryWorktreeOverridesBase(t *testing.T) {
// A worktree skill declaring the same workflow name as a base entry
// must take precedence. Worktree skills ARE the repo's workflow
// definition.
worktree := t.TempDir()
skillDir := filepath.Join(worktree, ".agents", "skills", "archie-wf-implement")
pluginsDir := filepath.Join(skillDir, "plugins")
if err := os.MkdirAll(pluginsDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
name: archie-wf-implement
description: Repo-specific implement workflow
version: 1.0.0
metadata:
archie:
workflow: implement
---
Repo-custom implement.
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(pluginsDir, "01-repo-plan.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "repo-plan", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = "repo-implement-override"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
// Base has "implement" as a built-in.
base := workflow.Registry{"implement": {Name: "implement", Stages: []workflow.Stage{
{Name: "builtin-plan", Run: func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = "builtin-implement"
return nil
}},
}}}
aug, err := AugmentRegistry(worktree, base)
if err != nil {
t.Fatal(err)
}
wf, ok := aug["implement"]
if !ok {
t.Fatal("'implement' missing from augmented registry")
}
if len(wf.Stages) != 1 {
t.Fatalf("got %d stages, want 1 from worktree override", len(wf.Stages))
}
if wf.Stages[0].Name != "repo-plan" {
t.Errorf("stage[0].Name = %q, want 'repo-plan' from worktree override", wf.Stages[0].Name)
}
// Run it — must use worktree version.
tc := &workflow.TaskContext{BuildSummary: ""}
if err := wf.Stages[0].Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if tc.BuildSummary != "repo-implement-override" {
t.Errorf("BuildSummary = %q, want 'repo-implement-override' (worktree override)", tc.BuildSummary)
}
}
func TestAugmentRegistryDoesNotModifyBase(t *testing.T) {
// AugmentRegistry returns a NEW registry — the caller's base must
// not be mutated.
base := workflow.Registry{"keep": {Name: "keep"}}
worktree := t.TempDir()
aug, err := AugmentRegistry(worktree, base)
if err != nil {
t.Fatal(err)
}
// Augmented has the entry.
if _, ok := aug["keep"]; !ok {
t.Fatal("'keep' missing from augmented registry")
}
// Mutating augmented must not affect base.
aug["keep"] = workflow.Workflow{Name: "modified"}
if base["keep"].Name != "keep" {
t.Error("AugmentRegistry mutated the base registry — must return a copy")
}
}
func TestAugmentRegistryNonexistentWorktreeReturnsBase(t *testing.T) {
base := workflow.Registry{"default": {Name: "default"}}
aug, err := AugmentRegistry("/nonexistent/worktree/path", base)
if err != nil {
t.Fatal(err)
}
if len(aug) != len(base) {
t.Errorf("got %d entries, want %d (nonexistent worktree adds nothing)", len(aug), len(base))
}
}
func TestAugmentRegistryWorktreeWithNoSkillsReturnsBase(t *testing.T) {
// A worktree without .agents/skills/ must not error — returns
// a copy of the base unchanged.
worktree := t.TempDir()
base := workflow.Registry{"default": {Name: "default"}}
aug, err := AugmentRegistry(worktree, base)
if err != nil {
t.Fatal(err)
}
if len(aug) != len(base) {
t.Errorf("got %d entries, want %d (no skills in worktree)", len(aug), len(base))
}
}
func TestAugmentRegistryWorktreeSkillWithNoStagesDoesNotOverride(t *testing.T) {
// A skill that declares a workflow but has no plugins must not
// override the base entry — it would produce an empty workflow.
worktree := t.TempDir()
skillDir := filepath.Join(worktree, ".agents", "skills", "archie-wf-empty")
if err := os.MkdirAll(skillDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
name: archie-wf-empty
description: Workflow with no stages
version: 1.0.0
metadata:
archie:
workflow: implement
---
No plugins here.
`), 0o644); err != nil {
t.Fatal(err)
}
base := workflow.Registry{"implement": {Name: "implement", Stages: []workflow.Stage{
{Name: "builtin", Run: func(ctx context.Context, tc *workflow.TaskContext) error { return nil }},
}}}
aug, err := AugmentRegistry(worktree, base)
if err != nil {
t.Fatal(err)
}
wf := aug["implement"]
if len(wf.Stages) == 0 {
t.Error("worktree skill with no stages overrode base — must keep base when skill is empty")
}
if wf.Stages[0].Name != "builtin" {
t.Error("base stage was replaced by empty worktree skill")
}
}
// ── AugmentRegistry adversarial tests ────────────────────────────────
func TestAugmentRegistryConcurrentAccess(t *testing.T) {
// AugmentRegistry must be safe to call concurrently from different
// goroutines (e.g. multiple tasks processed in parallel).
worktree := t.TempDir()
skillDir := filepath.Join(worktree, ".agents", "skills", "archie-wf-concurrent")
pluginsDir := filepath.Join(skillDir, "plugins")
if err := os.MkdirAll(pluginsDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
name: archie-wf-concurrent
description: Concurrent test
version: 1.0.0
metadata:
archie:
workflow: concurrent
---
Concurrent.
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(pluginsDir, "01-step.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "step", func(ctx context.Context, tc *workflow.TaskContext) error {
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
base := workflow.Registry{"default": {Name: "default"}}
// Run 10 concurrent augmentations — none should panic or corrupt state.
errs := make(chan error, 10)
for range 10 {
go func() {
aug, err := AugmentRegistry(worktree, base)
if err != nil {
errs <- err
return
}
if _, ok := aug["concurrent"]; !ok {
errs <- nil // would use sentinel but keeping simple
return
}
errs <- nil
}()
}
for range 10 {
if err := <-errs; err != nil {
t.Error("concurrent AugmentRegistry failed:", err)
}
}
// Base must still be unmodified.
if _, ok := base["concurrent"]; ok {
t.Error("base registry was mutated by concurrent augmentation")
}
}
func TestAugmentRegistryBrokenSkillMDIsSkipped(t *testing.T) {
// A SKILL.md with invalid YAML must not crash augmentation — the
// skill is simply skipped (skill.Catalog skips parse errors).
worktree := t.TempDir()
skillDir := filepath.Join(worktree, ".agents", "skills", "archie-wf-broken")
if err := os.MkdirAll(skillDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
this is not valid: [[[ YAML {{{
---
Body.
`), 0o644); err != nil {
t.Fatal(err)
}
base := workflow.Registry{"default": {Name: "default"}}
aug, err := AugmentRegistry(worktree, base)
if err != nil {
t.Fatal("AugmentRegistry errored on broken SKILL.md:", err)
}
if len(aug) != len(base) {
t.Errorf("got %d entries, want %d (broken SKILL.md adds nothing)", len(aug), len(base))
}
}
func TestAugmentRegistryWorktreeWithNoSkillsDir(t *testing.T) {
// A worktree that exists but has no .agents/ directory at all
// must not error.
worktree := t.TempDir()
// Don't create .agents/skills/ — just a bare worktree.
if err := os.WriteFile(filepath.Join(worktree, "README.md"), []byte(`# repo`), 0o644); err != nil {
t.Fatal(err)
}
base := workflow.Registry{"default": {Name: "default"}}
aug, err := AugmentRegistry(worktree, base)
if err != nil {
t.Fatal("AugmentRegistry errored on worktree without .agents/: ", err)
}
if len(aug) != len(base) {
t.Errorf("got %d entries, want %d", len(aug), len(base))
}
}
func TestAugmentRegistryNilBaseReturnsEmpty(t *testing.T) {
// A nil base registry must be treated as empty — not panic.
worktree := t.TempDir()
aug, err := AugmentRegistry(worktree, nil)
if err != nil {
t.Fatal("AugmentRegistry errored with nil base:", err)
}
if aug == nil {
t.Error("AugmentRegistry returned nil for nil base — want empty registry")
}
if len(aug) != 0 {
t.Errorf("got %d entries with nil base and no skills, want 0", len(aug))
}
}
func TestBuildRegistryNoStagesReturnsEmptyWorkflow(t *testing.T) {
dir := t.TempDir()
skillDir := filepath.Join(dir, ".agents", "skills", "archie-wf-empty")
if err := os.MkdirAll(skillDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(`---
name: archie-wf-empty
description: No stages
version: 1.0.0
metadata:
archie:
workflow: empty
---
Body.
`), 0o644); err != nil {
t.Fatal(err)
}
entry := SkillWorkflow{Workflow: "empty", Dir: "archie-wf-empty"}
wf, err := BuildWorkflow(dir, entry)
if err != nil {
t.Fatal(err)
}
if len(wf.Stages) != 0 {
t.Errorf("got %d stages, want 0", len(wf.Stages))
}
if wf.Name != "empty" {
t.Errorf("Workflow.Name = %q, want empty", wf.Name)
}
}
// ── resilience: skip broken plugins, don't abort ────────────────────
func TestBuildWorkflowSkipsBrokenPlugin(t *testing.T) {
// R2: one broken stage plugin must not abort the entire workflow.
// Valid plugins before and after the broken one must still load.
dir := t.TempDir()
pluginsDir := filepath.Join(dir, ".agents", "skills", "archie-wf-resilient", "plugins")
if err := os.MkdirAll(pluginsDir, 0o755); err != nil {
t.Fatal(err)
}
// First plugin — valid.
if err := os.WriteFile(filepath.Join(pluginsDir, "01-setup.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "setup", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = "setup-ran"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
// Second plugin — BROKEN (syntax error).
if err := os.WriteFile(filepath.Join(pluginsDir, "02-broken.go"), []byte(`package main
this is %% NOT VALID GO @@@@
`), 0o644); err != nil {
t.Fatal(err)
}
// Third plugin — valid.
if err := os.WriteFile(filepath.Join(pluginsDir, "03-teardown.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "teardown", func(ctx context.Context, tc *workflow.TaskContext) error {
tc.BuildSummary = tc.BuildSummary + " teardown-ran"
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(filepath.Dir(pluginsDir), "SKILL.md"), []byte(`---
name: archie-wf-resilient
description: Resilient workflow
version: 1.0.0
metadata:
archie:
workflow: resilient
---
Resilient workflow.
`), 0o644); err != nil {
t.Fatal(err)
}
entry := SkillWorkflow{Workflow: "resilient", Dir: "archie-wf-resilient"}
wf, err := BuildWorkflow(dir, entry)
if err != nil {
t.Fatalf("BuildWorkflow returned error instead of skipping broken plugin: %v", err)
}
if len(wf.Stages) != 2 {
t.Fatalf("got %d stages, want 2 (broken plugin skipped)", len(wf.Stages))
}
if wf.Stages[0].Name != "setup" {
t.Errorf("stage[0].Name = %q, want setup", wf.Stages[0].Name)
}
if wf.Stages[1].Name != "teardown" {
t.Errorf("stage[1].Name = %q, want teardown", wf.Stages[1].Name)
}
// Run the surviving stages.
tc := &workflow.TaskContext{BuildSummary: ""}
for _, s := range wf.Stages {
if err := s.Run(context.Background(), tc); err != nil {
t.Fatalf("stage %s: %v", s.Name, err)
}
}
if tc.BuildSummary != "setup-ran teardown-ran" {
t.Errorf("BuildSummary = %q, want 'setup-ran teardown-ran'", tc.BuildSummary)
}
}
func TestBuildRegistrySkipsBrokenSkill(t *testing.T) {
// R2: a skill with broken plugins must not prevent other skills
// from registering — and must not block daemon startup.
dir := t.TempDir()
// Skill 1: valid workflow.
goodDir := filepath.Join(dir, ".agents", "skills", "archie-wf-good", "plugins")
if err := os.MkdirAll(goodDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(goodDir, "01-step.go"), []byte(`package main
import (
"context"
"github.com/samcharles93/archie-core/internal/workflow"
)
func Stage() (string, func(context.Context, *workflow.TaskContext) error) {
return "step", func(ctx context.Context, tc *workflow.TaskContext) error {
return nil
}
}
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(filepath.Dir(goodDir), "SKILL.md"), []byte(`---
name: archie-wf-good
description: Good workflow
version: 1.0.0
metadata:
archie:
workflow: good
---
Good.
`), 0o644); err != nil {
t.Fatal(err)
}
// Skill 2: broken plugins — ALL plugins are broken.
badDir := filepath.Join(dir, ".agents", "skills", "archie-wf-bad", "plugins")
if err := os.MkdirAll(badDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(badDir, "01-broken.go"), []byte(`package main
%%% SYNTAX ERROR @@@
`), 0o644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(filepath.Dir(badDir), "SKILL.md"), []byte(`---
name: archie-wf-bad
description: Broken workflow
version: 1.0.0
metadata:
archie:
workflow: bad
---
Broken.
`), 0o644); err != nil {
t.Fatal(err)
}
reg, err := BuildRegistry(dir)
if err != nil {
t.Fatalf("BuildRegistry returned error instead of skipping broken skill: %v", err)
}
// Good workflow must still be registered.
if _, ok := reg["good"]; !ok {
t.Error("'good' workflow missing — broken skill blocked registry build")
}
// Bad workflow must not be registered (it had no valid stages).
if _, ok := reg["bad"]; ok {
// It might fall back to built-in "bad" — that's fine.
// But it should NOT be the empty workflow from the broken skill.
t.Log("'bad' workflow present (may be built-in fallback)")
}
// Built-in fallbacks must still exist.
if _, ok := reg["implement"]; !ok {
t.Error("built-in 'implement' missing after broken skill was skipped")
}
}