release v0.14.0: native Codex agent rendering, promotion collision detection, OpenCode disabled tools fix

Pack agents with harness.codex frontmatter overrides now render as
self-contained TOML files in .codex/agents/ with registration entries in
config.toml, matching Codex's native multi-agent format.

General frontmatter stripping ensures harness-specific fields are removed
when content is rendered as markdown for harnesses that don't support them.

Cline harness now detects promotion name collisions between skills,
workflows, and agents during sync.

OpenCode capture correctly parses disabled tools from settings.

Author: dfoster-oracle

CHANGELOG.md

@@ -6,6 +6,23 @@ The format is based on Keep a Changelog, and releases use semantic versioning ta
 
 ## Unreleased
 
+## [0.14.0]
+
+### Added
+
+- Native Codex agent rendering. Pack agents with `harness.codex` frontmatter overrides now render as self-contained TOML files in `.codex/agents/` with registration entries in `config.toml`, matching Codex's native multi-agent format. Agents can declare per-harness config (model, reasoning effort, service tier) under a `harness:` namespace in frontmatter.
+- General frontmatter stripping for cross-harness rendering. Harness-specific frontmatter fields (e.g., `harness:` on agents, `paths:` on rules) are automatically stripped when content is rendered as markdown for harnesses that don't support them.
+- Promotion collision detection for Cline harness. Skills, workflows, and agents that would collide in the same skill directory are now caught during sync with a descriptive error.
+
+### Changed
+
+- Codex Layout now manages `.codex/agents/` alongside `.agents/skills/` for validation, cleanup, and stale-file detection.
+- Codex `config.toml` Strip/Reset functions now handle both `mcp_servers` and `agents` managed keys.
+
+### Fixed
+
+- OpenCode capture now correctly parses disabled tools from settings, populating `DisabledTools` on captured MCP servers instead of silently dropping them.
+
 ## [0.13.1]
 
 ### Changed

VERSION

@@ -1 +1 @@
-0.13.1
+0.14.0

internal/domain/content.go

@@ -9,13 +9,18 @@ type RuleFrontmatter struct {
 }
 
 // AgentFrontmatter is the harness-neutral agent frontmatter schema.
+// The Harness field carries per-harness configuration overrides (e.g. model,
+// reasoning_effort) keyed by harness ID. Harness adapters read their own key
+// during native rendering and the field is stripped when agents are rendered
+// as markdown for model consumption.
 type AgentFrontmatter struct {
-	Name            string   `yaml:"name,omitempty"`
-	Description     string   `yaml:"description,omitempty"`
-	Tools           []string `yaml:"tools,omitempty"`
-	DisallowedTools []string `yaml:"disallowed_tools,omitempty"`
-	Skills          []string `yaml:"skills,omitempty"`
-	MCPServers      []string `yaml:"mcp_servers,omitempty"`
+	Name            string                    `yaml:"name,omitempty"`
+	Description     string                    `yaml:"description,omitempty"`
+	Tools           []string                  `yaml:"tools,omitempty"`
+	DisallowedTools []string                  `yaml:"disallowed_tools,omitempty"`
+	Skills          []string                  `yaml:"skills,omitempty"`
+	MCPServers      []string                  `yaml:"mcp_servers,omitempty"`
+	Harness         map[string]map[string]any `yaml:"harness,omitempty"`
 }
 
 // WorkflowFrontmatter is the harness-neutral workflow frontmatter schema.

internal/domain/domain_test.go

@@ -6,6 +6,8 @@ import (
 	"sort"
 	"testing"
 	"time"
+
+	"gopkg.in/yaml.v3"
 )
 
 func TestSplitFrontmatter_WithFrontmatter(t *testing.T) {
@@ -519,6 +521,48 @@ func TestLedger_PrevManagedOverlay_CleanedPath(t *testing.T) {
 	}
 }
 
