Maker mode

{
  "version": 1,
  "createdAt": "2026-03-01T10:30:00Z",
  "provider": "aws",
  "question": "Create an S3 bucket for logs",
  "summary": "Creates an S3 bucket with server-side encryption",
  "commands": [
    {
      "args": ["s3api", "create-bucket", "--bucket", "my-logs-<DEPLOY_ID>", "--region", "us-east-1"],
      "reason": "Create the S3 bucket",
      "produces": {"BUCKET_NAME": "$.Location"}
    },
    {
      "args": ["s3api", "put-bucket-encryption", "--bucket", "<BUCKET_NAME>", "--server-side-encryption-configuration", "{...}"],
      "reason": "Enable encryption at rest"
    }
  ],
  "notes": ["Bucket name includes unique deploy ID to avoid conflicts"]
}

func applyPlanBindings(args []string, bindings map[string]string) []string {
    if len(args) == 0 || len(bindings) == 0 {
        return args
    }
    out := make([]string, 0, len(args))
    for _, a := range args {
        if !strings.Contains(a, "<") || !strings.Contains(a, ">") {
            out = append(out, a)
            continue
        }
        rewritten := planPlaceholderTokenRe.ReplaceAllStringFunc(a, func(m string) string {
            key := strings.TrimSuffix(strings.TrimPrefix(m, "<"), ">")
            if v, ok := bindings[key]; ok && strings.TrimSpace(v) != "" {
                return v
            }
            return m
        })
        out = append(out, rewritten)
    }
    // fix: if --role-name got an ARN, extract just the role name
    out = fixRoleNameArg(out)
    return out
}

for idx, cmdSpec := range plan.Commands {
    if resumeFromIndex > 0 && idx < resumeFromIndex {
        _, _ = fmt.Fprintf(opts.Writer, "[maker][checkpoint] skipping already-completed command %d/%d\n", idx+1, len(plan.Commands))
        continue
    }
    _, _ = fmt.Fprintf(opts.Writer, "[maker][checkpoint] start command %d/%d\n", idx+1, len(plan.Commands))

    if err := validateCommand(cmdSpec.Args, opts.Destroyer); err != nil {
        _ = maybeSwarmDiagnose(ctx, opts, "preflight: command rejected", cmdSpec.Args, err.Error(), bindings)
        return fmt.Errorf("command %d rejected: %w", idx+1, err)
    }

    args := make([]string, 0, len(cmdSpec.Args)+6)
    args = append(args, cmdSpec.Args...)
    args = substituteAccountID(args, accountID)
    args = applyPlanBindings(args, bindings)

    // ... (handle special cases like Lambda zip, EC2 user-data, etc.)

    awsArgs := buildAWSExecArgs(args, opts, opts.Writer)

    _, _ = fmt.Fprintf(opts.Writer, "[maker] running %d/%d: %s\n", idx+1, len(plan.Commands), formatAWSArgsForLog(awsArgs))

    out, runErr := runAWSCommandStreaming(ctx, awsArgs, zipBytes, opts.Writer)
    if runErr != nil {
        if handled, handleErr := handleAWSFailure(ctx, plan, opts, idx, args, awsArgs, zipBytes, out, runErr, remediationAttempted, bindings, healPolicy, healRuntime); handled {
            if handleErr != nil {
                return handleErr
            }
            // Retry succeeded
            continue
        }
        return fmt.Errorf("aws command %d failed: %w", idx+1, runErr)
    }

    // Learn placeholder bindings from successful command outputs.
    learnPlanBindingsFromProduces(cmdSpec.Produces, out, bindings)
    learnPlanBindings(args, out, bindings)
    bindings["CHECKPOINT_LAST_SUCCESS_INDEX"] = strconv.Itoa(idx + 1)

    // CloudFormation is async. If we just created/updated a stack, wait for it to complete.
    if len(args) >= 2 && args[0] == "cloudformation" && (args[1] == "create-stack" || args[1] == "update-stack") {
        stackName := strings.TrimSpace(flagValue(args, "--stack-name"))
        if stackName != "" {
            status, details, waitErr := waitForCloudFormationStackTerminal(ctx, opts, stackName, opts.Writer)
            if waitErr != nil {
                return fmt.Errorf("cloudformation wait failed for %s: %w", stackName, waitErr)
            }
            if !isCloudFormationStackSuccess(status) {
                // ... (handle failure with AI retry)
            }
        }
    }

    _, _ = fmt.Fprintf(opts.Writer, "[maker][checkpoint] success command %d/%d\n", idx+1, len(plan.Commands))
}

type agenticFix struct {
    // RewrittenArgs: if non-nil, use these args instead of the original
    RewrittenArgs []string `json:"rewritten_args,omitempty"`
    // PreCommands: commands to run before retrying the original
    PreCommands []Command `json:"pre_commands,omitempty"`
    // Bindings: new placeholder bindings discovered
    Bindings map[string]string `json:"bindings,omitempty"`
    // Skip: if true, skip this command (it's already done or not needed)
    Skip bool `json:"skip,omitempty"`
    // Notes: explanation
    Notes []string `json:"notes,omitempty"`
}