Run pipeline stages on Claude Code (harness=claude)

A model stage with harness=claude, provider=anthropic and a Claude model id
runs one claude -p process per visit with the server user's Claude sign-in.
Only the declared tools exist (--tools) and nothing else is approved
(--permission-mode dontAsk); edits are approved only below the run directory
and the stage's artifacts directory. A permissions block, run write paths,
delivery=true and reasoning_effort none/minimal are refused, not widened.

Usage comes from the CLI's final result and counts toward budgets. Failures
are fixed text; billing, quota and rate-limit refusals map to
ErrProviderQuota. The redacted stream is the session export and evidence.
provider-check --harness claude and model overrides are covered.
This commit is contained in:
2026-11-11 10:30:37 +00:00
parent 16643b9f1b
commit bd07abcde8
19 changed files with 1448 additions and 16 deletions
+100
View File
@@ -0,0 +1,100 @@
package server
import (
"context"
"os"
"path/filepath"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// A stand-in Claude Code CLI: it answers the stage with a valid final message.
const fakeClaudeForRun = `#!/bin/sh
if [ "$1" = auth ]; then echo '{"loggedIn":true}'; exit 0; fi
session=""; model=""; prev=""
for a in "$@"; do
case "$prev" in
--session-id|--resume) session="$a" ;;
--model) model="$a" ;;
esac
prev="$a"
done
cat > /dev/null
echo '{"type":"system","subtype":"init","session_id":"'"$session"'","model":"'"$model"'"}'
echo '{"type":"assistant","session_id":"'"$session"'","message":{"role":"assistant","content":[{"type":"text","text":"working"}]}}'
printf '%s\n' '{"type":"result","subtype":"success","is_error":false,"result":"# outcome\nsuccess\n\n# handoff\n\nChanged nothing.\n","session_id":"'"$session"'","total_cost_usd":0.5,"usage":{"input_tokens":4,"output_tokens":6}}'
`
// TestRunnerRunsAClaudeHarnessStage drives a whole run whose only stage uses
// harness=claude through the real runner path: client selection, session
// ownership, usage and the session export gate.
func TestRunnerRunsAClaudeHarnessStage(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
root, err := filepath.EvalSymlinks(t.TempDir())
if err != nil {
t.Fatal(err)
}
t.Setenv("HOME", root)
t.Setenv("XDG_CACHE_HOME", root)
t.Setenv("CLAUDE_CODE_OAUTH_TOKEN", "")
executable := filepath.Join(root, "claude")
if err := os.WriteFile(executable, []byte(fakeClaudeForRun), 0700); err != nil {
t.Fatal(err)
}
t.Setenv("PIPELINES_CLAUDE", executable)
store, err := pipeline.Open(filepath.Join(root, "runs.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
source := strings.Replace(pipeline.Template([]string{"one"}, true), "provider=opencode-go\nmodel=deepseek-v4.1-flash\n", "harness=claude\nprovider=anthropic\nmodel=claude-haiku-5-5\n", 1)
if !strings.Contains(source, "harness=claude") {
t.Fatal("template changed; update this test")
}
if _, err := store.Submit(ctx, "test", source); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
r, err := newRunner(ctx, store)
if err != nil {
t.Fatal(err)
}
workspace := filepath.Join(root, "work")
if err := os.Mkdir(workspace, 0700); err != nil {
t.Fatal(err)
}
request := protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "claude", Workspace: workspace, Input: map[string]any{"prompt": "task"}}
// An override to another provider cannot run on this harness.
refused := request
refused.Model = "opencode-go/deepseek-v4.1-flash"
if _, err := r.start(refused); err == nil || !strings.Contains(err.Error(), "anthropic/<model>") {
t.Fatal("a non-Claude model override was admitted:", err)
}
run, err := r.start(request)
if err != nil {
t.Fatal(err)
}
r.wg.Wait()
detail, err := store.GetRun(ctx, run.ID)
if err != nil {
t.Fatal(err)
}
if detail.Status != "succeeded" || len(detail.Steps) != 1 {
t.Fatalf("run: %s %+v", detail.Status, detail.Steps)
}
step := detail.Steps[0]
if step.Outcome != "success" || step.SessionID == "" || step.Provider != "anthropic" || step.Model != "claude-haiku-5-5" {
t.Fatalf("step: %+v", step)
}
if step.SessionExport == nil || step.SessionExport.Backend != "claude" || step.SessionExport.Diagnostic != "" {
t.Fatalf("session export: %+v", step.SessionExport)
}
if step.Usage == nil {
t.Fatal("no usage recorded")
}
t.Logf("usage %+v export %+v", *step.Usage, *step.SessionExport)
}
+2
View File
@@ -26,6 +26,8 @@ func (r *runner) evidence(ctx context.Context, id int64) ([]protocol.SessionEvid
item.Backend = owner.Backend
if owner.Backend == "pi" {
item.Data, err = stage.PiEvidence(owner.Reference)
} else if owner.Backend == stage.ClaudeBackend {
item.Data, err = stage.ClaudeStageEvidence(owner.Reference)
} else {
item.Data, err = (stage.OpenCodeClient{Directory: owner.Directory, Backend: owner.Backend}).SessionEvidence(ctx, owner.ID)
}
+6
View File
@@ -67,6 +67,9 @@ var interruptRecoveredSession = func(ctx context.Context, owner pipeline.Session
if owner.Backend == "pi" {
return stage.InterruptPi(ctx, owner.Reference)
}
if owner.Backend == stage.ClaudeBackend {
return stage.InterruptClaudeStage(ctx, owner.Reference)
}
return (stage.OpenCodeClient{Backend: owner.Backend, Directory: owner.Directory, Reference: owner.Reference}).InterruptAndConfirm(ctx, owner.ID)
}
@@ -128,6 +131,9 @@ func planReattach(ctx context.Context, s *pipeline.Store) ([]reattachPlan, map[i
if owner.Backend == "pi" {
name = "Pi"
}
if owner.Backend == stage.ClaudeBackend {
name = "Claude Code"
}
reasons[row.ID] = fmt.Sprintf("%s stage sessions belong to the stopped server process, so stage %s could not be reattached", name, last.Stage)
continue
}
+20 -2
View File
@@ -14,6 +14,7 @@ import (
"sync"
"time"
"git.a-wan.net/alan/pipelines/internal/claude"
"git.a-wan.net/alan/pipelines/internal/filediff"
"git.a-wan.net/alan/pipelines/internal/harness"
"git.a-wan.net/alan/pipelines/internal/opencode"
@@ -223,13 +224,20 @@ func (r *runner) startWithSchedule(request protocol.Message, origin *pipeline.Sc
// admission: an unknown stage key or a malformed provider/model must never
// insert a run row. The resolution is O(#overrides + #stages) with no model or
// network call, and the same helper is the authoritative precedence rule.
if _, err := pipeline.EffectiveModels(d.Graph, request.Model, request.StageModels); err != nil {
launchModels, err := pipeline.EffectiveModels(d.Graph, request.Model, request.StageModels)
if err != nil {
return nil, err
}
for _, s := range d.Graph.Stages {
if stage.EffectiveType(s.Type) != stage.ModelType {
continue
}
if s.Configs["harness"] == stage.ClaudeBackend && launchModels[s.Key].Provider != stage.ClaudeProvider {
return nil, fmt.Errorf("stage %q runs on the claude harness and needs an %s/<model> override", s.Key, stage.ClaudeProvider)
}
if s.Configs["harness"] == stage.ClaudeBackend && r.execute == nil && !claude.Available() {
return nil, fmt.Errorf("Claude Code is not installed on this execution server; run pipelines harness setup claude there")
}
if s.Configs["harness"] == "pi" && r.execute == nil {
configured, err := harness.Load()
if err != nil {
@@ -1941,6 +1949,16 @@ func (r *runner) runLoop(ctx context.Context, id int64, graph protocol.Graph, na
result, err = (stage.ModelStage{Client: piClient}).Run(stageCtx, def, input)
stageSession = piClient.SessionID
client.Transcript = piClient.Transcript
} else if modelConfig.Harness == stage.ClaudeBackend {
claudeClient := &stage.ClaudeStageClient{Directory: workspace, Tools: tools, WritePaths: request.WritePaths, ArtifactsDir: artifactsDir}
claudeClient.OnOwnership = func(session, reference string, active bool) error {
c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
return r.store.RunSession(c, id, sequence, session, active, stage.ClaudeBackend, reference)
}
result, err = (stage.ModelStage{Client: claudeClient}).Run(stageCtx, def, input)
stageSession = claudeClient.SessionID
client.Transcript = claudeClient.Transcript
} else if useAgent {
result, err = (stage.ModelStage{Client: client}).Run(stageCtx, def, input)
stageSession = client.SessionID
@@ -2242,7 +2260,7 @@ func (r *runner) runLoop(ctx context.Context, id int64, graph protocol.Graph, na
func (r *runner) exportStageSession(ctx context.Context, owner pipeline.SessionOwner, artifactsDir string, runID int64, sequence int, key string, modelConfig stage.ModelConfig) *protocol.SessionExport {
evidence := &protocol.SessionExport{SessionID: owner.ID, Backend: owner.Backend, Directory: owner.Directory, RecordedAt: time.Now().UTC().Format(time.RFC3339)}
defer classifySessionExport(evidence)
if owner.Backend != "v1" && owner.Backend != "v2" && !(owner.Backend == "pi" && owner.Reference != "") {
if owner.Backend != "v1" && owner.Backend != "v2" && !((owner.Backend == "pi" || owner.Backend == stage.ClaudeBackend) && owner.Reference != "") {
evidence.Source = "unavailable"
evidence.Diagnostic = "session export unavailable: harness has no native export path"
return evidence
+1 -1
View File
@@ -87,7 +87,7 @@ func (r *runner) repairSessionExportOwned(ctx context.Context, id int64, sequenc
}
return r.sessionExportUpdatedDetail(recordCtx, id)
}
if owner.Backend != "v1" && owner.Backend != "v2" && owner.Backend != "pi" {
if owner.Backend != "v1" && owner.Backend != "v2" && owner.Backend != "pi" && owner.Backend != stage.ClaudeBackend {
return recordFailure("native export unavailable for original harness")
}
root, err := os.OpenRoot(r.artifactsRoot)