Ask model: "Make a plan"
Execute plan step by step.

export type PlannerInput = {
  taskId: string;
  taskKind:
    | "dependency_upgrade"
    | "api_migration"
    | "config_migration"
    | "test_fix"
    | "bug_fix"
    | "mechanical_refactor"
    | "analysis_only";

  userGoal: string;
  normalizedGoal: string;

  repository: {
    provider: "github" | "gitlab" | "bitbucket" | "local";
    owner: string;
    name: string;
    baseRef: string;
    baseCommitSha: string;
    defaultBranch: string;
    languageHints: string[];
    buildSystemHints: string[];
  };

  scope: {
    includePaths: string[];
    excludePaths: string[];
    maxFilesChanged: number;
    maxLinesChanged: number;
    allowGeneratedFiles: boolean;
    allowLockfileChange: boolean;
    allowPublicApiChange: boolean;
  };

  evidence: EvidenceItem[];
  repositoryMapRef: string;
  symbolIndexRef?: string;
  policySnapshotRef: string;

  risk: {
    initialLevel: "low" | "medium" | "high" | "blocked";
    reasons: string[];
  };
};

export type ExecutionPlan = {
  planId: string;
  taskId: string;
  version: number;
  status: "draft" | "approved" | "active" | "superseded" | "aborted" | "completed";

  intent: {
    goal: string;
    nonGoals: string[];
    expectedOutcome: string;
  };

  scopeBoundary: {
    allowedPaths: string[];
    forbiddenPaths: string[];
    allowedOperations: AgentOperation[];
    forbiddenOperations: AgentOperation[];
  };

  milestones: Milestone[];
  verificationStrategy: VerificationStrategy;
  stopConditions: StopCondition[];
  retryPolicy: RetryPolicy;
  escalationPolicy: EscalationPolicy;
  reviewerNotes: string[];
};

export type Milestone = {
  id: string;
  title: string;
  purpose: string;
  status: "pending" | "active" | "done" | "failed" | "skipped";

  preconditions: string[];
  actions: PlannedAction[];
  expectedArtifacts: string[];
  localVerification: string[];

  allowedFailureModes: string[];
  escalationTriggers: string[];
};

id: M2
judul: Replace deprecated API calls in service layer
purpose: Migrate call sites from LegacyUserClient#getUser to UserDirectoryClient#findUser
preconditions:
  - UserDirectoryClient exists and is injectable in the affected modules
  - LegacyUserClient#getUser call sites have been enumerated
allowed actions:
  - read files under src/main/java
  - edit files under src/main/java/com/acme/user
  - edit tests under src/test/java/com/acme/user
forbidden actions:
  - modify database migration
  - remove tests
  - change public REST response schema
local verification:
  - mvn -pl user-service test
  - mvn -pl user-service -DskipITs compile
escalation triggers:
  - migration requires changing public DTO
  - new API lacks equivalent behavior
  - more than 12 files need modification

1. Understand task and constraints
2. Discover impacted code
3. Build minimal change hypothesis
4. Apply smallest safe patch
5. Verify locally
6. Repair failures within scope
7. Summarize diff and evidence
8. Stop or escalate

function classifyPlanningMode(input: PlannerInput): PlanningMode {
  if (input.risk.initialLevel === "blocked") return "analysis_only";

  if (input.taskKind === "dependency_upgrade") {
    if (input.scope.allowLockfileChange) return "migration";
    return "mechanical";
  }

  if (input.taskKind === "api_migration") {
    if (!input.scope.allowPublicApiChange) return "mechanical";
    return "migration";
  }

  if (input.taskKind === "bug_fix") return "exploratory";

  if (input.scope.maxFilesChanged <= 2) return "tiny_patch";

  return "exploratory";
}

export type StopCondition =
  | { kind: "verification_passed" }
  | { kind: "max_iterations_reached"; maxIterations: number }
  | { kind: "max_files_changed_exceeded"; maxFiles: number }
  | { kind: "forbidden_path_touched"; paths: string[] }
  | { kind: "public_api_change_detected" }
  | { kind: "secret_detected" }
  | { kind: "destructive_command_requested" }
  | { kind: "repeated_same_failure"; threshold: number }
  | { kind: "insufficient_evidence" }
  | { kind: "requires_human_decision"; reason: string };

export type RetryPolicy = {
  maxAgentIterations: number;
  maxVerifierRetries: number;
  maxSameFailureCount: number;
  allowPlanRevision: boolean;
  allowedRepairKinds: Array<
    | "compile_error"
    | "test_failure"
    | "format_failure"
    | "lint_failure"
    | "dependency_resolution_failure"
  >;
};

{
  "fromPlanVersion": 1,
  "toPlanVersion": 2,
  "reason": "Compile error shows migrated method returns Optional<User> instead of User",
  "newEvidence": ["artifact:compile-log-001"],
  "scopeChange": "No new path added; adjust call sites to handle Optional.empty",
  "approvalRequired": false
}

export type Hypothesis = {
  id: string;
  statement: string;
  confidence: "low" | "medium" | "high";
  evidenceFor: string[];
  evidenceAgainst: string[];
  cheapestExperiment: string;
  expectedSignal: string;
};

Legacy:  LegacyUserClient#getUser(String id) -> User
New:     UserDirectoryClient#findUser(UserId id) -> Optional<User>
Goal:    Replace internal service-layer calls without changing REST response schema.