+func TestAgentFrontmatter_HarnessMapParsed(t *testing.T) {
+	t.Parallel()
+	raw := []byte("---\nname: explorer\ndescription: Fast exploration\nharness:\n  codex:\n    model: o3\n    model_reasoning_effort: high\n---\n\nYou explore code.\n")
+	fmBytes, _, err := SplitFrontmatter(raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fm AgentFrontmatter
+	if err := yaml.Unmarshal(fmBytes, &fm); err != nil {
+		t.Fatal(err)
+	}
+	codex, ok := fm.Harness["codex"]
+	if !ok {
+		t.Fatal("expected harness.codex key")
+	}
+	if codex["model"] != "o3" {
+		t.Fatalf("model = %v, want o3", codex["model"])
+	}
+	if codex["model_reasoning_effort"] != "high" {
+		t.Fatalf("reasoning = %v, want high", codex["model_reasoning_effort"])
+	}
+}
+
+func TestAgentFrontmatter_HarnessOmittedWhenEmpty(t *testing.T) {
+	t.Parallel()
+	fm := AgentFrontmatter{
+		Name:        "simple",
+		Description: "No harness config",
+	}
+	out, err := yaml.Marshal(fm)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var m map[string]any
+	if err := yaml.Unmarshal(out, &m); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := m["harness"]; ok {
+		t.Fatal("harness key should be omitted when nil")
+	}
+}
+
 func TestProfile_SettingsPackName(t *testing.T) {
 	t.Parallel()
 	p := NewProfile()

internal/engine/frontmatter_strip.go

@@ -0,0 +1,28 @@
+package engine
+
+import (
+	"gopkg.in/yaml.v3"
+)
+
+// StripFrontmatterKeys marshals a frontmatter struct to a map, removes the
+// named keys, and returns clean YAML bytes. Used by harness adapters to strip
+// fields the target harness doesn't support before rendering content as
+// markdown for model consumption.
+//
+// Examples: "harness" on agents (only meaningful to the native Codex adapter),
+// "paths" on rules (only Claude Code supports conditional path loading).
+func StripFrontmatterKeys(fm any, keys ...string) ([]byte, error) {
+	// Marshal the struct to a generic map so we can remove arbitrary keys.
+	raw, err := yaml.Marshal(fm)
+	if err != nil {
+		return nil, err
+	}
+	var m map[string]any
+	if err := yaml.Unmarshal(raw, &m); err != nil {
+		return nil, err
+	}
+	for _, k := range keys {
+		delete(m, k)
+	}
+	return yaml.Marshal(m)
+}

internal/engine/frontmatter_strip_test.go

@@ -0,0 +1,95 @@
+package engine
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/shrug-labs/aipack/internal/domain"
+)
+
+func TestStripFrontmatterKeys_Agent_RemovesHarness(t *testing.T) {
+	t.Parallel()
+	fm := domain.AgentFrontmatter{
+		Name:        "explorer",
+		Description: "Fast exploration",
+		Tools:       []string{"Read", "Grep"},
+		Harness: map[string]map[string]any{
+			"codex": {"model": "o3"},
+		},
+	}
+	out, err := StripFrontmatterKeys(fm, "harness")
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(out)
+	if strings.Contains(s, "harness") {
+		t.Fatalf("should strip harness key, got:\n%s", s)
+	}
+	if !strings.Contains(s, "explorer") {
+		t.Fatal("should preserve name")
+	}
+	if !strings.Contains(s, "Read") {
+		t.Fatal("should preserve tools")
+	}
+}
+
+func TestStripFrontmatterKeys_Rule_RemovesPaths(t *testing.T) {
+	t.Parallel()
+	fm := domain.RuleFrontmatter{
+		Name:        "my-rule",
+		Description: "Does things",
+		Paths:       []string{"src/**/*.go"},
+	}
+	out, err := StripFrontmatterKeys(fm, "paths")
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(out)
+	if strings.Contains(s, "paths") {
+		t.Fatalf("should strip paths key, got:\n%s", s)
+	}
+	if !strings.Contains(s, "my-rule") {
+		t.Fatal("should preserve name")
+	}
+}
+
+func TestStripFrontmatterKeys_NoKeysToStrip(t *testing.T) {
+	t.Parallel()
+	fm := domain.AgentFrontmatter{
+		Name:        "simple",
+		Description: "No harness-specific fields",
+	}
+	out, err := StripFrontmatterKeys(fm, "harness")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(out), "simple") {
+		t.Fatal("should preserve content when nothing to strip")
+	}
+}
+
+func TestStripFrontmatterKeys_MultipleKeys(t *testing.T) {
+	t.Parallel()
+	fm := domain.AgentFrontmatter{
+		Name:        "test",
+		Description: "test agent",
+		Tools:       []string{"Read"},
+		Harness: map[string]map[string]any{
+			"codex": {"model": "o3"},
+		},
+	}
+	out, err := StripFrontmatterKeys(fm, "harness", "tools")
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(out)
+	if strings.Contains(s, "harness") {
+		t.Fatal("should strip harness")
+	}
+	if strings.Contains(s, "tools") {
+		t.Fatal("should strip tools")
+	}
+	if !strings.Contains(s, "test") {
+		t.Fatal("should preserve name")
+	}
+}

