426 lines
16 KiB
Go
426 lines
16 KiB
Go
// This file implements the /goal command (mirrors pi-goal / Claude Code's goal
|
||
// mode): given a high-level objective, pigo runs the agent autonomously —
|
||
// re-prompting it turn after turn from the loop's follow-up seam — until the
|
||
// model declares the goal done (goal_complete), reports a true impasse
|
||
// (goal_blocked), or a safety guard (max turns / no-progress) or the token
|
||
// budget stops it.
|
||
//
|
||
// /goal is intercepted in the REPL loop rather than routed through a slash
|
||
// Action closure because it must run agent streams and mutate the shared
|
||
// context and goal state — none of which a pure string→string Action can do,
|
||
// exactly like /compact and /fork. It reaches the session's collaborators and
|
||
// mutable state through the cli.Host contract, so it need not import the
|
||
// concrete replDeps aggregate that assembles them.
|
||
//
|
||
// Scope: core autonomous continuation plus an optional token budget. Goal state
|
||
// lives only in the session's in-memory GoalState (host.Goal()); it is not
|
||
// persisted across process restarts.
|
||
package goal
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"io"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/smallnest/pigo/internal/agentcore"
|
||
"github.com/smallnest/pigo/internal/agenttool"
|
||
"github.com/smallnest/pigo/internal/cli"
|
||
"github.com/smallnest/pigo/internal/cli/run"
|
||
"github.com/smallnest/pigo/internal/cli/ui"
|
||
"github.com/smallnest/pigo/internal/compaction"
|
||
"github.com/smallnest/pigo/internal/hooks"
|
||
"github.com/smallnest/pigo/internal/provider"
|
||
"github.com/smallnest/pigo/internal/runtime"
|
||
"github.com/smallnest/pigo/internal/trust"
|
||
)
|
||
|
||
// goalMaxAutomaticTurns caps how many autonomous continuations a single /goal
|
||
// run will issue before pausing, a runaway guard (mirrors pi-goal's automaticTurns).
|
||
const goalMaxAutomaticTurns = 25
|
||
|
||
// goalMaxNoProgress pauses the run after this many consecutive tool-free
|
||
// continuations, so a model looping without acting cannot spin forever (mirrors
|
||
// pi-goal's noProgressTurns).
|
||
const goalMaxNoProgress = 3
|
||
|
||
// runGoal parses and dispatches a /goal invocation. setCancel publishes the
|
||
// active run's cancel func so the REPL's SIGINT handler can interrupt an
|
||
// autonomous run (same plumbing as a normal turn).
|
||
func RunGoal(setCancel func(context.CancelFunc), out io.Writer, host cli.Host, line string) {
|
||
args := strings.TrimSpace(strings.TrimPrefix(line, "/goal"))
|
||
|
||
switch {
|
||
case args == "":
|
||
printGoalStatus(out, host.Goal())
|
||
return
|
||
case args == "clear":
|
||
host.Goal().Clear()
|
||
fmt.Fprintln(out, "goal cleared")
|
||
return
|
||
case args == "pause":
|
||
snap := host.Goal().Snapshot()
|
||
if snap.Status != agenttool.GoalActive && snap.Status != agenttool.GoalPaused {
|
||
fmt.Fprintln(out, "no active goal to pause")
|
||
return
|
||
}
|
||
host.Goal().SetStatus(agenttool.GoalPaused)
|
||
fmt.Fprintln(out, "goal paused — run /goal resume to continue")
|
||
return
|
||
case args == "resume":
|
||
snap := host.Goal().Snapshot()
|
||
if snap.Status != agenttool.GoalPaused && snap.Status != agenttool.GoalBudgetLimited {
|
||
fmt.Fprintln(out, "no paused goal to resume")
|
||
return
|
||
}
|
||
host.Goal().Resume()
|
||
fmt.Fprintf(out, "resuming goal: %s\n", ui.OneLine(snap.Objective))
|
||
runGoalLoop(setCancel, out, host)
|
||
return
|
||
}
|
||
|
||
// Otherwise args is a new objective, optionally prefixed with --tokens N.
|
||
objective, budget, err := parseGoalObjective(args)
|
||
if err != nil {
|
||
fmt.Fprintf(out, "pigo: %v\n", err)
|
||
return
|
||
}
|
||
if strings.TrimSpace(objective) == "" {
|
||
fmt.Fprintln(out, "usage: /goal [--tokens N] <objective>")
|
||
return
|
||
}
|
||
host.Goal().Start(newGoalID(), objective, budget)
|
||
if budget > 0 {
|
||
fmt.Fprintf(out, "goal set (token budget %d): %s\n", budget, ui.OneLine(objective))
|
||
} else {
|
||
fmt.Fprintf(out, "goal set: %s\n", ui.OneLine(objective))
|
||
}
|
||
runGoalLoop(setCancel, out, host)
|
||
}
|
||
|
||
// newGoalID returns a short unique id for a goal (used to key goal_complete's
|
||
// exact-id contract in a future extension; here it just labels the goal).
|
||
func newGoalID() string { return "goal-" + strconv.FormatInt(time.Now().UnixNano(), 36) }
|
||
|
||
// parseGoalObjective splits an optional leading "--tokens N" flag from the
|
||
// objective text. N accepts a bare integer or a k/m suffix (100k, 1m). The flag
|
||
// must lead; anything after it (or the whole string when absent) is the
|
||
// objective.
|
||
func parseGoalObjective(args string) (objective string, budget int, err error) {
|
||
rest := args
|
||
if strings.HasPrefix(rest, "--tokens") {
|
||
rest = strings.TrimSpace(strings.TrimPrefix(rest, "--tokens"))
|
||
// The value is the next whitespace-delimited token.
|
||
var valTok string
|
||
if i := strings.IndexAny(rest, " \t"); i >= 0 {
|
||
valTok = rest[:i]
|
||
rest = strings.TrimSpace(rest[i+1:])
|
||
} else {
|
||
valTok = rest
|
||
rest = ""
|
||
}
|
||
budget, err = parseTokenBudget(valTok)
|
||
if err != nil {
|
||
return "", 0, err
|
||
}
|
||
}
|
||
return rest, budget, nil
|
||
}
|
||
|
||
// parseTokenBudget parses a token count with an optional k/m (×1000/×1000000)
|
||
// suffix, case-insensitive. It rejects a non-positive or malformed value.
|
||
func parseTokenBudget(s string) (int, error) {
|
||
s = strings.TrimSpace(strings.ToLower(s))
|
||
if s == "" {
|
||
return 0, fmt.Errorf("--tokens requires a value (e.g. --tokens 100k)")
|
||
}
|
||
mult := 1
|
||
switch {
|
||
case strings.HasSuffix(s, "k"):
|
||
mult = 1000
|
||
s = strings.TrimSuffix(s, "k")
|
||
case strings.HasSuffix(s, "m"):
|
||
mult = 1000000
|
||
s = strings.TrimSuffix(s, "m")
|
||
}
|
||
n, convErr := strconv.Atoi(s)
|
||
if convErr != nil || n <= 0 {
|
||
return 0, fmt.Errorf("invalid --tokens value %q (want a positive number, optionally with k/m)", s)
|
||
}
|
||
return n * mult, nil
|
||
}
|
||
|
||
// goalContinuationPrompt is the follow-up injected each autonomous turn to keep
|
||
// the model working toward the goal. The objective itself is re-stated every
|
||
// turn by the GoalReminderProvider, so this only nudges continuation.
|
||
const goalContinuationPrompt = "Continue working toward the goal. When every requirement is " +
|
||
"verifiably met, call goal_complete with a summary. If you hit a true impasse you cannot work " +
|
||
"around, call goal_blocked with concrete evidence. Otherwise keep going — do not stop or ask " +
|
||
"the user whether to continue."
|
||
|
||
// goalFollowUpDecision decides, from a goal snapshot, whether the autonomous
|
||
// loop should issue another continuation turn. It is pure so the branch logic
|
||
// (complete/blocked terminal states, token budget, turn cap, no-progress guard)
|
||
// can be unit-tested without running a real agent stream. The returned status is
|
||
// the terminal status to record when cont is false (GoalIdle means "leave the
|
||
// status as-is" — used for the already-terminal complete/blocked cases).
|
||
func goalFollowUpDecision(snap agenttool.GoalSnapshot) (cont bool, terminal agenttool.GoalStatus) {
|
||
switch snap.Status {
|
||
case agenttool.GoalComplete, agenttool.GoalBlocked:
|
||
// A goal tool already ended the run; nothing to continue.
|
||
return false, agenttool.GoalIdle
|
||
}
|
||
if snap.TokenBudget > 0 && snap.TokensUsed >= snap.TokenBudget {
|
||
return false, agenttool.GoalBudgetLimited
|
||
}
|
||
if snap.Iterations >= goalMaxAutomaticTurns {
|
||
return false, agenttool.GoalPaused
|
||
}
|
||
if snap.NoProgress >= goalMaxNoProgress {
|
||
return false, agenttool.GoalPaused
|
||
}
|
||
return true, agenttool.GoalIdle
|
||
}
|
||
|
||
// runGoalLoop drives the autonomous goal run. It assembles a run just like
|
||
// streamRun but with the goal tools (goal_complete/goal_blocked) added, the goal
|
||
// reminder wired alongside the todo reminder, and a GetFollowUpMessages hook that
|
||
// re-prompts the model each time the inner loop settles — until a goal tool ends
|
||
// the run or goalFollowUpDecision trips a guard. On return it prints the outcome
|
||
// and persists the turn. The run reuses the REPL's SIGINT cancel plumbing via
|
||
// setCancel.
|
||
func runGoalLoop(setCancel func(context.CancelFunc), out io.Writer, host cli.Host) {
|
||
goalReg := goalToolRegistry(host.Registry(), host.Goal())
|
||
reminders := goalReminders(host.Registry(), host.Goal())
|
||
|
||
runCtx, cancel := context.WithCancel(context.Background())
|
||
setCancel(cancel)
|
||
defer func() {
|
||
cancel()
|
||
setCancel(nil)
|
||
}()
|
||
|
||
// lastSeen tracks how many messages we have already accounted for, so each
|
||
// settle folds in only the assistant turns produced since the previous one:
|
||
// their output tokens (budget) and whether any tool ran (no-progress guard).
|
||
lastSeen := len(host.AgentCtx().Messages)
|
||
|
||
cfg := runtime.RunConfig{
|
||
LoopConfig: runtime.LoopConfig{
|
||
Model: host.Live().Model,
|
||
Provider: host.Live().ProviderName,
|
||
ThinkingLevel: host.Live().ThinkingLevel,
|
||
Stream: provider.StreamFnFromProvider(host.Live().Provider),
|
||
GetAPIKey: host.Creds().GetAPIKey,
|
||
ContextWindow: host.Live().ContextWindow,
|
||
Compaction: compaction.DefaultCompactionSettings,
|
||
},
|
||
Batch: agenttool.BatchConfig{
|
||
ToolExecutorConfig: agenttool.ToolExecutorConfig{
|
||
Registry: goalReg,
|
||
BeforeToolCall: trust.BeforeToolCall(host.Trust(), host.Cwd(), host.Input(), out, host.ConfirmMu()),
|
||
},
|
||
},
|
||
Reminders: reminders,
|
||
GetFollowUpMessages: func(ctx context.Context, agentCtx *agentcore.AgentContext) []agentcore.AgentMessage {
|
||
// Account for the turns produced since the last settle. Auto-compaction
|
||
// can shrink agentCtx.Messages in place (summary + tail) between settles,
|
||
// dropping its length below lastSeen; clamp so the slice never goes out
|
||
// of bounds. The compacted turn's tokens are then under-counted, which is
|
||
// acceptable for a soft budget guard (a crash is not).
|
||
if lastSeen > len(agentCtx.Messages) {
|
||
lastSeen = len(agentCtx.Messages)
|
||
}
|
||
outputTokens, hadTool := goalTurnActivity(agentCtx.Messages[lastSeen:])
|
||
lastSeen = len(agentCtx.Messages)
|
||
host.Goal().RecordIteration(outputTokens, hadTool)
|
||
|
||
cont, terminal := goalFollowUpDecision(host.Goal().Snapshot())
|
||
if !cont {
|
||
if terminal != agenttool.GoalIdle {
|
||
host.Goal().SetStatus(terminal)
|
||
}
|
||
return nil
|
||
}
|
||
return []agentcore.AgentMessage{agentcore.UserMessage{
|
||
RoleField: agentcore.RoleUser,
|
||
Content: agentcore.ContentList{agentcore.NewTextContent(goalContinuationPrompt)},
|
||
}}
|
||
},
|
||
}
|
||
|
||
// Wire the per-turn hook seams (PreToolUse/PostToolUse/Stop) onto this goal
|
||
// run's cfg from the session dispatcher; a nil dispatcher is a no-op (FR-18).
|
||
if d := host.Dispatcher(); d != nil {
|
||
run.InstallSeams(&cfg, d, host.HookDeps())
|
||
}
|
||
|
||
// The first turn is driven by the goal reminder alone (the objective is
|
||
// injected as background context); no explicit user prompt is appended so the
|
||
// objective is not duplicated in the durable history.
|
||
stream := runtime.StartRun(runCtx, host.AgentCtx(), cfg)
|
||
drainGoalStream(runCtx, out, host, stream)
|
||
|
||
printGoalOutcome(out, host.Goal().Snapshot())
|
||
cli.PersistTurn(out, host)
|
||
}
|
||
|
||
// goalToolRegistry returns a registry holding every tool from base plus the two
|
||
// goal-control tools, so the autonomous run can invoke goal_complete/goal_blocked
|
||
// while keeping all the normal tools available. The base registry is left
|
||
// unchanged (the goal tools are only present for the goal run).
|
||
func goalToolRegistry(base *agenttool.ToolRegistry, state *agenttool.GoalState) *agenttool.ToolRegistry {
|
||
reg := agenttool.NewToolRegistry()
|
||
if base != nil {
|
||
for _, t := range base.List() {
|
||
_ = reg.Register(t)
|
||
}
|
||
}
|
||
_ = reg.Register(&agenttool.GoalCompleteTool{State: state})
|
||
_ = reg.Register(&agenttool.GoalBlockedTool{State: state})
|
||
return reg
|
||
}
|
||
|
||
// goalReminders builds the per-turn reminder registry for a goal run: the goal
|
||
// reminder (re-stating the objective every turn) plus the todo reminder when a
|
||
// todo tool is present, so an autonomous run keeps both its objective and its
|
||
// task list in view.
|
||
func goalReminders(base *agenttool.ToolRegistry, state *agenttool.GoalState) *runtime.ReminderRegistry {
|
||
reg := runtime.NewReminderRegistry(&runtime.GoalReminderProvider{State: state})
|
||
if base != nil {
|
||
if t, ok := base.Get("todo"); ok {
|
||
if tt, ok := t.(*agenttool.TodoTool); ok && tt.Store != nil {
|
||
reg.Register(&runtime.TodoReminderProvider{Store: tt.Store})
|
||
}
|
||
}
|
||
}
|
||
return reg
|
||
}
|
||
|
||
// goalTurnActivity sums the output tokens across the assistant messages in tail
|
||
// and reports whether any tool ran in that window (an assistant tool call or a
|
||
// tool result). It feeds RecordIteration's token-budget and no-progress inputs.
|
||
func goalTurnActivity(tail []agentcore.AgentMessage) (outputTokens int, hadTool bool) {
|
||
for _, m := range tail {
|
||
switch msg := m.(type) {
|
||
case agentcore.AssistantMessage:
|
||
if msg.Usage != nil {
|
||
outputTokens += msg.Usage.OutputTokens
|
||
}
|
||
if len(msg.ToolCalls()) > 0 {
|
||
hadTool = true
|
||
}
|
||
case agentcore.ToolResultMessage:
|
||
hadTool = true
|
||
}
|
||
}
|
||
return outputTokens, hadTool
|
||
}
|
||
|
||
// drainGoalStream prints the streamed assistant text and tool activity of a goal
|
||
// run to out, mirroring streamRun's rendering. It blocks until the run ends.
|
||
// chainGoalEvent returns the OnEvent observer for a goal run: the plugin
|
||
// notifier, with the SessionEnd/PreCompact hook notifier chained after it when
|
||
// hooks are configured, mirroring the REPL's OnEvent composition.
|
||
func chainGoalEvent(host cli.Host) func(agentcore.AgentEvent) {
|
||
notifier := host.NotifierHandle()
|
||
d := host.Dispatcher()
|
||
if d == nil {
|
||
return notifier
|
||
}
|
||
deps := host.HookDeps()
|
||
hookEvent := hooks.NewHookNotifier(d, deps.SessionID, deps.ProjectDir).Handle
|
||
if notifier == nil {
|
||
return hookEvent
|
||
}
|
||
return func(ev agentcore.AgentEvent) {
|
||
notifier(ev)
|
||
hookEvent(ev)
|
||
}
|
||
}
|
||
|
||
func drainGoalStream(ctx context.Context, out io.Writer, host cli.Host, stream *runtime.LoopEventStream) {
|
||
var reply strings.Builder
|
||
flushReply := func() {
|
||
if reply.Len() == 0 {
|
||
return
|
||
}
|
||
rendered := ui.RenderMarkdown(reply.String())
|
||
fmt.Fprint(out, rendered)
|
||
if !strings.HasSuffix(rendered, "\n") {
|
||
fmt.Fprintln(out)
|
||
}
|
||
reply.Reset()
|
||
}
|
||
_, err := runtime.DrainStream(ctx, stream, runtime.StreamHandler{
|
||
OnEvent: chainGoalEvent(host),
|
||
OnText: func(delta string) {
|
||
reply.WriteString(delta)
|
||
},
|
||
OnTurnEnd: func(msg agentcore.AssistantMessage, results []agentcore.ToolResultMessage) {
|
||
flushReply()
|
||
for _, c := range msg.ToolCalls() {
|
||
fmt.Fprintf(out, " %s %s\n", ui.Colorize(ui.Enabled(), ui.Green, "→ tool:"), ui.ToolCallLabel(c))
|
||
}
|
||
for _, tr := range results {
|
||
ui.RenderToolResult(out, tr)
|
||
}
|
||
},
|
||
})
|
||
flushReply()
|
||
if err != nil {
|
||
if ctx.Err() != nil {
|
||
fmt.Fprintln(out, "^C interrupted — goal paused (run /goal resume to continue)")
|
||
host.Goal().SetStatus(agenttool.GoalPaused)
|
||
} else {
|
||
fmt.Fprintf(out, "error: %v\n", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// printGoalOutcome prints a one-line result banner after a goal run settles,
|
||
// keyed on the terminal status the run reached.
|
||
func printGoalOutcome(out io.Writer, snap agenttool.GoalSnapshot) {
|
||
color := ui.Enabled()
|
||
switch snap.Status {
|
||
case agenttool.GoalComplete:
|
||
fmt.Fprintf(out, "%s goal complete: %s\n", ui.Colorize(color, ui.Green, "✓"), snap.Summary)
|
||
case agenttool.GoalBlocked:
|
||
fmt.Fprintf(out, "%s goal blocked: %s\n", ui.Colorize(color, ui.Red, "⚠"), snap.BlockReason)
|
||
case agenttool.GoalBudgetLimited:
|
||
fmt.Fprintf(out, "%s goal paused — token budget reached (%d / %d). Run /goal resume to continue.\n",
|
||
ui.Colorize(color, ui.Yellow, "⏸"), snap.TokensUsed, snap.TokenBudget)
|
||
case agenttool.GoalPaused:
|
||
fmt.Fprintf(out, "%s goal paused after %d turns. Run /goal resume to continue, or /goal clear to drop it.\n",
|
||
ui.Colorize(color, ui.Yellow, "⏸"), snap.Iterations)
|
||
}
|
||
}
|
||
|
||
// printGoalStatus prints a summary of the current goal state for a bare /goal.
|
||
func printGoalStatus(out io.Writer, goal *agenttool.GoalState) {
|
||
snap := goal.Snapshot()
|
||
if snap.Status == agenttool.GoalIdle {
|
||
fmt.Fprintln(out, "no goal set — run /goal <objective> to start one")
|
||
return
|
||
}
|
||
fmt.Fprintf(out, "goal: %s\n", snap.Objective)
|
||
fmt.Fprintf(out, "status: %s\n", snap.Status)
|
||
fmt.Fprintf(out, "iterations: %d\n", snap.Iterations)
|
||
if snap.TokenBudget > 0 {
|
||
fmt.Fprintf(out, "tokens: %d / %d\n", snap.TokensUsed, snap.TokenBudget)
|
||
} else {
|
||
fmt.Fprintf(out, "tokens: %d (no budget)\n", snap.TokensUsed)
|
||
}
|
||
if !snap.StartedAt.IsZero() {
|
||
fmt.Fprintf(out, "elapsed: %s\n", time.Since(snap.StartedAt).Round(time.Second))
|
||
}
|
||
if snap.Summary != "" {
|
||
fmt.Fprintf(out, "summary: %s\n", snap.Summary)
|
||
}
|
||
if snap.BlockReason != "" {
|
||
fmt.Fprintf(out, "blocked: %s\n", snap.BlockReason)
|
||
}
|
||
}
|