Search and replace getUser with findUser.

semantic_delta:
  input_type:
    old: string
    new: UserId
  return_type:
    old: User
    new: Optional<User>
  error_behavior:
    old: throws UserNotFoundException
    new: Optional.empty
  dependency_injection:
    old: LegacyUserClient
    new: UserDirectoryClient

[
  { "id": "T1", "text": "Inspect old API call sites", "status": "done" },
  { "id": "T2", "text": "Update UserService dependency", "status": "active" },
  { "id": "T3", "text": "Run user-service compile", "status": "pending" }
]

export class PlannerService {
  constructor(
    private readonly policy: PolicyService,
    private readonly repoMap: RepositoryMapService,
    private readonly search: CodeSearchService,
    private readonly llm: LlmClient,
    private readonly planJudge: PlanJudge,
  ) {}

  async createPlan(input: PlannerInput): Promise<ExecutionPlan> {
    const mode = classifyPlanningMode(input);
    const deterministicBoundary = await this.policy.buildScopeBoundary(input);
    const evidencePack = await this.collectPlanningEvidence(input, mode);

    const draft = await this.llmDraftPlan({
      input,
      mode,
      deterministicBoundary,
      evidencePack,
    });

    const normalized = normalizePlan(draft, deterministicBoundary);
    const verdict = await this.planJudge.judge(normalized, input);

    if (!verdict.accepted) {
      throw new PlanRejectedError(verdict.reasons);
    }

    return normalized;
  }
}

LLM drafts the plan.
Policy owns the boundary.
Judge validates the plan.
Runtime executes only validated plan.

You are creating an execution plan for an autonomous coding agent.

Goal:
{{normalized_goal}}

Repository evidence:
{{evidence_pack}}

Non-negotiable constraints:
{{policy_constraints}}

Return JSON matching ExecutionPlan.
Do not invent files.
Every milestone must reference evidence item ids.
Every write action must be within allowed paths.
Every milestone must include local verification or explain why none is possible.
Set escalationRequired=true if the change needs public API, schema, secret, or destructive operation.

export type VerificationStrategy = {
  prePatchChecks: VerifierCommand[];
  postPatchChecks: VerifierCommand[];
  targetedChecks: VerifierCommand[];
  fullChecks: VerifierCommand[];
  passCriteria: string[];
  knownPreExistingFailures?: string[];
};

verification_strategy:
  pre_patch_checks:
    - mvn -pl user-service -DskipTests compile
  targeted_checks:
    - mvn -pl user-service -Dtest=UserServiceTest test
  post_patch_checks:
    - mvn -pl user-service test
  full_checks:
    - mvn test
  pass_criteria:
    - compile succeeds
    - related tests pass
    - no test deleted
    - no public response schema changed

{
  "action": "Modify OrderService because it seems related"
}

{
  "action": "Modify OrderService.submitOrder",
  "evidence": [
    "symbol-ref:OrderService.submitOrder",
    "search-hit:LegacyPricingClient usage in OrderService.java:42",
    "test-ref:OrderServiceTest.shouldApplyDiscount"
  ]
}

create table agent_plan (
  id uuid primary key,
  task_id uuid not null,
  run_id uuid,
  version int not null,
  status text not null,
  planning_mode text not null,
  plan_json jsonb not null,
  created_by text not null,
  created_at timestamptz not null default now(),
  supersedes_plan_id uuid,
  unique(task_id, version)
);

create table agent_plan_event (
  id uuid primary key,
  plan_id uuid not null references agent_plan(id),
  event_type text not null,
  event_json jsonb not null,
  created_at timestamptz not null default now()
);

Upgrade jackson-databind from 2.14.x to 2.17.x in billing-service.

intent:
  goal: Upgrade jackson-databind in billing-service while preserving JSON serialization behavior.
  non_goals:
    - change API schema
    - refactor unrelated JSON code
    - upgrade unrelated dependencies
scope_boundary:
  allowed_paths:
    - billing-service/pom.xml
    - billing-service/src/test/**
    - billing-service/src/main/**
  forbidden_paths:
    - db/migration/**
    - api/openapi/**
    - infra/**
milestones:
  - inspect current dependency graph
  - update dependency version
  - run compile and JSON-related tests
  - repair serialization incompatibilities if any
verification:
  - mvn -pl billing-service dependency:tree
  - mvn -pl billing-service test
stop_conditions:
  - public API schema changed
  - more than 8 files modified
  - dependency convergence failure requires parent BOM change

Fix failing test PaymentRetryPolicyTest.shouldStopAfterThreeAttempts.

mode: exploratory
hypotheses:
  - retry counter off-by-one
  - test fixture no longer matches retry config
  - async scheduler executes extra attempt
first_experiment:
  command: mvn -pl payment -Dtest=PaymentRetryPolicyTest#shouldStopAfterThreeAttempts test
expected_signal:
  - exact assertion failure
  - stack trace location
scope:
  allowed_paths:
    - payment/src/main/java/**
    - payment/src/test/java/**
  forbidden_actions:
    - delete test
    - relax assertion without code evidence
    - disable retry behavior
stop_conditions:
  - failure is flaky/timing dependent and needs design decision
  - fix requires changing public retry contract