internal/engine/parse.go

@@ -162,7 +162,14 @@ func RenderRuleBytes(rule domain.Rule) ([]byte, error) {
 }
 
 func RenderAgentBytes(agent domain.Agent) ([]byte, error) {
-	return renderTypedContent(agent.Frontmatter, agent.Body)
+	// Strip harness-specific keys before rendering to markdown — they are
+	// only meaningful to native harness adapters (e.g. Codex), not to models
+	// consuming the rendered markdown.
+	fm, err := StripFrontmatterKeys(agent.Frontmatter, "harness")
+	if err != nil {
+		return nil, err
+	}
+	return renderFrontmatterBytes(fm, agent.Body)
 }
 
 func RenderWorkflowBytes(workflow domain.Workflow) ([]byte, error) {
@@ -177,7 +184,16 @@ func renderTypedContent(frontmatter any, body []byte) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
+	return renderFrontmatterBytes(fm, body)
+}
+
+// renderFrontmatterBytes combines pre-marshaled YAML frontmatter bytes with a
+// markdown body into a complete frontmatter document.
+func renderFrontmatterBytes(fm []byte, body []byte) ([]byte, error) {
 	fm = bytes.TrimRight(fm, "\n")
+	if len(fm) == 0 {
+		return append([]byte(nil), body...), nil
+	}
 	var out bytes.Buffer
 	out.WriteString("---\n")
 	out.Write(fm)

internal/engine/parse_test.go

@@ -370,6 +370,69 @@ func TestRenderAgentBytes_NeutralSchema(t *testing.T) {
 	}
 }
 
+func TestRenderAgentBytes_StripsHarness(t *testing.T) {
+	t.Parallel()
+	agent := domain.Agent{
+		Frontmatter: domain.AgentFrontmatter{
+			Name:        "explorer",
+			Description: "Fast exploration",
+			Tools:       []string{"Read"},
+			Harness: map[string]map[string]any{
+				"codex": {"model": "o3", "model_reasoning_effort": "high"},
+			},
+		},
+		Body: []byte("You explore.\n"),
+	}
+	out, err := RenderAgentBytes(agent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(out)
+	if strings.Contains(s, "harness") {
+		t.Fatalf("rendered markdown should not contain harness block:\n%s", s)
+	}
+	if strings.Contains(s, "codex") {
+		t.Fatalf("rendered markdown should not contain harness-specific keys:\n%s", s)
+	}
+	if !strings.Contains(s, "explorer") {
+		t.Fatal("should preserve name")
+	}
+	if !strings.Contains(s, "You explore.") {
+		t.Fatal("should preserve body")
+	}
+}
+
+func TestRenderAgentBytes_RoundTripsWithHarness(t *testing.T) {
+	t.Parallel()
+	agent := domain.Agent{
+		Frontmatter: domain.AgentFrontmatter{
+			Name:        "reviewer",
+			Description: "Reviews changes",
+			Tools:       []string{"bash", "read"},
+			Harness: map[string]map[string]any{
+				"codex": {"model": "o3"},
+			},
+		},
+		Body: []byte("Review\n"),
+	}
+	raw, err := RenderAgentBytes(agent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Parse should succeed — harness is stripped, so no round-trip of that field.
+	parsed, err := ParseAgentBytes(raw, "reviewer", "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if parsed.Frontmatter.Description != "Reviews changes" {
+		t.Fatalf("Description = %q", parsed.Frontmatter.Description)
+	}
+	// Harness should NOT round-trip through markdown rendering.
+	if parsed.Frontmatter.Harness != nil {
+		t.Fatalf("Harness should be nil after round-trip, got %v", parsed.Frontmatter.Harness)
+	}
+}
+
 func TestParseRules_MissingFile(t *testing.T) {
 	t.Parallel()
 	dir := t.TempDir()

internal/harness/cline/harness.go

@@ -95,10 +95,17 @@ func planProject(f *domain.Fragment, ctx engine.SyncContext) error {
 	rulesDir := filepath.Join(pd, paths.RulesDir)
 	skillsDir := filepath.Join(pd, paths.SkillsDir)
 
+	skills := ctx.Profile.AllSkills()
+	agents := ctx.Profile.AllAgents()
+
+	if err := harness.CheckPromotionCollisions(skills, nil, agents); err != nil {
+		return fmt.Errorf("cline: %w", err)
+	}
+
 	f.AddRuleWrites(rulesDir, "", ctx.Profile.AllRules())
 	f.AddWorkflowWrites(filepath.Join(pd, paths.WorkflowsDir), "", ctx.Profile.AllWorkflows())
-	f.AddSkillCopies(skillsDir, "", ctx.Profile.AllSkills())
-	addPromotedAgents(f, skillsDir, ctx.Profile.AllAgents())
+	f.AddSkillCopies(skillsDir, "", skills)
+	addPromotedAgents(f, skillsDir, agents)
 
 	// Cline MCP settings are always global — sync them even in project scope.
 	return planGlobalMCP(f, ctx)
@@ -107,10 +114,17 @@ func planProject(f *domain.Fragment, ctx engine.SyncContext) error {
 func planGlobal(f *domain.Fragment, ctx engine.SyncContext) error {
 	paths := GlobalPathsFor(ctx.TargetDir)
 
+	skills := ctx.Profile.AllSkills()
+	agents := ctx.Profile.AllAgents()
+
+	if err := harness.CheckPromotionCollisions(skills, nil, agents); err != nil {
+		return fmt.Errorf("cline: %w", err)
+	}
+
 	f.AddRuleWrites(paths.RulesDir, "", ctx.Profile.AllRules())
 	f.AddWorkflowWrites(paths.WorkflowsDir, "", ctx.Profile.AllWorkflows())
-	f.AddSkillCopies(paths.SkillsDir, "", ctx.Profile.AllSkills())
-	addPromotedAgents(f, paths.SkillsDir, ctx.Profile.AllAgents())
+	f.AddSkillCopies(paths.SkillsDir, "", skills)
+	addPromotedAgents(f, paths.SkillsDir, agents)
 
 	return planGlobalMCP(f, ctx)
 }

internal/harness/cline/promote.go

@@ -26,6 +26,9 @@ func addPromotedAgents(f *domain.Fragment, skillsDir string, agents []domain.Age
 		if desc == "" {
 			desc = fmt.Sprintf("Agent: %s", name)
 		}
+		if !strings.HasPrefix(desc, harness.DescPrefixAgent) {
+			desc = harness.DescPrefixAgent + desc
+		}
 		fm := harness.PromotedFrontmatter{
 			Name:            name,
 			Description:     desc,